/[svn]/gigedit/trunk/src/gigedit/mainwindow.cpp
ViewVC logotype

Diff of /gigedit/trunk/src/gigedit/mainwindow.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1322 by schoenebeck, Tue Sep 4 11:04:56 2007 UTC revision 1582 by persson, Sat Dec 8 12:28:53 2007 UTC
# 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
# Line 48  Glib::ustring filename_display_basename( Line 50  Glib::ustring filename_display_basename(
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 56  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 86  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 127  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 182  MainWindow::MainWindow() Line 229  MainWindow::MainWindow()
229          "    </menu>"          "    </menu>"
230          "    <menu action='MenuInstrument'>"          "    <menu action='MenuInstrument'>"
231          "    </menu>"          "    </menu>"
232            "    <menu action='MenuView'>"
233            "      <menuitem action='Statusbar'/>"
234            "    </menu>"
235  #ifdef ABOUT_DIALOG  #ifdef ABOUT_DIALOG
236          "    <menu action='MenuHelp'>"          "    <menu action='MenuHelp'>"
237          "      <menuitem action='About'/>"          "      <menuitem action='About'/>"
# Line 211  MainWindow::MainWindow() Line 261  MainWindow::MainWindow()
261      m_VBox.pack_start(m_HPaned);      m_VBox.pack_start(m_HPaned);
262      m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);
263      m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);
264        m_VBox.pack_start(m_StatusBar, Gtk::PACK_SHRINK);
265    
266        // Status Bar:
267        m_StatusBar.pack_start(m_AttachedStateLabel, Gtk::PACK_SHRINK);
268        m_StatusBar.pack_start(m_AttachedStateImage, Gtk::PACK_SHRINK);
269        m_StatusBar.show();
270    
271      m_RegionChooser.signal_region_selected().connect(      m_RegionChooser.signal_region_selected().connect(
272          sigc::mem_fun(*this, &MainWindow::region_changed) );          sigc::mem_fun(*this, &MainWindow::region_changed) );
# Line 264  MainWindow::MainWindow() Line 320  MainWindow::MainWindow()
320          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
321      instrumentProps.signal_instrument_changed().connect(      instrumentProps.signal_instrument_changed().connect(
322          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
323        propDialog.signal_info_changed().connect(
324            sigc::mem_fun(*this, &MainWindow::file_changed));
325    
326      dimreg_edit.signal_dimreg_to_be_changed().connect(      dimreg_edit.signal_dimreg_to_be_changed().connect(
327          dimreg_to_be_changed_signal.make_slot());          dimreg_to_be_changed_signal.make_slot());
# Line 293  MainWindow::MainWindow() Line 351  MainWindow::MainWindow()
351      m_RegionChooser.signal_region_changed_signal().connect(      m_RegionChooser.signal_region_changed_signal().connect(
352          region_changed_signal.make_slot());          region_changed_signal.make_slot());
353    
354        dimreg_all_regions.signal_toggled().connect(
355            sigc::mem_fun(*this, &MainWindow::update_dimregs));
356        dimreg_all_dimregs.signal_toggled().connect(
357            sigc::mem_fun(*this, &MainWindow::dimreg_all_dimregs_toggled));
358        dimreg_stereo.signal_toggled().connect(
359            sigc::mem_fun(*this, &MainWindow::update_dimregs));
360    
361      file = 0;      file = 0;
362      file_is_changed = false;      file_is_changed = false;
363        set_file_is_shared(false);
364    
365      show_all_children();      show_all_children();
366    
# Line 308  MainWindow::~MainWindow() Line 374  MainWindow::~MainWindow()
374    
375  bool MainWindow::on_delete_event(GdkEventAny* event)  bool MainWindow::on_delete_event(GdkEventAny* event)
376  {  {
377      return file_is_changed && !close_confirmation_dialog();      return !file_is_shared && file_is_changed && !close_confirmation_dialog();
378  }  }
379    
380  void MainWindow::on_action_quit()  void MainWindow::on_action_quit()
381  {  {
382      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
383      hide();      hide();
384  }  }
385    
# Line 322  void MainWindow::region_changed() Line 388  void MainWindow::region_changed()
388      m_DimRegionChooser.set_region(m_RegionChooser.get_region());      m_DimRegionChooser.set_region(m_RegionChooser.get_region());
389  }  }
390    
391  void MainWindow::dimreg_changed()  gig::Instrument* MainWindow::get_instrument()
 {  
     dimreg_edit.set_dim_region(m_DimRegionChooser.get_dimregion());  
 }  
   
 void MainWindow::on_sel_change()  
