/[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 1339 by schoenebeck, Mon Sep 10 19:56:26 2007 UTC revision 1661 by schoenebeck, Sun Feb 3 14:10:47 2008 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (C) 2006, 2007 Andreas Persson   * Copyright (C) 2006 - 2008 Andreas Persson
3   *   *
4   * This program is free software; you can redistribute it and/or   * This program is free software; you can redistribute it and/or
5   * modify it under the terms of the GNU General Public License as   * modify it under the terms of the GNU General Public License as
# Line 17  Line 17 
17   * 02110-1301 USA.   * 02110-1301 USA.
18   */   */
19    
 #include <libintl.h>  
20  #include <iostream>  #include <iostream>
21    
22  #include <gtkmm/filechooserdialog.h>  #include <gtkmm/filechooserdialog.h>
# Line 25  Line 24 
24  #include <gtkmm/stock.h>  #include <gtkmm/stock.h>
25  #include <gtkmm/targetentry.h>  #include <gtkmm/targetentry.h>
26  #include <gtkmm/main.h>  #include <gtkmm/main.h>
27    #include <gtkmm/toggleaction.h>
28    
29    #include "global.h"
30    
31  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2
32  #define ABOUT_DIALOG  #define ABOUT_DIALOG
# 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 210  MainWindow::MainWindow() Line 260  MainWindow::MainWindow()
260      m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);      m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);
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_RegionChooser.m_VirtKeybPropsBox, Gtk::PACK_SHRINK);
264      m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);
265        m_VBox.pack_start(m_StatusBar, Gtk::PACK_SHRINK);
266    
267        // Status Bar:
268        m_StatusBar.pack_start(m_AttachedStateLabel, Gtk::PACK_SHRINK);
269        m_StatusBar.pack_start(m_AttachedStateImage, Gtk::PACK_SHRINK);
270        m_StatusBar.show();
271    
272      m_RegionChooser.signal_region_selected().connect(      m_RegionChooser.signal_region_selected().connect(
273          sigc::mem_fun(*this, &MainWindow::region_changed) );          sigc::mem_fun(*this, &MainWindow::region_changed) );
# Line 264  MainWindow::MainWindow() Line 321  MainWindow::MainWindow()
321          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
322      instrumentProps.signal_instrument_changed().connect(      instrumentProps.signal_instrument_changed().connect(
323          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
324        propDialog.signal_info_changed().connect(
325            sigc::mem_fun(*this, &MainWindow::file_changed));
326    
327      dimreg_edit.signal_dimreg_to_be_changed().connect(      dimreg_edit.signal_dimreg_to_be_changed().connect(
328          dimreg_to_be_changed_signal.make_slot());          dimreg_to_be_changed_signal.make_slot());
# Line 293  MainWindow::MainWindow() Line 352  MainWindow::MainWindow()
352      m_RegionChooser.signal_region_changed_signal().connect(      m_RegionChooser.signal_region_changed_signal().connect(
353          region_changed_signal.make_slot());          region_changed_signal.make_slot());
354    
355        note_on_signal.connect(
356            sigc::mem_fun(m_RegionChooser, &RegionChooser::on_note_on_event));
357        note_off_signal.connect(
358            sigc::mem_fun(m_RegionChooser, &RegionChooser::on_note_off_event));
359    
360        dimreg_all_regions.signal_toggled().connect(
361            sigc::mem_fun(*this, &MainWindow::update_dimregs));
362        dimreg_all_dimregs.signal_toggled().connect(
363            sigc::mem_fun(*this, &MainWindow::dimreg_all_dimregs_toggled));
364        dimreg_stereo.signal_toggled().connect(
365            sigc::mem_fun(*this, &MainWindow::update_dimregs));
366    
367      file = 0;      file = 0;
368      file_is_changed = false;      file_is_changed = false;
369        set_file_is_shared(false);
370    
371      show_all_children();      show_all_children();
372    
# Line 308  MainWindow::~MainWindow() Line 380  MainWindow::~MainWindow()
380    
381  bool MainWindow::on_delete_event(GdkEventAny* event)  bool MainWindow::on_delete_event(GdkEventAny* event)
382  {  {
383      return file_is_changed && !close_confirmation_dialog();      return !file_is_shared && file_is_changed && !close_confirmation_dialog();
384  }  }
385    
386  void MainWindow::on_action_quit()  void MainWindow::on_action_quit()
387  {  {
388      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
389      hide();      hide();
390  }  }
391    
# Line 322  void MainWindow::region_changed() Line 394  void MainWindow::region_changed()
394      m_DimRegionChooser.set_region(m_RegionChooser.get_region());      m_DimRegionChooser.set_region(m_RegionChooser.get_region());
395  }  }
396    
397  void MainWindow::dimreg_changed()  gig::Instrument* MainWindow::get_instrument()
 {  
     dimreg_edit.set_dim_region(m_DimRegionChooser.get_dimregion());  
 }  
   
 void MainWindow::on_sel_change()  