392  {  {
393        gig::Instrument* instrument = 0;
394      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();
395    
396      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();
397      if (it) {      if (it) {
398          Gtk::TreeModel::Row row = *it;          Gtk::TreeModel::Row row = *it;
399          std::cout << row[m_Columns.m_col_name] << std::endl;          instrument = row[m_Columns.m_col_instr];
400        }
401        return instrument;
402    }
403    
404    void MainWindow::add_region_to_dimregs(gig::Region* region, bool stereo, bool all_dimregs)
405    {
406        if (all_dimregs) {
407            for (int i = 0 ; i < region->DimensionRegions ; i++) {
408                if (region->pDimensionRegions[i]) {
409                    dimreg_edit.dimregs.insert(region->pDimensionRegions[i]);
410                }
411            }
412        } else {
413            m_DimRegionChooser.get_dimregions(region, stereo, dimreg_edit.dimregs);
414        }
415    }
416    
417    void MainWindow::update_dimregs()
418    {
419        dimreg_edit.dimregs.clear();
420        bool all_regions = dimreg_all_regions.get_active();
421        bool stereo = dimreg_stereo.get_active();
422        bool all_dimregs = dimreg_all_dimregs.get_active();
423    
424          m_RegionChooser.set_instrument(row[m_Columns.m_col_instr]);      if (all_regions) {
425            gig::Instrument* instrument = get_instrument();
426            if (instrument) {
427                for (gig::Region* region = instrument->GetFirstRegion() ;
428                     region ;
429                     region = instrument->GetNextRegion()) {
430                    add_region_to_dimregs(region, stereo, all_dimregs);
431                }
432            }
433      } else {      } else {
434          m_RegionChooser.set_instrument(0);          gig::Region* region = m_RegionChooser.get_region();
435            if (region) {
436                add_region_to_dimregs(region, stereo, all_dimregs);
437            }
438      }      }
439  }  }
440    
441    void MainWindow::dimreg_all_dimregs_toggled()
442    {
443        dimreg_stereo.set_sensitive(!dimreg_all_dimregs.get_active());
444        update_dimregs();
445    }
446    
447    void MainWindow::dimreg_changed()
448    {
449        update_dimregs();
450        dimreg_edit.set_dim_region(m_DimRegionChooser.get_dimregion());
451    }
452    
453    void MainWindow::on_sel_change()
454    {
455        m_RegionChooser.set_instrument(get_instrument());
456    }
457    
458  void loader_progress_callback(gig::progress_t* progress)  void loader_progress_callback(gig::progress_t* progress)
459  {  {
460      Loader* loader = static_cast<Loader*>(progress->custom);      Loader* loader = static_cast<Loader*>(progress->custom);
# Line 427  void MainWindow::__clear() { Line 540  void MainWindow::__clear() {
540      m_refTreeModel->clear();      m_refTreeModel->clear();
541      m_refSamplesTreeModel->clear();      m_refSamplesTreeModel->clear();
542      // free libgig's gig::File instance      // free libgig's gig::File instance
543      if (file) {      if (file && !file_is_shared) delete file;
544          delete file;      file = NULL;
545          file = NULL;      set_file_is_shared(false);
     }  
546  }  }
547    
548  void MainWindow::on_action_file_new()  void MainWindow::on_action_file_new()
549  {  {
550      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
551    
552        if (file_is_shared && !leaving_shared_mode_dialog()) return;
553    
554      // clear all GUI elements      // clear all GUI elements
555      __clear();      __clear();
# Line 467  bool MainWindow::close_confirmation_dial Line 581  bool MainWindow::close_confirmation_dial
581      return response != Gtk::RESPONSE_CANCEL;      return response != Gtk::RESPONSE_CANCEL;
582  }  }
583    
584    bool MainWindow::leaving_shared_mode_dialog() {
585        Glib::ustring msg = _("Detach from sampler and proceed working stand-alone?");
586        Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
587    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2
588        dialog.set_secondary_text(
589            _("If you proceed to work on another instrument file, it won't be "
590              "used by the sampler until you tell the sampler explicitly to "
591              "load it.")
592       );
593    #endif
594        dialog.add_button(_("_Yes, Detach"), Gtk::RESPONSE_YES);
595        dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
596        dialog.set_default_response(Gtk::RESPONSE_CANCEL);
597        int response = dialog.run();
598        dialog.hide();
599        return response == Gtk::RESPONSE_YES;
600    }
601    
602  void MainWindow::on_action_file_open()  void MainWindow::on_action_file_open()
603  {  {
604      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
605    
606        if (file_is_shared && !leaving_shared_mode_dialog()) return;
607    
608      Gtk::FileChooserDialog dialog(*this, _("Open file"));      Gtk::FileChooserDialog dialog(*this, _("Open file"));
609      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
# Line 510  void MainWindow::load_instrument(gig::In Line 644  void MainWindow::load_instrument(gig::In
644          msg.run();          msg.run();
645          Gtk::Main::quit();          Gtk::Main::quit();
646      }      }
647        // clear all GUI elements
648        __clear();
649        // load the instrument
650      gig::File* pFile = (gig::File*) instr->GetParent();      gig::File* pFile = (gig::File*) instr->GetParent();
651      load_gig(pFile, 0 /*file name*/);      load_gig(pFile, 0 /*file name*/, true /*shared instrument*/);
652      //TODO: automatically select the given instrument      //TODO: automatically select the given instrument
653  }  }
654    
# Line 560  bool MainWindow::check_if_savable() Line 697  bool MainWindow::check_if_savable()
697  bool MainWindow::file_save()  bool MainWindow::file_save()
698  {  {
699      if (!check_if_savable()) return false;      if (!check_if_savable()) return false;
700      if (!file_has_name) return file_save_as();      if (!file_is_shared && !file_has_name) return file_save_as();
701    
702      std::cout << "Saving file\n" << std::flush;      std::cout << "Saving file\n" << std::flush;
703      file_structure_to_be_changed_signal.emit(this->file);      file_structure_to_be_changed_signal.emit(this->file);
# Line 572  bool MainWindow::file_save() Line 709  bool MainWindow::file_save()
709          }          }
710      } catch (RIFF::Exception e) {      } catch (RIFF::Exception e) {
711          file_structure_changed_signal.emit(this->file);          file_structure_changed_signal.emit(this->file);
712          Glib::ustring txt = "Could not save file: " + e.Message;          Glib::ustring txt = _("Could not save file: ") + e.Message;
713          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
714          msg.run();          msg.run();
715          return false;          return false;
# Line 627  bool MainWindow::file_save_as() Line 764  bool MainWindow::file_save_as()
764              file_is_changed = false;              file_is_changed = false;
765          } catch (RIFF::Exception e) {          } catch (RIFF::Exception e) {
766              file_structure_changed_signal.emit(this->file);              file_structure_changed_signal.emit(this->file);
767              Glib::ustring txt = "Could not save file: " + e.Message;              Glib::ustring txt = _("Could not save file: ") + e.Message;
768              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
769              msg.run();              msg.run();
770              return false;              return false;
# Line 724  void MainWindow::__import_queued_samples Line 861  void MainWindow::__import_queued_samples
861      }      }
862      // show error message box when some sample(s) could not be imported      // show error message box when some sample(s) could not be imported
863      if (error_files.size()) {      if (error_files.size()) {
864          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;
865          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
866          msg.run();          msg.run();
867      }      }
# Line 741  void MainWindow::on_action_help_about() Line 878  void MainWindow::on_action_help_about()
878  #ifdef ABOUT_DIALOG  #ifdef ABOUT_DIALOG
879      Gtk::AboutDialog dialog;      Gtk::AboutDialog dialog;
880      dialog.set_version(VERSION);      dialog.set_version(VERSION);
881        dialog.set_copyright("Copyright (C) 2006,2007 Andreas Persson");
882        dialog.set_comments(
883            "Released under the GNU General Public License.\n"
884            "\n"
885            "Please notice that this is still a very young instrument editor. "
886            "So better backup your Gigasampler files before editing them with "
887            "this application.\n"
888            "\n"
889            "Please report bugs to: http://bugs.linuxsampler.org"
890        );
891        dialog.set_website("http://www.linuxsampler.org");
892        dialog.set_website_label("http://www.linuxsampler.org");
893      dialog.run();      dialog.run();
894  #endif  #endif
895  }  }
896    
897  PropDialog::PropDialog()  PropDialog::PropDialog()
898      : table(2,1)      : table(2,1),
899          eName("Name"),
900          eCreationDate("Creation date"),
901          eComments("Comments"),
902          eProduct("Product"),
903          eCopyright("Copyright"),
904          eArtists("Artists"),
905          eGenre("Genre"),
906          eKeywords("Keywords"),
907          eEngineer("Engineer"),
908          eTechnician("Technician"),
909          eSoftware("Software"),
910          eMedium("Medium"),
911          eSource("Source"),
912          eSourceForm("Source form"),
913          eCommissioned("Commissioned"),
914          eSubject("Subject"),
915          quitButton(Gtk::Stock::CLOSE),
916          update_model(0)
917  {  {
918        set_title("File Properties");
919        eName.set_width_chars(50);
920    
921        connect(eName, &DLS::Info::Name);
922        connect(eCreationDate, &DLS::Info::CreationDate);
923        connect(eComments, &DLS::Info::Comments);
924        connect(eProduct, &DLS::Info::Product);
925        connect(eCopyright, &DLS::Info::Copyright);
926        connect(eArtists, &DLS::Info::Artists);
927        connect(eGenre, &DLS::Info::Genre);
928        connect(eKeywords, &DLS::Info::Keywords);
929        connect(eEngineer, &DLS::Info::Engineer);
930        connect(eTechnician, &DLS::Info::Technician);
931        connect(eSoftware, &DLS::Info::Software);
932        connect(eMedium, &DLS::Info::Medium);
933        connect(eSource, &DLS::Info::Source);
934        connect(eSourceForm, &DLS::Info::SourceForm);
935        connect(eCommissioned, &DLS::Info::Commissioned);
936        connect(eSubject, &DLS::Info::Subject);
937    
938        table.add(eName);
939        table.add(eCreationDate);
940        table.add(eComments);
941        table.add(eProduct);
942        table.add(eCopyright);
943        table.add(eArtists);
944        table.add(eGenre);
945        table.add(eKeywords);
946        table.add(eEngineer);
947        table.add(eTechnician);
948        table.add(eSoftware);
949        table.add(eMedium);
950        table.add(eSource);
951        table.add(eSourceForm);
952        table.add(eCommissioned);
953        table.add(eSubject);
954    
955      table.set_col_spacings(5);      table.set_col_spacings(5);
956      const char* propLabels[] = {      add(vbox);
957          "Name:",      table.set_border_width(5);
958          "CreationDate:",      vbox.add(table);
959          "Comments:", // TODO: multiline      vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);
960          "Product:",      buttonBox.set_layout(Gtk::BUTTONBOX_END);
961          "Copyright:",      buttonBox.set_border_width(5);
962          "Artists:",      buttonBox.show();
963          "Genre:",      buttonBox.pack_start(quitButton);
964          "Keywords:",      quitButton.set_flags(Gtk::CAN_DEFAULT);
965          "Engineer:",      quitButton.grab_focus();
966          "Technician:",      quitButton.signal_clicked().connect(
967          "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);  
     }  
968    
969      add(table);      quitButton.show();
970      // add_button(Gtk::Stock::CANCEL, 0);      vbox.show();
     // add_button(Gtk::Stock::OK, 1);  
971      show_all_children();      show_all_children();
972  }  }
973    
974  void PropDialog::set_info(DLS::Info* info)  void PropDialog::set_info(DLS::Info* info)
975  {  {
976      entry[0].set_text(info->Name);      this->info = info;
977      entry[1].set_text(info->CreationDate);      update_model++;
978      entry[2].set_text(Glib::convert(info->Comments, "UTF-8", "ISO-8859-1"));      eName.set_value(info->Name);
979      entry[3].set_text(info->Product);      eCreationDate.set_value(info->CreationDate);
980      entry[4].set_text(info->Copyright);      eComments.set_value(info->Comments);
981      entry[5].set_text(info->Artists);      eProduct.set_value(info->Product);
982      entry[6].set_text(info->Genre);      eCopyright.set_value(info->Copyright);
983      entry[7].set_text(info->Keywords);      eArtists.set_value(info->Artists);
984      entry[8].set_text(info->Engineer);      eGenre.set_value(info->Genre);
985      entry[9].set_text(info->Technician);      eKeywords.set_value(info->Keywords);
986      entry[10].set_text(info->Software);      eEngineer.set_value(info->Engineer);
987      entry[11].set_text(info->Medium);      eTechnician.set_value(info->Technician);
988      entry[12].set_text(info->Source);      eSoftware.set_value(info->Software);
989      entry[13].set_text(info->SourceForm);      eMedium.set_value(info->Medium);
990      entry[14].set_text(info->Commissioned);      eSource.set_value(info->Source);
991      entry[15].set_text(info->Subject);      eSourceForm.set_value(info->SourceForm);
992        eCommissioned.set_value(info->Commissioned);
993        eSubject.set_value(info->Subject);
994        update_model--;
995  }  }
996    
997  void InstrumentProps::add_prop(BoolEntry& boolentry)  sigc::signal<void>& PropDialog::signal_info_changed()
998  {  {
999      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());  
1000  }  }
1001    
1002  void InstrumentProps::add_prop(BoolEntryPlus6& boolentry)  void InstrumentProps::set_IsDrum(bool value)
1003  {  {
1004      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());  
1005  }  }
1006    
1007  void InstrumentProps::add_prop(LabelWidget& prop)  void InstrumentProps::set_MIDIBank(uint16_t value)
1008  {  {
1009      table.attach(prop.label, 0, 1, rowno, rowno + 1,      instrument->MIDIBank = value;
1010                   Gtk::FILL, Gtk::SHRINK);  }
1011      table.attach(prop.widget, 1, 2, rowno, rowno + 1,  
1012                   Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK);  void InstrumentProps::set_MIDIProgram(uint32_t value)
1013      rowno++;  {
1014      prop.signal_changed_by_user().connect(instrument_changed.make_slot());      instrument->MIDIProgram = value;
1015    }
1016    
1017    void InstrumentProps::set_DimensionKeyRange_low(uint8_t value)
1018    {
1019        instrument->DimensionKeyRange.low = value;
1020        if (value > instrument->DimensionKeyRange.high) {
1021            eDimensionKeyRangeHigh.set_value(value);
1022        }
1023    }
1024    
1025    void InstrumentProps::set_DimensionKeyRange_high(uint8_t value)
1026    {
1027        instrument->DimensionKeyRange.high = value;
1028        if (value < instrument->DimensionKeyRange.low) {
1029            eDimensionKeyRangeLow.set_value(value);
1030        }
1031  }  }
1032    
1033  InstrumentProps::InstrumentProps()  InstrumentProps::InstrumentProps()
# Line 841  InstrumentProps::InstrumentProps() Line 1044  InstrumentProps::InstrumentProps()
1044        ePitchbendRange("Pitchbend range", 0, 12),        ePitchbendRange("Pitchbend range", 0, 12),
1045        ePianoReleaseMode("Piano release mode"),        ePianoReleaseMode("Piano release mode"),
1046        eDimensionKeyRangeLow("Dimension key range low"),        eDimensionKeyRangeLow("Dimension key range low"),
1047        eDimensionKeyRangeHigh("Dimension key range high")        eDimensionKeyRangeHigh("Dimension key range high"),
1048          update_model(0)
1049  {  {
1050      set_title("Instrument properties");      set_title("Instrument Properties");
1051    
1052        connect(eIsDrum, &InstrumentProps::set_IsDrum);
1053        connect(eMIDIBank, &InstrumentProps::set_MIDIBank);
1054        connect(eMIDIProgram, &InstrumentProps::set_MIDIProgram);
1055        connect(eAttenuation, &gig::Instrument::Attenuation);
1056        connect(eGainPlus6, &gig::Instrument::Attenuation);
1057        connect(eEffectSend, &gig::Instrument::EffectSend);
1058        connect(eFineTune, &gig::Instrument::FineTune);
1059        connect(ePitchbendRange, &gig::Instrument::PitchbendRange);
1060        connect(ePianoReleaseMode, &gig::Instrument::PianoReleaseMode);
1061        connect(eDimensionKeyRangeLow,
1062                &InstrumentProps::set_DimensionKeyRange_low);
1063        connect(eDimensionKeyRangeHigh,
1064                &InstrumentProps::set_DimensionKeyRange_high);
1065    
     rowno = 0;  
1066      table.set_col_spacings(5);      table.set_col_spacings(5);
1067    
1068      add_prop(eName);      table.add(eName);
1069      add_prop(eIsDrum);      table.add(eIsDrum);
1070      add_prop(eMIDIBank);      table.add(eMIDIBank);
1071      add_prop(eMIDIProgram);      table.add(eMIDIProgram);
1072      add_prop(eAttenuation);      table.add(eAttenuation);
1073      add_prop(eGainPlus6);      table.add(eGainPlus6);
1074      add_prop(eEffectSend);      table.add(eEffectSend);
1075      add_prop(eFineTune);      table.add(eFineTune);
1076      add_prop(ePitchbendRange);      table.add(ePitchbendRange);
1077      add_prop(ePianoReleaseMode);      table.add(ePianoReleaseMode);
1078      add_prop(eDimensionKeyRangeLow);      table.add(eDimensionKeyRangeLow);
1079      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));  
1080    
1081      add(vbox);      add(vbox);
1082      table.set_border_width(5);      table.set_border_width(5);
# Line 888  InstrumentProps::InstrumentProps() Line 1100  InstrumentProps::InstrumentProps()
1100    
1101  void InstrumentProps::set_instrument(gig::Instrument* instrument)  void InstrumentProps::set_instrument(gig::Instrument* instrument)
1102  {  {
1103      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);  
 }  