398  {  {
399        gig::Instrument* instrument = 0;
400      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();
401    
402      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();
403      if (it) {      if (it) {
404          Gtk::TreeModel::Row row = *it;          Gtk::TreeModel::Row row = *it;
405          std::cout << row[m_Columns.m_col_name] << std::endl;          instrument = row[m_Columns.m_col_instr];
406        }
407        return instrument;
408    }
409    
410          m_RegionChooser.set_instrument(row[m_Columns.m_col_instr]);  void MainWindow::add_region_to_dimregs(gig::Region* region, bool stereo, bool all_dimregs)
411    {
412        if (all_dimregs) {
413            for (int i = 0 ; i < region->DimensionRegions ; i++) {
414                if (region->pDimensionRegions[i]) {
415                    dimreg_edit.dimregs.insert(region->pDimensionRegions[i]);
416                }
417            }
418      } else {      } else {
419          m_RegionChooser.set_instrument(0);          m_DimRegionChooser.get_dimregions(region, stereo, dimreg_edit.dimregs);
420      }      }
421  }  }
422    
423    void MainWindow::update_dimregs()
424    {
425        dimreg_edit.dimregs.clear();
426        bool all_regions = dimreg_all_regions.get_active();
427        bool stereo = dimreg_stereo.get_active();
428        bool all_dimregs = dimreg_all_dimregs.get_active();
429    
430        if (all_regions) {
431            gig::Instrument* instrument = get_instrument();
432            if (instrument) {
433                for (gig::Region* region = instrument->GetFirstRegion() ;
434                     region ;
435                     region = instrument->GetNextRegion()) {
436                    add_region_to_dimregs(region, stereo, all_dimregs);
437                }
438            }
439        } else {
440            gig::Region* region = m_RegionChooser.get_region();
441            if (region) {
442                add_region_to_dimregs(region, stereo, all_dimregs);
443            }
444        }
445    }
446    
447    void MainWindow::dimreg_all_dimregs_toggled()
448    {
449        dimreg_stereo.set_sensitive(!dimreg_all_dimregs.get_active());
450        update_dimregs();
451    }
452    
453    void MainWindow::dimreg_changed()
454    {
455        update_dimregs();
456        dimreg_edit.set_dim_region(m_DimRegionChooser.get_dimregion());
457    }
458    
459    void MainWindow::on_sel_change()
460    {
461        m_RegionChooser.set_instrument(get_instrument());
462    }
463    
464  void loader_progress_callback(gig::progress_t* progress)  void loader_progress_callback(gig::progress_t* progress)
465  {  {
466      Loader* loader = static_cast<Loader*>(progress->custom);      Loader* loader = static_cast<Loader*>(progress->custom);
# Line 427  void MainWindow::__clear() { Line 546  void MainWindow::__clear() {
546      m_refTreeModel->clear();      m_refTreeModel->clear();
547      m_refSamplesTreeModel->clear();      m_refSamplesTreeModel->clear();
548      // free libgig's gig::File instance      // free libgig's gig::File instance
549      if (file) {      if (file && !file_is_shared) delete file;
550          delete file;      file = NULL;
551          file = NULL;      set_file_is_shared(false);
     }  
552  }  }
553    
554  void MainWindow::on_action_file_new()  void MainWindow::on_action_file_new()
555  {  {
556      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
557    
558        if (file_is_shared && !leaving_shared_mode_dialog()) return;
559    
560      // clear all GUI elements      // clear all GUI elements
561      __clear();      __clear();
# Line 467  bool MainWindow::close_confirmation_dial Line 587  bool MainWindow::close_confirmation_dial
587      return response != Gtk::RESPONSE_CANCEL;      return response != Gtk::RESPONSE_CANCEL;
588  }  }
589    
590    bool MainWindow::leaving_shared_mode_dialog() {
591        Glib::ustring msg = _("Detach from sampler and proceed working stand-alone?");
592        Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
593    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 6) || GTKMM_MAJOR_VERSION > 2
594        dialog.set_secondary_text(
595            _("If you proceed to work on another instrument file, it won't be "
596              "used by the sampler until you tell the sampler explicitly to "
597              "load it.")
598       );
599    #endif
600        dialog.add_button(_("_Yes, Detach"), Gtk::RESPONSE_YES);
601        dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
602        dialog.set_default_response(Gtk::RESPONSE_CANCEL);
603        int response = dialog.run();
604        dialog.hide();
605        return response == Gtk::RESPONSE_YES;
606    }
607    
608  void MainWindow::on_action_file_open()  void MainWindow::on_action_file_open()
609  {  {
610      if (file_is_changed && !close_confirmation_dialog()) return;      if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
611    
612        if (file_is_shared && !leaving_shared_mode_dialog()) return;
613    
614      Gtk::FileChooserDialog dialog(*this, _("Open file"));      Gtk::FileChooserDialog dialog(*this, _("Open file"));
615      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
# Line 514  void MainWindow::load_instrument(gig::In Line 654  void MainWindow::load_instrument(gig::In
654      __clear();      __clear();
655      // load the instrument      // load the instrument
656      gig::File* pFile = (gig::File*) instr->GetParent();      gig::File* pFile = (gig::File*) instr->GetParent();
657      load_gig(pFile, 0 /*file name*/);      load_gig(pFile, 0 /*file name*/, true /*shared instrument*/);
658      //TODO: automatically select the given instrument      //TODO: automatically select the given instrument
659  }  }
660    
# Line 563  bool MainWindow::check_if_savable() Line 703  bool MainWindow::check_if_savable()
703  bool MainWindow::file_save()  bool MainWindow::file_save()
704  {  {
705      if (!check_if_savable()) return false;      if (!check_if_savable()) return false;
706      if (!file_has_name) return file_save_as();      if (!file_is_shared && !file_has_name) return file_save_as();
707    
708      std::cout << "Saving file\n" << std::flush;      std::cout << "Saving file\n" << std::flush;
709      file_structure_to_be_changed_signal.emit(this->file);      file_structure_to_be_changed_signal.emit(this->file);
# Line 575  bool MainWindow::file_save() Line 715  bool MainWindow::file_save()
715          }          }
716      } catch (RIFF::Exception e) {      } catch (RIFF::Exception e) {
717          file_structure_changed_signal.emit(this->file);          file_structure_changed_signal.emit(this->file);
718          Glib::ustring txt = "Could not save file: " + e.Message;          Glib::ustring txt = _("Could not save file: ") + e.Message;
719          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
720          msg.run();          msg.run();
721          return false;          return false;
# Line 630  bool MainWindow::file_save_as() Line 770  bool MainWindow::file_save_as()
770              file_is_changed = false;              file_is_changed = false;
771          } catch (RIFF::Exception e) {          } catch (RIFF::Exception e) {
772              file_structure_changed_signal.emit(this->file);              file_structure_changed_signal.emit(this->file);
773              Glib::ustring txt = "Could not save file: " + e.Message;              Glib::ustring txt = _("Could not save file: ") + e.Message;
774              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
775              msg.run();              msg.run();
776              return false;              return false;
# Line 727  void MainWindow::__import_queued_samples Line 867  void MainWindow::__import_queued_samples
867      }      }
868      // show error message box when some sample(s) could not be imported      // show error message box when some sample(s) could not be imported
869      if (error_files.size()) {      if (error_files.size()) {
870          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;
871          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
872          msg.run();          msg.run();
873      }      }
# Line 744  void MainWindow::on_action_help_about() Line 884  void MainWindow::on_action_help_about()
884  #ifdef ABOUT_DIALOG  #ifdef ABOUT_DIALOG
885      Gtk::AboutDialog dialog;      Gtk::AboutDialog dialog;
886      dialog.set_version(VERSION);      dialog.set_version(VERSION);
887        dialog.set_copyright("Copyright (C) 2006,2007 Andreas Persson");
888        dialog.set_comments(
889            "Released under the GNU General Public License.\n"
890            "\n"
891            "Please notice that this is still a very young instrument editor. "
892            "So better backup your Gigasampler files before editing them with "
893            "this application.\n"
894            "\n"
895            "Please report bugs to: http://bugs.linuxsampler.org"
896        );
897        dialog.set_website("http://www.linuxsampler.org");
898        dialog.set_website_label("http://www.linuxsampler.org");
899      dialog.run();      dialog.run();
900  #endif  #endif
901  }  }
902    
903  PropDialog::PropDialog()  PropDialog::PropDialog()
904      : table(2,1)      : table(2,1),
905          eName("Name"),
906          eCreationDate("Creation date"),
907          eComments("Comments"),
908          eProduct("Product"),
909          eCopyright("Copyright"),
910          eArtists("Artists"),
911          eGenre("Genre"),
912          eKeywords("Keywords"),
913          eEngineer("Engineer"),
914          eTechnician("Technician"),
915          eSoftware("Software"),
916          eMedium("Medium"),
917          eSource("Source"),
918          eSourceForm("Source form"),
919          eCommissioned("Commissioned"),
920          eSubject("Subject"),
921          quitButton(Gtk::Stock::CLOSE),
922          update_model(0)
923  {  {
924        set_title("File Properties");
925        eName.set_width_chars(50);
926    
927        connect(eName, &DLS::Info::Name);
928        connect(eCreationDate, &DLS::Info::CreationDate);
929        connect(eComments, &DLS::Info::Comments);
930        connect(eProduct, &DLS::Info::Product);
931        connect(eCopyright, &DLS::Info::Copyright);
932        connect(eArtists, &DLS::Info::Artists);
933        connect(eGenre, &DLS::Info::Genre);
934        connect(eKeywords, &DLS::Info::Keywords);
935        connect(eEngineer, &DLS::Info::Engineer);
936        connect(eTechnician, &DLS::Info::Technician);
937        connect(eSoftware, &DLS::Info::Software);
938        connect(eMedium, &DLS::Info::Medium);
939        connect(eSource, &DLS::Info::Source);
940        connect(eSourceForm, &DLS::Info::SourceForm);
941        connect(eCommissioned, &DLS::Info::Commissioned);
942        connect(eSubject, &DLS::Info::Subject);
943    
944        table.add(eName);
945        table.add(eCreationDate);
946        table.add(eComments);
947        table.add(eProduct);
948        table.add(eCopyright);
949        table.add(eArtists);
950        table.add(eGenre);
951        table.add(eKeywords);
952        table.add(eEngineer);
953        table.add(eTechnician);
954        table.add(eSoftware);
955        table.add(eMedium);
956        table.add(eSource);
957        table.add(eSourceForm);
958        table.add(eCommissioned);
959        table.add(eSubject);
960    
961      table.set_col_spacings(5);      table.set_col_spacings(5);
962      const char* propLabels[] = {      add(vbox);
963          "Name:",      table.set_border_width(5);
964          "CreationDate:",      vbox.add(table);
965          "Comments:", // TODO: multiline      vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);
966          "Product:",      buttonBox.set_layout(Gtk::BUTTONBOX_END);
967          "Copyright:",      buttonBox.set_border_width(5);
968          "Artists:",      buttonBox.show();
969          "Genre:",      buttonBox.pack_start(quitButton);
970          "Keywords:",      quitButton.set_flags(Gtk::CAN_DEFAULT);
971          "Engineer:",      quitButton.grab_focus();
972          "Technician:",      quitButton.signal_clicked().connect(
973          "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);  
     }  
974    
975      add(table);      quitButton.show();
976      // add_button(Gtk::Stock::CANCEL, 0);      vbox.show();
     // add_button(Gtk::Stock::OK, 1);  
977      show_all_children();      show_all_children();
978  }  }
979    
980  void PropDialog::set_info(DLS::Info* info)  void PropDialog::set_info(DLS::Info* info)
981  {  {
982      entry[0].set_text(info->Name);      this->info = info;
983      entry[1].set_text(info->CreationDate);      update_model++;
984      entry[2].set_text(Glib::convert(info->Comments, "UTF-8", "ISO-8859-1"));      eName.set_value(info->Name);
985      entry[3].set_text(info->Product);      eCreationDate.set_value(info->CreationDate);
986      entry[4].set_text(info->Copyright);      eComments.set_value(info->Comments);
987      entry[5].set_text(info->Artists);      eProduct.set_value(info->Product);
988      entry[6].set_text(info->Genre);      eCopyright.set_value(info->Copyright);
989      entry[7].set_text(info->Keywords);      eArtists.set_value(info->Artists);
990      entry[8].set_text(info->Engineer);      eGenre.set_value(info->Genre);
991      entry[9].set_text(info->Technician);      eKeywords.set_value(info->Keywords);
992      entry[10].set_text(info->Software);      eEngineer.set_value(info->Engineer);
993      entry[11].set_text(info->Medium);      eTechnician.set_value(info->Technician);
994      entry[12].set_text(info->Source);      eSoftware.set_value(info->Software);
995      entry[13].set_text(info->SourceForm);      eMedium.set_value(info->Medium);
996      entry[14].set_text(info->Commissioned);      eSource.set_value(info->Source);
997      entry[15].set_text(info->Subject);      eSourceForm.set_value(info->SourceForm);
998        eCommissioned.set_value(info->Commissioned);
999        eSubject.set_value(info->Subject);
1000        update_model--;
1001  }  }
1002    
1003  void InstrumentProps::add_prop(BoolEntry& boolentry)  sigc::signal<void>& PropDialog::signal_info_changed()
1004  {  {
1005      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());  
1006  }  }
1007    
1008  void InstrumentProps::add_prop(BoolEntryPlus6& boolentry)  void InstrumentProps::set_IsDrum(bool value)
1009  {  {
1010      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());  
1011  }  }
1012    
1013  void InstrumentProps::add_prop(LabelWidget& prop)  void InstrumentProps::set_MIDIBank(uint16_t value)
1014  {  {
1015      table.attach(prop.label, 0, 1, rowno, rowno + 1,      instrument->MIDIBank = value;
1016                   Gtk::FILL, Gtk::SHRINK);  }
1017      table.attach(prop.widget, 1, 2, rowno, rowno + 1,  
1018                   Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK);  void InstrumentProps::set_MIDIProgram(uint32_t value)
1019      rowno++;  {
1020      prop.signal_changed_by_user().connect(instrument_changed.make_slot());      instrument->MIDIProgram = value;
1021    }
1022    
1023    void InstrumentProps::set_DimensionKeyRange_low(uint8_t value)
1024    {
1025        instrument->DimensionKeyRange.low = value;
1026        if (value > instrument->DimensionKeyRange.high) {
1027            eDimensionKeyRangeHigh.set_value(value);
1028        }
1029    }
1030    
1031    void InstrumentProps::set_DimensionKeyRange_high(uint8_t value)
1032    {
1033        instrument->DimensionKeyRange.high = value;
1034        if (value < instrument->DimensionKeyRange.low) {
1035            eDimensionKeyRangeLow.set_value(value);
1036        }
1037  }  }
1038    
1039  InstrumentProps::InstrumentProps()  InstrumentProps::InstrumentProps()
# Line 843  InstrumentProps::InstrumentProps() Line 1049  InstrumentProps::InstrumentProps()
1049        eFineTune("Fine tune", -8400, 8400),        eFineTune("Fine tune", -8400, 8400),
1050        ePitchbendRange("Pitchbend range", 0, 12),        ePitchbendRange("Pitchbend range", 0, 12),
1051        ePianoReleaseMode("Piano release mode"),        ePianoReleaseMode("Piano release mode"),
1052        eDimensionKeyRangeLow("Dimension key range low"),        eDimensionKeyRangeLow("Keyswitching range low"),
1053        eDimensionKeyRangeHigh("Dimension key range high")        eDimensionKeyRangeHigh("Keyswitching range high"),
1054  {        update_model(0)
1055      set_title("Instrument properties");  {
1056        set_title("Instrument Properties");
1057    
1058        eDimensionKeyRangeLow.set_tip(
1059            _("start of the keyboard area which should switch the "
1060              "\"keyswitching\" dimension")
1061        );
1062        eDimensionKeyRangeHigh.set_tip(
1063            _("end of the keyboard area which should switch the "
1064              "\"keyswitching\" dimension")
1065        );
1066    
1067        connect(eIsDrum, &InstrumentProps::set_IsDrum);
1068        connect(eMIDIBank, &InstrumentProps::set_MIDIBank);
1069        connect(eMIDIProgram, &InstrumentProps::set_MIDIProgram);
1070        connect(eAttenuation, &gig::Instrument::Attenuation);
1071        connect(eGainPlus6, &gig::Instrument::Attenuation);
1072        connect(eEffectSend, &gig::Instrument::EffectSend);
1073        connect(eFineTune, &gig::Instrument::FineTune);
1074        connect(ePitchbendRange, &gig::Instrument::PitchbendRange);
1075        connect(ePianoReleaseMode, &gig::Instrument::PianoReleaseMode);
1076        connect(eDimensionKeyRangeLow,
1077                &InstrumentProps::set_DimensionKeyRange_low);
1078        connect(eDimensionKeyRangeHigh,
1079                &InstrumentProps::set_DimensionKeyRange_high);
1080    
     rowno = 0;  
1081      table.set_col_spacings(5);      table.set_col_spacings(5);
1082    
1083      add_prop(eName);      table.add(eName);
1084      add_prop(eIsDrum);      table.add(eIsDrum);
1085      add_prop(eMIDIBank);      table.add(eMIDIBank);
1086      add_prop(eMIDIProgram);      table.add(eMIDIProgram);
1087      add_prop(eAttenuation);      table.add(eAttenuation);
1088      add_prop(eGainPlus6);      table.add(eGainPlus6);
1089      add_prop(eEffectSend);      table.add(eEffectSend);
1090      add_prop(eFineTune);      table.add(eFineTune);
1091      add_prop(ePitchbendRange);      table.add(ePitchbendRange);
1092      add_prop(ePianoReleaseMode);      table.add(ePianoReleaseMode);
1093      add_prop(eDimensionKeyRangeLow);      table.add(eDimensionKeyRangeLow);
1094      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));  
1095    
1096      add(vbox);      add(vbox);
1097      table.set_border_width(5);      table.set_border_width(5);
# Line 891  InstrumentProps::InstrumentProps() Line 1115  InstrumentProps::InstrumentProps()
1115    
1116  void InstrumentProps::set_instrument(gig::Instrument* instrument)  void InstrumentProps::set_instrument(gig::Instrument* instrument)
1117  {  {
1118      eName.set_ptr(&instrument->pInfo->Name);      this->instrument = instrument;
1119      eIsDrum.set_ptr(&instrument->IsDrum);  
1120      eMIDIBank.set_ptr(&instrument->MIDIBank);      update_model++;
1121      eMIDIProgram.set_ptr(&instrument->MIDIProgram);      eName.set_value(instrument->pInfo->Name);
1122      eAttenuation.set_ptr(&instrument->Attenuation);      eIsDrum.set_value(instrument->IsDrum);
1123      eGainPlus6.set_ptr(&instrument->Attenuation);      eMIDIBank.set_value(instrument->MIDIBank);
1124      eEffectSend.set_ptr(&instrument->EffectSend);      eMIDIProgram.set_value(instrument->MIDIProgram);
1125      eFineTune.set_ptr(&instrument->FineTune);      eAttenuation.set_value(instrument->Attenuation);
1126      ePitchbendRange.set_ptr(&instrument->PitchbendRange);      eGainPlus6.set_value(instrument->Attenuation);
1127      ePianoReleaseMode.set_ptr(&instrument->PianoReleaseMode);      eEffectSend.set_value(instrument->EffectSend);
1128      eDimensionKeyRangeLow.set_ptr(0);      eFineTune.set_value(instrument->FineTune);
1129      eDimensionKeyRangeHigh.set_ptr(0);      ePitchbendRange.set_value(instrument->PitchbendRange);
1130      eDimensionKeyRangeLow.set_ptr(&instrument->DimensionKeyRange.low);      ePianoReleaseMode.set_value(instrument->PianoReleaseMode);
1131      eDimensionKeyRangeHigh.set_ptr(&instrument->DimensionKeyRange.high);      eDimensionKeyRangeLow.set_value(instrument->DimensionKeyRange.low);
1132  }      eDimensionKeyRangeHigh.set_value(instrument->DimensionKeyRange.high);
1133        update_model--;
 void InstrumentProps::key_range_low_changed()  
 {  
     double l = eDimensionKeyRangeLow.get_value();  
     double h = eDimensionKeyRangeHigh.get_value();  
     if (h < l) eDimensionKeyRangeHigh.set_value(l);  
 }  
   
 void InstrumentProps::key_range_high_changed()  
 {  
     double l = eDimensionKeyRangeLow.get_value();  
     double h = eDimensionKeyRangeHigh.get_value();  
     if (h < l) eDimensionKeyRangeLow.set_value(h);  
1134  }  }
1135    
1136  sigc::signal<void>& InstrumentProps::signal_instrument_changed()  sigc::signal<void>& InstrumentProps::signal_instrument_changed()
# Line 934  void MainWindow::file_changed() Line 1146  void MainWindow::file_changed()
1146      }      }
1147  }  }
1148    
1149  void MainWindow::load_gig(gig::File* gig, const char* filename)  void MainWindow::load_gig(gig::File* gig, const char* filename, bool isSharedInstrument)
1150  {  {
1151      file = 0;      file = 0;
1152        set_file_is_shared(isSharedInstrument);
1153    
1154      this->filename = filename ? filename : _("Unsaved Gig File");      this->filename = filename ? filename : _("Unsaved Gig File");
1155      set_title(Glib::filename_display_basename(this->filename));      set_title(Glib::filename_display_basename(this->filename));
# Line 999  void MainWindow::load_gig(gig::File* gig Line 1212  void MainWindow::load_gig(gig::File* gig
1212    
1213  void MainWindow::show_instr_props()  void MainWindow::show_instr_props()
1214  {  {
1215      Glib::RefPtr<Gtk::TreeSelection> tree_sel_ref = m_TreeView.get_selection();      gig::Instrument* instrument = get_instrument();
1216      Gtk::TreeModel::iterator it = tree_sel_ref->get_selected();      if (instrument)
     if (it)  
1217      {      {
1218          Gtk::TreeModel::Row row = *it;          instrumentProps.set_instrument(instrument);
1219          if (row[m_Columns.m_col_instr])          instrumentProps.show();
1220          {          instrumentProps.deiconify();
             instrumentProps.set_instrument(row[m_Columns.m_col_instr]);  
             instrumentProps.show();  
             instrumentProps.deiconify();  
         }  
1221      }      }
1222  }  }
1223    
1224    void MainWindow::on_action_view_status_bar() {
1225        Gtk::CheckMenuItem* item =
1226            dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/Statusbar"));
1227        if (!item) {
1228            std::cerr << "/MenuBar/MenuView/Statusbar == NULL\n";
1229            return;
1230        }
1231        if (item->get_active()) m_StatusBar.show();
1232        else                    m_StatusBar.hide();
1233    }
1234    
1235  void MainWindow::on_button_release(GdkEventButton* button)  void MainWindow::on_button_release(GdkEventButton* button)
1236  {  {
1237      if (button->type == GDK_2BUTTON_PRESS) {      if (button->type == GDK_2BUTTON_PRESS) {
# Line 1070  void MainWindow::on_action_add_instrumen Line 1289  void MainWindow::on_action_add_instrumen
1289    
1290  void MainWindow::on_action_remove_instrument() {  void MainWindow::on_action_remove_instrument() {
1291      if (!file) return;      if (!file) return;
1292        if (file_is_shared) {
1293            Gtk::MessageDialog msg(
1294                *this,
1295                 _("You cannot delete an instrument from this file, since it's "
1296                   "currently used by the sampler."),
1297                 false, Gtk::MESSAGE_INFO
1298            );
1299            msg.run();
1300            return;
1301        }
1302    
1303      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
1304      Gtk::TreeModel::iterator it = sel->get_selected();      Gtk::TreeModel::iterator it = sel->get_selected();
1305      if (it) {      if (it) {
# Line 1256  void MainWindow::on_action_add_sample() Line 1486  void MainWindow::on_action_add_sample()
1486          }          }
1487          // 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
1488          if (error_files.size()) {          if (error_files.size()) {
1489              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;
1490              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1491              msg.run();              msg.run();
1492          }          }
# Line 1429  void MainWindow::on_sample_label_drop_dr Line 1659  void MainWindow::on_sample_label_drop_dr
1659          // notify we're done with altering          // notify we're done with altering
1660          region_changed_signal.emit(region);          region_changed_signal.emit(region);
1661    
1662            file_changed();
1663    
1664          return;          return;
1665      }      }
1666      // drop failed      // drop failed
# Line 1469  void MainWindow::instrument_name_changed Line 1701  void MainWindow::instrument_name_changed
1701      }      }
1702  }  }
1703    
1704    void MainWindow::set_file_is_shared(bool b) {
1705        this->file_is_shared = b;
1706    
1707        if (file_is_shared) {
1708            m_AttachedStateLabel.set_label(_("live-mode"));
1709            m_AttachedStateImage.set(
1710                Gdk::Pixbuf::create_from_xpm_data(status_attached_xpm)
1711            );
1712        } else {
1713            m_AttachedStateLabel.set_label(_("stand-alone"));
1714            m_AttachedStateImage.set(
1715                Gdk::Pixbuf::create_from_xpm_data(status_detached_xpm)
1716            );
1717        }
1718    }
1719    
1720  sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_to_be_changed() {  sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_to_be_changed() {
1721      return file_structure_to_be_changed_signal;      return file_structure_to_be_changed_signal;
1722  }  }
# Line 1504  sigc::signal<void, gig::DimensionRegion* Line 1752  sigc::signal<void, gig::DimensionRegion*
1752  sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {  sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {
1753      return dimreg_changed_signal;      return dimreg_changed_signal;
1754  }  }
1755    
1756    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_on() {
1757        return note_on_signal;
1758    }
1759    
1760    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_off() {
1761        return note_off_signal;
1762    }
1763    
1764    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_hit() {
1765        return m_RegionChooser.signal_keyboard_key_hit();
1766    }
1767    
1768    sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_released() {
1769        return m_RegionChooser.signal_keyboard_key_released();
1770    }
Legend:
Removed from v.1339  
changed lines
  Added in v.1661
  ViewVC Help
Powered by ViewVC