1104    
1105  void InstrumentProps::key_range_high_changed()      update_model++;
1106  {      eName.set_value(instrument->pInfo->Name);
1107      double l = eDimensionKeyRangeLow.get_value();      eIsDrum.set_value(instrument->IsDrum);
1108      double h = eDimensionKeyRangeHigh.get_value();      eMIDIBank.set_value(instrument->MIDIBank);
1109      if (h < l) eDimensionKeyRangeLow.set_value(h);      eMIDIProgram.set_value(instrument->MIDIProgram);
1110        eAttenuation.set_value(instrument->Attenuation);
1111        eGainPlus6.set_value(instrument->Attenuation);
1112        eEffectSend.set_value(instrument->EffectSend);
1113        eFineTune.set_value(instrument->FineTune);
1114        ePitchbendRange.set_value(instrument->PitchbendRange);
1115        ePianoReleaseMode.set_value(instrument->PianoReleaseMode);
1116        eDimensionKeyRangeLow.set_value(instrument->DimensionKeyRange.low);
1117        eDimensionKeyRangeHigh.set_value(instrument->DimensionKeyRange.high);
1118        update_model--;
1119  }  }
1120    
1121  sigc::signal<void> InstrumentProps::signal_instrument_changed()  sigc::signal<void>& InstrumentProps::signal_instrument_changed()
1122  {  {
1123      return instrument_changed;      return instrument_changed;
1124  }  }
# Line 931  void MainWindow::file_changed() Line 1131  void MainWindow::file_changed()
1131      }      }
1132  }  }
1133    
1134  void MainWindow::load_gig(gig::File* gig, const char* filename)  void MainWindow::load_gig(gig::File* gig, const char* filename, bool isSharedInstrument)
1135  {  {
1136      file = 0;      file = 0;
1137        set_file_is_shared(isSharedInstrument);
1138    
1139      this->filename = filename ? filename : _("Unsaved Gig File");      this->filename = filename ? filename : _("Unsaved Gig File");
1140      set_title(Glib::filename_display_basename(this->filename));      set_title(Glib::filename_display_basename(this->filename));
# Line 996  void MainWindow::load_gig(gig::File* gig Line 1197  void MainWindow::load_gig(gig::File* gig
1197    
1198  void MainWindow::show_instr_props()  void MainWindow::show_instr_props()
1199  {  {
1200      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();      gig::Instrument* instrument = get_instrument();
1201      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();      if (instrument)
     if (it)  
1202      {      {
1203          Gtk::TreeModel::Row row = *it;          instrumentProps.set_instrument(instrument);
1204          if (row[m_Columns.m_col_instr])          instrumentProps.show();
1205          {          instrumentProps.deiconify();
1206              instrumentProps.set_instrument(row[m_Columns.m_col_instr]);      }
1207              instrumentProps.show();  }
1208              instrumentProps.deiconify();  
1209          }  void MainWindow::on_action_view_status_bar() {
1210        Gtk::CheckMenuItem* item =
1211            dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/Statusbar"));
1212        if (!item) {
1213            std::cerr << "/MenuBar/MenuView/Statusbar == NULL\n";
1214            return;
1215      }      }
1216        if (item->get_active()) m_StatusBar.show();
1217        else                    m_StatusBar.hide();
1218  }  }
1219    
1220  void MainWindow::on_button_release(GdkEventButton* button)  void MainWindow::on_button_release(GdkEventButton* button)
# Line 1067  void MainWindow::on_action_add_instrumen Line 1274  void MainWindow::on_action_add_instrumen
1274    
1275  void MainWindow::on_action_remove_instrument() {  void MainWindow::on_action_remove_instrument() {
1276      if (!file) return;      if (!file) return;
1277        if (file_is_shared) {
1278            Gtk::MessageDialog msg(
1279                *this,
1280                 _("You cannot delete an instrument from this file, since it's "
1281                   "currently used by the sampler."),
1282                 false, Gtk::MESSAGE_INFO
1283            );
1284            msg.run();
1285            return;
1286        }
1287    
1288      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
1289      Gtk::TreeModel::iterator it = sel->get_selected();      Gtk::TreeModel::iterator it = sel->get_selected();
1290      if (it) {      if (it) {
# Line 1253  void MainWindow::on_action_add_sample() Line 1471  void MainWindow::on_action_add_sample()
1471          }          }
1472          // 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
1473          if (error_files.size()) {          if (error_files.size()) {
1474              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;
1475              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1476              msg.run();              msg.run();
1477          }          }
# Line 1426  void MainWindow::on_sample_label_drop_dr Line 1644  void MainWindow::on_sample_label_drop_dr
1644          // notify we're done with altering          // notify we're done with altering
1645          region_changed_signal.emit(region);          region_changed_signal.emit(region);
1646    
1647            file_changed();
1648    
1649          return;          return;
1650      }      }
1651      // drop failed      // drop failed
# Line 1466  void MainWindow::instrument_name_changed Line 1686  void MainWindow::instrument_name_changed
1686      }      }
1687  }  }
1688    
1689  sigc::signal<void, gig::File*> MainWindow::signal_file_structure_to_be_changed() {  void MainWindow::set_file_is_shared(bool b) {
1690        this->file_is_shared = b;
1691    
1692        if (file_is_shared) {
1693            m_AttachedStateLabel.set_label(_("live-mode"));
1694            m_AttachedStateImage.set(
1695                Gdk::Pixbuf::create_from_xpm_data(status_attached_xpm)
1696            );
1697        } else {
1698            m_AttachedStateLabel.set_label(_("stand-alone"));
1699            m_AttachedStateImage.set(
1700                Gdk::Pixbuf::create_from_xpm_data(status_detached_xpm)
1701            );
1702        }
1703    }
1704    
1705    sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_to_be_changed() {
1706      return file_structure_to_be_changed_signal;      return file_structure_to_be_changed_signal;
1707  }  }
1708    
1709  sigc::signal<void, gig::File*> MainWindow::signal_file_structure_changed() {  sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_changed() {
1710      return file_structure_changed_signal;      return file_structure_changed_signal;
1711  }  }
1712    
1713  sigc::signal<void, std::list<gig::Sample*> > MainWindow::signal_samples_to_be_removed() {  sigc::signal<void, std::list<gig::Sample*> >& MainWindow::signal_samples_to_be_removed() {
1714      return samples_to_be_removed_signal;      return samples_to_be_removed_signal;
1715  }  }
1716    
1717  sigc::signal<void> MainWindow::signal_samples_removed() {  sigc::signal<void>& MainWindow::signal_samples_removed() {
1718      return samples_removed_signal;      return samples_removed_signal;
1719  }  }
1720    
1721  sigc::signal<void, gig::Region*> MainWindow::signal_region_to_be_changed() {  sigc::signal<void, gig::Region*>& MainWindow::signal_region_to_be_changed() {
1722      return region_to_be_changed_signal;      return region_to_be_changed_signal;
1723  }  }
1724    
1725  sigc::signal<void, gig::Region*> MainWindow::signal_region_changed() {  sigc::signal<void, gig::Region*>& MainWindow::signal_region_changed() {
1726      return region_changed_signal;      return region_changed_signal;
1727  }  }
1728    
1729  sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/> MainWindow::signal_sample_ref_changed() {  sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& MainWindow::signal_sample_ref_changed() {
1730      return sample_ref_changed_signal;      return sample_ref_changed_signal;
1731  }  }
1732    
1733  sigc::signal<void, gig::DimensionRegion*> MainWindow::signal_dimreg_to_be_changed() {  sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_to_be_changed() {
1734      return dimreg_to_be_changed_signal;      return dimreg_to_be_changed_signal;
1735  }  }
1736    
1737  sigc::signal<void, gig::DimensionRegion*> MainWindow::signal_dimreg_changed() {  sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {
1738      return dimreg_changed_signal;      return dimreg_changed_signal;
1739  }  }
Legend:
Removed from v.1322  
changed lines
  Added in v.1582
  ViewVC Help
Powered by ViewVC