/[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 3471 by persson, Sat Feb 16 19:13:37 2019 UTC revision 3712 by schoenebeck, Fri Jan 10 15:22:34 2020 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (C) 2006-2019 Andreas Persson   * Copyright (C) 2006-2020 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 21  Line 21 
21  #include <cstring>  #include <cstring>
22    
23  #include "compat.h"  #include "compat.h"
 // threads.h must be included first to be able to build with  
 // G_DISABLE_DEPRECATED  
 #if (GLIBMM_MAJOR_VERSION == 2 && GLIBMM_MINOR_VERSION == 31 && GLIBMM_MICRO_VERSION >= 2) || \  
     (GLIBMM_MAJOR_VERSION == 2 && GLIBMM_MINOR_VERSION > 31) || GLIBMM_MAJOR_VERSION > 2  
 #include <glibmm/threads.h>  
 #endif  
24    
25  #include <glibmm/convert.h>  #include <glibmm/convert.h>
26  #include <glibmm/dispatcher.h>  #include <glibmm/dispatcher.h>
# Line 102  MainWindow::MainWindow() : Line 96  MainWindow::MainWindow() :
96    
97      if (!Settings::singleton()->autoRestoreWindowDimension) {      if (!Settings::singleton()->autoRestoreWindowDimension) {
98  #if GTKMM_MAJOR_VERSION >= 3  #if GTKMM_MAJOR_VERSION >= 3
99          set_default_size(895, 600);          set_default_size(960, 600);
100  #else  #else
101          set_default_size(800, 600);          set_default_size(865, 600);
102  #endif  #endif
103          set_position(Gtk::WIN_POS_CENTER);          set_position(Gtk::WIN_POS_CENTER);
104      }      }
# Line 457  MainWindow::MainWindow() : Line 451  MainWindow::MainWindow() :
451          m_actionGroup->add_action_bool("Statusbar", sigc::mem_fun(*this, &MainWindow::on_action_view_status_bar), true);          m_actionGroup->add_action_bool("Statusbar", sigc::mem_fun(*this, &MainWindow::on_action_view_status_bar), true);
452      m_actionToggleRestoreWinDim =      m_actionToggleRestoreWinDim =
453          m_actionGroup->add_action_bool("AutoRestoreWinDim", sigc::mem_fun(*this, &MainWindow::on_auto_restore_win_dim), Settings::singleton()->autoRestoreWindowDimension);          m_actionGroup->add_action_bool("AutoRestoreWinDim", sigc::mem_fun(*this, &MainWindow::on_auto_restore_win_dim), Settings::singleton()->autoRestoreWindowDimension);
454        m_actionInstrDoubleClickOpensProps =
455            m_actionGroup->add_action_bool(
456                "OpenInstrPropsByDoubleClick",
457                sigc::mem_fun(*this, &MainWindow::on_instr_double_click_opens_props),
458                Settings::singleton()->instrumentDoubleClickOpensProps
459            );
460      m_actionToggleShowTooltips = m_actionGroup->add_action_bool(      m_actionToggleShowTooltips = m_actionGroup->add_action_bool(
461          "ShowTooltips", sigc::mem_fun(*this, &MainWindow::on_action_show_tooltips),          "ShowTooltips", sigc::mem_fun(*this, &MainWindow::on_action_show_tooltips),
462          Settings::singleton()->showTooltips          Settings::singleton()->showTooltips
# Line 484  MainWindow::MainWindow() : Line 484  MainWindow::MainWindow() :
484                           *this, &MainWindow::on_auto_restore_win_dim));                           *this, &MainWindow::on_auto_restore_win_dim));
485    
486      toggle_action =      toggle_action =
487            Gtk::ToggleAction::create("OpenInstrPropsByDoubleClick", _("Instrument Properties by Double Click"));
488        toggle_action->set_active(Settings::singleton()->instrumentDoubleClickOpensProps);
489        actionGroup->add(toggle_action,
490                         sigc::mem_fun(
491                             *this, &MainWindow::on_instr_double_click_opens_props));
492    
493        toggle_action =
494          Gtk::ToggleAction::create("ShowTooltips", _("Tooltips for Beginners"));          Gtk::ToggleAction::create("ShowTooltips", _("Tooltips for Beginners"));
495      toggle_action->set_active(Settings::singleton()->showTooltips);      toggle_action->set_active(Settings::singleton()->showTooltips);
496      actionGroup->add(      actionGroup->add(
# Line 515  MainWindow::MainWindow() : Line 522  MainWindow::MainWindow() :
522          "DupInstrument", sigc::mem_fun(*this, &MainWindow::on_action_duplicate_instrument)          "DupInstrument", sigc::mem_fun(*this, &MainWindow::on_action_duplicate_instrument)
523      );      );
524      m_actionGroup->add_action(      m_actionGroup->add_action(
525            "MoveInstrument", sigc::mem_fun(*this, &MainWindow::on_action_move_instr)
526        );
527        m_actionGroup->add_action(
528          "CombInstruments", sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)          "CombInstruments", sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)
529      );      );
530      m_actionGroup->add_action(      m_actionGroup->add_action(
# Line 536  MainWindow::MainWindow() : Line 546  MainWindow::MainWindow() :
546          sigc::mem_fun(*this, &MainWindow::on_action_duplicate_instrument)          sigc::mem_fun(*this, &MainWindow::on_action_duplicate_instrument)
547      );      );
548      actionGroup->add(      actionGroup->add(
549            Gtk::Action::create("MoveInstrument", _("Move _Instrument To ...")),
550            Gtk::AccelKey(GDK_KEY_i, primaryModifierKey),
551            sigc::mem_fun(*this, &MainWindow::on_action_move_instr)
552        );
553        actionGroup->add(
554          Gtk::Action::create("CombInstruments", _("_Combine Instruments ...")),          Gtk::Action::create("CombInstruments", _("_Combine Instruments ...")),
555          Gtk::AccelKey(GDK_KEY_j, primaryModifierKey),          Gtk::AccelKey(GDK_KEY_j, primaryModifierKey),
556          sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)          sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)
# Line 891  MainWindow::MainWindow() : Line 906  MainWindow::MainWindow() :
906          "          <attribute name='label' translatable='yes'>Duplicate Instrument</attribute>"          "          <attribute name='label' translatable='yes'>Duplicate Instrument</attribute>"
907          "          <attribute name='action'>AppMenu.DupInstrument</attribute>"          "          <attribute name='action'>AppMenu.DupInstrument</attribute>"
908          "        </item>"          "        </item>"
909            "        <item id='MoveInstrument'>"
910            "          <attribute name='label' translatable='yes'>Move Instrument To ...</attribute>"
911            "          <attribute name='action'>AppMenu.MoveInstrument</attribute>"
912            "        </item>"
913          "        <item id='CombInstruments'>"          "        <item id='CombInstruments'>"
914          "          <attribute name='label' translatable='yes'>Combine Instrument</attribute>"          "          <attribute name='label' translatable='yes'>Combine Instrument</attribute>"
915          "          <attribute name='action'>AppMenu.CombInstruments</attribute>"          "          <attribute name='action'>AppMenu.CombInstruments</attribute>"
# Line 941  MainWindow::MainWindow() : Line 960  MainWindow::MainWindow() :
960          "          <attribute name='label' translatable='yes'>Auto restore Window Dimensions</attribute>"          "          <attribute name='label' translatable='yes'>Auto restore Window Dimensions</attribute>"
961          "          <attribute name='action'>AppMenu.AutoRestoreWinDim</attribute>"          "          <attribute name='action'>AppMenu.AutoRestoreWinDim</attribute>"
962          "        </item>"          "        </item>"
963            "        <item id='OpenInstrPropsByDoubleClick'>"
964            "          <attribute name='label' translatable='yes'>Instrument Properties by Double Click</attribute>"
965            "          <attribute name='action'>AppMenu.OpenInstrPropsByDoubleClick</attribute>"
966            "        </item>"
967          "      </section>"          "      </section>"
968          "      <section>"          "      <section>"
969          "        <item id='RefreshAll'>"          "        <item id='RefreshAll'>"
# Line 1016  MainWindow::MainWindow() : Line 1039  MainWindow::MainWindow() :
1039          "        <attribute name='label' translatable='yes'>Duplicate Instrument</attribute>"          "        <attribute name='label' translatable='yes'>Duplicate Instrument</attribute>"
1040          "        <attribute name='action'>AppMenu.DupInstrument</attribute>"          "        <attribute name='action'>AppMenu.DupInstrument</attribute>"
1041          "      </item>"          "      </item>"
1042            "      <item id='MoveInstrument'>"
1043            "        <attribute name='label' translatable='yes'>Move Instrument To ...</attribute>"
1044            "        <attribute name='action'>AppMenu.MoveInstrument</attribute>"
1045            "      </item>"
1046          "      <item id='CombInstruments'>"          "      <item id='CombInstruments'>"
1047          "        <attribute name='label' translatable='yes'>Combine Instruments</attribute>"          "        <attribute name='label' translatable='yes'>Combine Instruments</attribute>"
1048          "        <attribute name='action'>AppMenu.CombInstruments</attribute>"          "        <attribute name='action'>AppMenu.CombInstruments</attribute>"
# Line 1154  MainWindow::MainWindow() : Line 1181  MainWindow::MainWindow() :
1181          "      <menu action='AssignScripts'/>"          "      <menu action='AssignScripts'/>"
1182          "      <menuitem action='AddInstrument'/>"          "      <menuitem action='AddInstrument'/>"
1183          "      <menuitem action='DupInstrument'/>"          "      <menuitem action='DupInstrument'/>"
1184            "      <menuitem action='MoveInstrument'/>"
1185          "      <menuitem action='CombInstruments'/>"          "      <menuitem action='CombInstruments'/>"
1186          "      <separator/>"          "      <separator/>"
1187          "      <menuitem action='RemoveInstrument'/>"          "      <menuitem action='RemoveInstrument'/>"
# Line 1169  MainWindow::MainWindow() : Line 1197  MainWindow::MainWindow() :
1197          "      <menuitem action='Statusbar'/>"          "      <menuitem action='Statusbar'/>"
1198          "      <menuitem action='ShowTooltips'/>"          "      <menuitem action='ShowTooltips'/>"
1199          "      <menuitem action='AutoRestoreWinDim'/>"          "      <menuitem action='AutoRestoreWinDim'/>"
1200            "      <menuitem action='OpenInstrPropsByDoubleClick'/>"
1201          "      <separator/>"          "      <separator/>"
1202          "      <menuitem action='RefreshAll'/>"          "      <menuitem action='RefreshAll'/>"
1203          "    </menu>"          "    </menu>"
# Line 1192  MainWindow::MainWindow() : Line 1221  MainWindow::MainWindow() :
1221          "    <menuitem action='ScriptSlots'/>"          "    <menuitem action='ScriptSlots'/>"
1222          "    <menuitem action='AddInstrument'/>"          "    <menuitem action='AddInstrument'/>"
1223          "    <menuitem action='DupInstrument'/>"          "    <menuitem action='DupInstrument'/>"
1224            "    <menuitem action='MoveInstrument'/>"
1225          "    <menuitem action='CombInstruments'/>"          "    <menuitem action='CombInstruments'/>"
1226          "    <separator/>"          "    <separator/>"
1227          "    <menuitem action='RemoveInstrument'/>"          "    <menuitem action='RemoveInstrument'/>"
# Line 1292  MainWindow::MainWindow() : Line 1322  MainWindow::MainWindow() :
1322      }      }
1323      {      {
1324          Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(          Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1325                uiManager->get_widget("/MenuBar/MenuView/OpenInstrPropsByDoubleClick"));
1326            item->set_tooltip_text(_("If checked, double clicking an instrument opens its properties dialog."));
1327        }
1328        {
1329            Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1330              uiManager->get_widget("/MenuBar/MenuTools/CombineInstruments"));              uiManager->get_widget("/MenuBar/MenuTools/CombineInstruments"));
1331          item->set_tooltip_text(_("Create combi sounds out of individual sounds of this .gig file."));          item->set_tooltip_text(_("Create combi sounds out of individual sounds of this .gig file."));
1332      }      }
# Line 1490  MainWindow::MainWindow() : Line 1525  MainWindow::MainWindow() :
1525          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
1526      instrumentProps.signal_changed().connect(      instrumentProps.signal_changed().connect(
1527          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
1528      propDialog.signal_changed().connect(      sampleProps.signal_changed().connect(
1529            sigc::mem_fun(*this, &MainWindow::file_changed));
1530        fileProps.signal_changed().connect(
1531          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
1532      midiRules.signal_changed().connect(      midiRules.signal_changed().connect(
1533          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
# Line 1894  void MainWindow::on_sel_change() Line 1931  void MainWindow::on_sel_change()
1931    
1932    
1933  LoaderSaverBase::LoaderSaverBase(const Glib::ustring filename, gig::File* gig) :  LoaderSaverBase::LoaderSaverBase(const Glib::ustring filename, gig::File* gig) :
1934      filename(filename), gig(gig), thread(0), progress(0.f)      filename(filename), gig(gig),
1935    #ifdef GLIB_THREADS
1936        thread(0),
1937    #endif
1938        progress(0.f)
1939  {  {
1940  }  }
1941    
# Line 1907  void loader_progress_callback(gig::progr Line 1948  void loader_progress_callback(gig::progr
1948  void LoaderSaverBase::progress_callback(float fraction)  void LoaderSaverBase::progress_callback(float fraction)
1949  {  {
1950      {      {
1951    #ifdef GLIB_THREADS
1952          Glib::Threads::Mutex::Lock lock(progressMutex);          Glib::Threads::Mutex::Lock lock(progressMutex);
1953    #else
1954            std::lock_guard<std::mutex> lock(progressMutex);
1955    #endif
1956          progress = fraction;          progress = fraction;
1957      }      }
1958      progress_dispatcher();      progress_dispatcher();
# Line 1919  __attribute__((force_align_arg_pointer)) Line 1964  __attribute__((force_align_arg_pointer))
1964  #endif  #endif
1965  void LoaderSaverBase::thread_function()  void LoaderSaverBase::thread_function()
1966  {  {
1967    #ifdef GLIB_THREADS
1968      printf("thread_function self=%p\n",      printf("thread_function self=%p\n",
1969             static_cast<void*>(Glib::Threads::Thread::self()));             static_cast<void*>(Glib::Threads::Thread::self()));
1970    #else
1971        std::cout << "thread_function self=" << std::this_thread::get_id() << "\n";
1972    #endif
1973      printf("Start %s\n", filename.c_str());      printf("Start %s\n", filename.c_str());
1974      try {      try {
1975          gig::progress_t progress;          gig::progress_t progress;
# Line 1941  void LoaderSaverBase::thread_function() Line 1990  void LoaderSaverBase::thread_function()
1990    
1991  void LoaderSaverBase::launch()  void LoaderSaverBase::launch()
1992  {  {
1993    #ifdef GLIB_THREADS
1994  #ifdef OLD_THREADS  #ifdef OLD_THREADS
1995      thread = Glib::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function), true);      thread = Glib::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function), true);
1996  #else  #else
1997      thread = Glib::Threads::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function));      thread = Glib::Threads::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function));
1998  #endif  #endif
1999      printf("launch thread=%p\n", static_cast<void*>(thread));      printf("launch thread=%p\n", static_cast<void*>(thread));
2000    #else
2001        thread = std::thread([this](){ thread_function(); });
2002        std::cout << "launch thread=" << thread.get_id() << "\n";
2003    #endif
2004  }  }
2005    
2006  float LoaderSaverBase::get_progress()  float LoaderSaverBase::get_progress()
2007  {  {
2008    #ifdef GLIB_THREADS
2009      Glib::Threads::Mutex::Lock lock(progressMutex);      Glib::Threads::Mutex::Lock lock(progressMutex);
2010    #else
2011        std::lock_guard<std::mutex> lock(progressMutex);
2012    #endif
2013      return progress;      return progress;
2014  }  }
2015    
# Line 1971  Glib::Dispatcher& LoaderSaverBase::signa Line 2029  Glib::Dispatcher& LoaderSaverBase::signa
2029  }  }
2030    
2031  void LoaderSaverBase::join() {  void LoaderSaverBase::join() {
2032    #ifdef GLIB_THREADS
2033      thread->join();      thread->join();
2034    #else
2035        thread.join();
2036    #endif
2037  }  }
2038    
2039    
# Line 2186  void MainWindow::on_action_file_open() Line 2248  void MainWindow::on_action_file_open()
2248          dialog.set_current_folder(current_gig_dir);          dialog.set_current_folder(current_gig_dir);
2249      }      }
2250      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
2251            dialog.hide();
2252          std::string filename = dialog.get_filename();          std::string filename = dialog.get_filename();
2253          printf("filename=%s\n", filename.c_str());          printf("filename=%s\n", filename.c_str());
2254    #ifdef GLIB_THREADS
2255          printf("on_action_file_open self=%p\n",          printf("on_action_file_open self=%p\n",
2256                 static_cast<void*>(Glib::Threads::Thread::self()));                 static_cast<void*>(Glib::Threads::Thread::self()));
2257    #else
2258            std::cout << "on_action_file_open self=" <<
2259                std::this_thread::get_id() << "\n";
2260    #endif
2261          load_file(filename.c_str());          load_file(filename.c_str());
2262          current_gig_dir = Glib::path_get_dirname(filename);          current_gig_dir = Glib::path_get_dirname(filename);
2263      }      }
# Line 2264  void MainWindow::on_loader_finished() Line 2332  void MainWindow::on_loader_finished()
2332  {  {
2333      loader->join();      loader->join();
2334      printf("Loader finished!\n");      printf("Loader finished!\n");
2335    #ifdef GLIB_THREADS
2336      printf("on_loader_finished self=%p\n",      printf("on_loader_finished self=%p\n",
2337             static_cast<void*>(Glib::Threads::Thread::self()));             static_cast<void*>(Glib::Threads::Thread::self()));
2338    #else
2339        std::cout << "on_loader_finished self=" <<
2340            std::this_thread::get_id() << "\n";
2341    #endif
2342      load_gig(loader->gig, loader->filename.c_str());      load_gig(loader->gig, loader->filename.c_str());
2343      progress_dialog->hide();      progress_dialog->hide();
2344  }  }
# Line 2444  bool MainWindow::file_save_as() Line 2517  bool MainWindow::file_save_as()
2517  #endif  #endif
2518    
2519      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
2520            dialog.hide();
2521          std::string filename = dialog.get_filename();          std::string filename = dialog.get_filename();
2522          if (!Glib::str_has_suffix(filename, ".gig")) {          if (!Glib::str_has_suffix(filename, ".gig")) {
2523              filename += ".gig";              filename += ".gig";
# Line 2572  void MainWindow::__import_queued_samples Line 2646  void MainWindow::__import_queued_samples
2646    
2647  void MainWindow::on_action_file_properties()  void MainWindow::on_action_file_properties()
2648  {  {
2649      propDialog.show();      fileProps.show();
2650      propDialog.deiconify();      fileProps.deiconify();
2651  }  }
2652    
2653  void MainWindow::on_action_warn_user_on_extensions() {  void MainWindow::on_action_warn_user_on_extensions() {
# Line 2635  void MainWindow::on_action_help_about() Line 2709  void MainWindow::on_action_help_about()
2709              "backup your Gigasampler/GigaStudio files before editing them with "              "backup your Gigasampler/GigaStudio files before editing them with "
2710              "this application.\n"              "this application.\n"
2711              "\n"              "\n"
2712              "Please report bugs to: http://bugs.linuxsampler.org"              "Please report bugs to: https://bugs.linuxsampler.org"
2713          );          );
2714      dialog.set_comments(sComment.c_str());      dialog.set_comments(sComment.c_str());
2715      dialog.set_website("http://www.linuxsampler.org");      dialog.set_website("https://www.linuxsampler.org");
2716      dialog.set_website_label("http://www.linuxsampler.org");      dialog.set_website_label("https://www.linuxsampler.org");
2717      dialog.set_position(Gtk::WIN_POS_CENTER);      dialog.set_position(Gtk::WIN_POS_CENTER);
2718      dialog.run();      dialog.run();
2719  }  }
2720    
2721  PropDialog::PropDialog()  FilePropDialog::FilePropDialog()
2722      : eFileFormat(_("File Format")),      : eFileFormat(_("File Format")),
2723        eName(_("Name")),        eName(_("Name")),
2724        eCreationDate(_("Creation date")),        eCreationDate(_("Creation date")),
# Line 2678  PropDialog::PropDialog() Line 2752  PropDialog::PropDialog()
2752      set_title(_("File Properties"));      set_title(_("File Properties"));
2753      eName.set_width_chars(50);      eName.set_width_chars(50);
2754    
2755      connect(eFileFormat, &PropDialog::set_FileFormat);      connect(eFileFormat, &FilePropDialog::set_FileFormat);
2756      connect(eName, &DLS::Info::Name);      connect(eName, &DLS::Info::Name);
2757      connect(eCreationDate, &DLS::Info::CreationDate);      connect(eCreationDate, &DLS::Info::CreationDate);
2758      connect(eComments, &DLS::Info::Comments);      connect(eComments, &DLS::Info::Comments);
# Line 2739  PropDialog::PropDialog() Line 2813  PropDialog::PropDialog()
2813      quitButton.set_can_default();      quitButton.set_can_default();
2814      quitButton.grab_focus();      quitButton.grab_focus();
2815      quitButton.signal_clicked().connect(      quitButton.signal_clicked().connect(
2816          sigc::mem_fun(*this, &PropDialog::hide));          sigc::mem_fun(*this, &FilePropDialog::hide));
2817    
2818      quitButton.show();      quitButton.show();
2819      vbox.show();      vbox.show();
# Line 2748  PropDialog::PropDialog() Line 2822  PropDialog::PropDialog()
2822  #endif  #endif
2823  }  }
2824    
2825  void PropDialog::set_file(gig::File* file)  void FilePropDialog::set_file(gig::File* file)
2826  {  {
2827      m_file = file;      m_file = file;
2828      update(file->pInfo);      update(file->pInfo);
# Line 2774  void PropDialog::set_file(gig::File* fil Line 2848  void PropDialog::set_file(gig::File* fil
2848      update_model--;      update_model--;
2849  }  }
2850    
2851  void PropDialog::set_FileFormat(int value)  void FilePropDialog::set_FileFormat(int value)
2852  {  {
2853      m_file->pVersion->major = value;      m_file->pVersion->major = value;
2854  }  }
# Line 2818  InstrumentProps::InstrumentProps() : Line 2892  InstrumentProps::InstrumentProps() :
2892      eIsDrum(_("Is drum")),      eIsDrum(_("Is drum")),
2893      eMIDIBank(_("MIDI bank"), 0, 16383),      eMIDIBank(_("MIDI bank"), 0, 16383),
2894      eMIDIProgram(_("MIDI program")),      eMIDIProgram(_("MIDI program")),
2895      eAttenuation(_("Attenuation"), 0, 96, 0, 1),      eAttenuation(_("Attenuation (dB)"), -96, +96, 0, 1),
     eGainPlus6(_("Gain +6dB"), eAttenuation, -6),  
2896      eEffectSend(_("Effect send"), 0, 65535),      eEffectSend(_("Effect send"), 0, 65535),
2897      eFineTune(_("Fine tune"), -8400, 8400),      eFineTune(_("Fine tune"), -8400, 8400),
2898      ePitchbendRange(_("Pitchbend range"), 0, 48),      ePitchbendRange(_("Pitchbend range (halftones)"), 0, 48),
2899      ePianoReleaseMode(_("Piano release mode")),      ePianoReleaseMode(_("Piano release mode")),
2900      eDimensionKeyRangeLow(_("Keyswitching range low")),      eDimensionKeyRangeLow(_("Keyswitching range low")),
2901      eDimensionKeyRangeHigh(_("Keyswitching range high"))      eDimensionKeyRangeHigh(_("Keyswitching range high")),
2902        table2(2,1),
2903        eName2(_("Name")),
2904        eCreationDate(_("Creation date")),
2905        eComments(_("Comments")),
2906        eProduct(_("Product")),
2907        eCopyright(_("Copyright")),
2908        eArtists(_("Artists")),
2909        eGenre(_("Genre")),
2910        eKeywords(_("Keywords")),
2911        eEngineer(_("Engineer")),
2912        eTechnician(_("Technician")),
2913        eSoftware(_("Software")),
2914        eMedium(_("Medium")),
2915        eSource(_("Source")),
2916        eSourceForm(_("Source form")),
2917        eCommissioned(_("Commissioned")),
2918        eSubject(_("Subject"))
2919  {  {
2920      if (!Settings::singleton()->autoRestoreWindowDimension) {      if (!Settings::singleton()->autoRestoreWindowDimension) {
2921          //set_default_size(470, 390);          //set_default_size(470, 390);
# Line 2834  InstrumentProps::InstrumentProps() : Line 2924  InstrumentProps::InstrumentProps() :
2924    
2925      set_title(_("Instrument Properties"));      set_title(_("Instrument Properties"));
2926    
2927        tabs.append_page(vbox[1], _("Settings"));
2928        tabs.append_page(vbox[2], _("Info"));
2929    
2930      eDimensionKeyRangeLow.set_tip(      eDimensionKeyRangeLow.set_tip(
2931          _("start of the keyboard area which should switch the "          _("start of the keyboard area which should switch the "
2932            "\"keyswitching\" dimension")            "\"keyswitching\" dimension")
# Line 2848  InstrumentProps::InstrumentProps() : Line 2941  InstrumentProps::InstrumentProps() :
2941      connect(eMIDIBank, &InstrumentProps::set_MIDIBank);      connect(eMIDIBank, &InstrumentProps::set_MIDIBank);
2942      connect(eMIDIProgram, &InstrumentProps::set_MIDIProgram);      connect(eMIDIProgram, &InstrumentProps::set_MIDIProgram);
2943      connect(eAttenuation, &gig::Instrument::Attenuation);      connect(eAttenuation, &gig::Instrument::Attenuation);
     connect(eGainPlus6, &gig::Instrument::Attenuation);  
2944      connect(eEffectSend, &gig::Instrument::EffectSend);      connect(eEffectSend, &gig::Instrument::EffectSend);
2945      connect(eFineTune, &gig::Instrument::FineTune);      connect(eFineTune, &gig::Instrument::FineTune);
2946      connect(ePitchbendRange, &gig::Instrument::PitchbendRange);      connect(ePitchbendRange, &gig::Instrument::PitchbendRange);
# Line 2858  InstrumentProps::InstrumentProps() : Line 2950  InstrumentProps::InstrumentProps() :
2950    
2951      eName.signal_value_changed().connect(sig_name_changed.make_slot());      eName.signal_value_changed().connect(sig_name_changed.make_slot());
2952    
2953        connect(eName2, &InstrumentProps::set_Name);
2954        connectLambda(eCreationDate, [this](gig::String s) {
2955            m->pInfo->CreationDate = s;
2956        });
2957        connectLambda(eComments, [this](gig::String s) {
2958            m->pInfo->Comments = s;
2959        });
2960        connectLambda(eProduct, [this](gig::String s) {
2961            m->pInfo->Product = s;
2962        });
2963        connectLambda(eCopyright, [this](gig::String s) {
2964            m->pInfo->Copyright = s;
2965        });
2966        connectLambda(eArtists, [this](gig::String s) {
2967            m->pInfo->Artists = s;
2968        });
2969        connectLambda(eGenre, [this](gig::String s) {
2970            m->pInfo->Genre = s;
2971        });
2972        connectLambda(eKeywords, [this](gig::String s) {
2973            m->pInfo->Keywords = s;
2974        });
2975        connectLambda(eEngineer, [this](gig::String s) {
2976            m->pInfo->Engineer = s;
2977        });
2978        connectLambda(eTechnician, [this](gig::String s) {
2979            m->pInfo->Technician = s;
2980        });
2981        connectLambda(eSoftware, [this](gig::String s) {
2982            m->pInfo->Software = s;
2983        });
2984        connectLambda(eMedium, [this](gig::String s) {
2985            m->pInfo->Medium = s;
2986        });
2987        connectLambda(eSource, [this](gig::String s) {
2988            m->pInfo->Source = s;
2989        });
2990        connectLambda(eSourceForm, [this](gig::String s) {
2991            m->pInfo->SourceForm = s;
2992        });
2993        connectLambda(eCommissioned, [this](gig::String s) {
2994            m->pInfo->Commissioned = s;
2995        });
2996        connectLambda(eSubject, [this](gig::String s) {
2997            m->pInfo->Subject = s;
2998        });
2999    
3000        // tab 1
3001  #if USE_GTKMM_GRID  #if USE_GTKMM_GRID
3002      table.set_column_spacing(5);      table.set_column_spacing(5);
3003  #else  #else
3004      table.set_col_spacings(5);      table.set_col_spacings(5);
3005  #endif  #endif
   
3006      table.add(eName);      table.add(eName);
3007      table.add(eIsDrum);      table.add(eIsDrum);
3008      table.add(eMIDIBank);      table.add(eMIDIBank);
3009      table.add(eMIDIProgram);      table.add(eMIDIProgram);
3010      table.add(eAttenuation);      table.add(eAttenuation);
     table.add(eGainPlus6);  
3011      table.add(eEffectSend);      table.add(eEffectSend);
3012      table.add(eFineTune);      table.add(eFineTune);
3013      table.add(ePitchbendRange);      table.add(ePitchbendRange);
# Line 2877  InstrumentProps::InstrumentProps() : Line 3015  InstrumentProps::InstrumentProps() :
3015      table.add(eDimensionKeyRangeLow);      table.add(eDimensionKeyRangeLow);
3016      table.add(eDimensionKeyRangeHigh);      table.add(eDimensionKeyRangeHigh);
3017    
3018      add(vbox);      // tab 2
3019    #if USE_GTKMM_GRID
3020        table2.set_column_spacing(5);
3021    #else
3022        table2.set_col_spacings(5);
3023    #endif
3024        table2.add(eName2);
3025        table2.add(eCreationDate);
3026        table2.add(eComments);
3027        table2.add(eProduct);
3028        table2.add(eCopyright);
3029        table2.add(eArtists);
3030        table2.add(eGenre);
3031        table2.add(eKeywords);
3032        table2.add(eEngineer);
3033        table2.add(eTechnician);
3034        table2.add(eSoftware);
3035        table2.add(eMedium);
3036        table2.add(eSource);
3037        table2.add(eSourceForm);
3038        table2.add(eCommissioned);
3039        table2.add(eSubject);
3040    
3041        add(vbox[0]);
3042  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3043      table.set_margin(5);      table.set_margin(5);
3044  #else  #else
3045      table.set_border_width(5);      table.set_border_width(5);
3046  #endif  #endif
3047      vbox.pack_start(table);      vbox[1].pack_start(table);
3048        vbox[2].pack_start(table2);
3049      table.show();      table.show();
3050      vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);      table2.show();
3051        vbox[0].pack_start(tabs);
3052        vbox[0].pack_start(buttonBox, Gtk::PACK_SHRINK);
3053      buttonBox.set_layout(Gtk::BUTTONBOX_END);      buttonBox.set_layout(Gtk::BUTTONBOX_END);
3054  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3055      buttonBox.set_margin(5);      buttonBox.set_margin(5);
# Line 2901  InstrumentProps::InstrumentProps() : Line 3065  InstrumentProps::InstrumentProps() :
3065          sigc::mem_fun(*this, &InstrumentProps::hide));          sigc::mem_fun(*this, &InstrumentProps::hide));
3066    
3067      quitButton.show();      quitButton.show();
3068      vbox.show();      vbox[0].show();
3069  #if HAS_GTKMM_SHOW_ALL_CHILDREN  #if HAS_GTKMM_SHOW_ALL_CHILDREN
3070      show_all_children();      show_all_children();
3071  #endif  #endif
# Line 2912  void InstrumentProps::set_instrument(gig Line 3076  void InstrumentProps::set_instrument(gig
3076      update(instrument);      update(instrument);
3077    
3078      update_model++;      update_model++;
3079    
3080        // tab 1
3081      eName.set_value(instrument->pInfo->Name);      eName.set_value(instrument->pInfo->Name);
3082      eIsDrum.set_value(instrument->IsDrum);      eIsDrum.set_value(instrument->IsDrum);
3083      eMIDIBank.set_value(instrument->MIDIBank);      eMIDIBank.set_value(instrument->MIDIBank);
3084      eMIDIProgram.set_value(instrument->MIDIProgram);      eMIDIProgram.set_value(instrument->MIDIProgram);
3085        // tab 2
3086        eName2.set_value(instrument->pInfo->Name);
3087        eCreationDate.set_value(instrument->pInfo->CreationDate);
3088        eComments.set_value(instrument->pInfo->Comments);
3089        eProduct.set_value(instrument->pInfo->Product);
3090        eCopyright.set_value(instrument->pInfo->Copyright);
3091        eArtists.set_value(instrument->pInfo->Artists);
3092        eGenre.set_value(instrument->pInfo->Genre);
3093        eKeywords.set_value(instrument->pInfo->Keywords);
3094        eEngineer.set_value(instrument->pInfo->Engineer);
3095        eTechnician.set_value(instrument->pInfo->Technician);
3096        eSoftware.set_value(instrument->pInfo->Software);
3097        eMedium.set_value(instrument->pInfo->Medium);
3098        eSource.set_value(instrument->pInfo->Source);
3099        eSourceForm.set_value(instrument->pInfo->SourceForm);
3100        eCommissioned.set_value(instrument->pInfo->Commissioned);
3101        eSubject.set_value(instrument->pInfo->Subject);
3102    
3103        update_model--;
3104    }
3105    
3106    
3107    SampleProps::SampleProps() :
3108    #if HAS_GTKMM_STOCK
3109        quitButton(Gtk::Stock::CLOSE),
3110    #else
3111        quitButton(_("_Close")),
3112    #endif
3113        table(2,1),
3114        eName(_("Name")),
3115        eUnityNote(_("Unity Note")),
3116        eSampleGroup(_("Sample Group")),
3117        eSampleFormatInfo(_("Sample Format")),
3118        eSampleID("Sample ID"),
3119        eChecksum("Wave Data CRC-32"),
3120        eLoopsCount(_("Loops"), 0, 1), // we might support more than 1 loop in future
3121        eLoopStart(_("Loop start position"), 0, 9999999),
3122        eLoopLength(_("Loop size"), 0, 9999999),
3123        eLoopType(_("Loop type")),
3124        eLoopPlayCount(_("Playback count")),
3125        table2(2,1),
3126        eName2(_("Name")),
3127        eCreationDate(_("Creation date")),
3128        eComments(_("Comments")),
3129        eProduct(_("Product")),
3130        eCopyright(_("Copyright")),
3131        eArtists(_("Artists")),
3132        eGenre(_("Genre")),
3133        eKeywords(_("Keywords")),
3134        eEngineer(_("Engineer")),
3135        eTechnician(_("Technician")),
3136        eSoftware(_("Software")),
3137        eMedium(_("Medium")),
3138        eSource(_("Source")),
3139        eSourceForm(_("Source form")),
3140        eCommissioned(_("Commissioned")),
3141        eSubject(_("Subject"))
3142    {
3143        if (!Settings::singleton()->autoRestoreWindowDimension) {
3144            //set_default_size(470, 390);
3145            set_position(Gtk::WIN_POS_MOUSE);
3146        }
3147    
3148        set_title(_("Sample Properties"));
3149    
3150        tabs.append_page(vbox[1], _("Settings"));
3151        tabs.append_page(vbox[2], _("Info"));
3152    
3153        connect(eName, &SampleProps::set_Name);
3154        connect(eUnityNote, &gig::Sample::MIDIUnityNote);
3155        connect(eLoopsCount, &gig::Sample::Loops);
3156        connectLambda(eLoopStart, [this](uint32_t start){
3157            m->LoopStart = start;
3158            m->LoopEnd = start + m->LoopSize;
3159        });
3160        connectLambda(eLoopLength, [this](uint32_t length){
3161            m->LoopSize = length;
3162            m->LoopEnd = m->LoopStart + length;
3163        });
3164        {
3165            const char* choices[] = { _("normal"), _("bidirectional"), _("backward"), 0 };
3166            static const gig::loop_type_t values[] = {
3167                gig::loop_type_normal,
3168                gig::loop_type_bidirectional,
3169                gig::loop_type_backward
3170            };
3171            eLoopType.set_choices(choices, values);
3172        }
3173        connect(eLoopType, &gig::Sample::LoopType);
3174        connect(eLoopPlayCount, &gig::Sample::LoopPlayCount);
3175    
3176        eName.signal_value_changed().connect(sig_name_changed.make_slot());
3177    
3178        connect(eName2, &SampleProps::set_Name);
3179        connectLambda(eCreationDate, [this](gig::String s) {
3180            m->pInfo->CreationDate = s;
3181        });
3182        connectLambda(eComments, [this](gig::String s) {
3183            m->pInfo->Comments = s;
3184        });
3185        connectLambda(eProduct, [this](gig::String s) {
3186            m->pInfo->Product = s;
3187        });
3188        connectLambda(eCopyright, [this](gig::String s) {
3189            m->pInfo->Copyright = s;
3190        });
3191        connectLambda(eArtists, [this](gig::String s) {
3192            m->pInfo->Artists = s;
3193        });
3194        connectLambda(eGenre, [this](gig::String s) {
3195            m->pInfo->Genre = s;
3196        });
3197        connectLambda(eKeywords, [this](gig::String s) {
3198            m->pInfo->Keywords = s;
3199        });
3200        connectLambda(eEngineer, [this](gig::String s) {
3201            m->pInfo->Engineer = s;
3202        });
3203        connectLambda(eTechnician, [this](gig::String s) {
3204            m->pInfo->Technician = s;
3205        });
3206        connectLambda(eSoftware, [this](gig::String s) {
3207            m->pInfo->Software = s;
3208        });
3209        connectLambda(eMedium, [this](gig::String s) {
3210            m->pInfo->Medium = s;
3211        });
3212        connectLambda(eSource, [this](gig::String s) {
3213            m->pInfo->Source = s;
3214        });
3215        connectLambda(eSourceForm, [this](gig::String s) {
3216            m->pInfo->SourceForm = s;
3217        });
3218        connectLambda(eCommissioned, [this](gig::String s) {
3219            m->pInfo->Commissioned = s;
3220        });
3221        connectLambda(eSubject, [this](gig::String s) {
3222            m->pInfo->Subject = s;
3223        });
3224    
3225        // tab 1
3226    #if USE_GTKMM_GRID
3227        table.set_column_spacing(5);
3228    #else
3229        table.set_col_spacings(5);
3230    #endif
3231        table.add(eName);
3232        table.add(eUnityNote);
3233        table.add(eSampleGroup);
3234        table.add(eSampleFormatInfo);
3235        table.add(eSampleID);
3236        table.add(eChecksum);
3237        table.add(eLoopsCount);
3238        table.add(eLoopStart);
3239        table.add(eLoopLength);
3240        table.add(eLoopType);
3241        table.add(eLoopPlayCount);
3242    
3243        // tab 2
3244    #if USE_GTKMM_GRID
3245        table2.set_column_spacing(5);
3246    #else
3247        table2.set_col_spacings(5);
3248    #endif
3249        table2.add(eName2);
3250        table2.add(eCreationDate);
3251        table2.add(eComments);
3252        table2.add(eProduct);
3253        table2.add(eCopyright);
3254        table2.add(eArtists);
3255        table2.add(eGenre);
3256        table2.add(eKeywords);
3257        table2.add(eEngineer);
3258        table2.add(eTechnician);
3259        table2.add(eSoftware);
3260        table2.add(eMedium);
3261        table2.add(eSource);
3262        table2.add(eSourceForm);
3263        table2.add(eCommissioned);
3264        table2.add(eSubject);
3265    
3266        add(vbox[0]);
3267    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3268        table.set_margin(5);
3269    #else
3270        table.set_border_width(5);
3271    #endif
3272        vbox[1].pack_start(table);
3273        vbox[2].pack_start(table2);
3274        table.show();
3275        table2.show();
3276        vbox[0].pack_start(tabs);
3277        vbox[0].pack_start(buttonBox, Gtk::PACK_SHRINK);
3278        buttonBox.set_layout(Gtk::BUTTONBOX_END);
3279    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3280        buttonBox.set_margin(5);
3281    #else
3282        buttonBox.set_border_width(5);
3283    #endif
3284        buttonBox.show();
3285        buttonBox.pack_start(quitButton);
3286        quitButton.set_can_default();
3287        quitButton.grab_focus();
3288    
3289        quitButton.signal_clicked().connect(
3290            sigc::mem_fun(*this, &SampleProps::hide));
3291    
3292        quitButton.show();
3293        vbox[0].show();
3294    #if HAS_GTKMM_SHOW_ALL_CHILDREN
3295        show_all_children();
3296    #endif
3297    }
3298    
3299    void SampleProps::set_sample(gig::Sample* sample)
3300    {
3301        update(sample);
3302    
3303        update_model++;
3304    
3305        // tab 1
3306        eName.set_value(sample->pInfo->Name);
3307        eUnityNote.set_value(sample->MIDIUnityNote);
3308        // show sample group name
3309        {
3310            Glib::ustring s = "---";
3311            if (sample && sample->GetGroup())
3312                s = sample->GetGroup()->Name;
3313            eSampleGroup.text.set_text(s);
3314        }
3315        // assemble sample format info string
3316        {
3317            Glib::ustring s;
3318            if (sample) {
3319                switch (sample->Channels) {
3320                    case 1: s = _("Mono"); break;
3321                    case 2: s = _("Stereo"); break;
3322                    default:
3323                        s = ToString(sample->Channels) + _(" audio channels");
3324                        break;
3325                }
3326                s += " " + ToString(sample->BitDepth) + " Bits";
3327                s += " " + ToString(sample->SamplesPerSecond/1000) + "."
3328                         + ToString((sample->SamplesPerSecond%1000)/100) + " kHz";
3329            } else {
3330                s = _("No sample assigned to this dimension region.");
3331            }
3332            eSampleFormatInfo.text.set_text(s);
3333        }
3334        // generate sample's memory address pointer string
3335        {
3336            Glib::ustring s;
3337            if (sample) {
3338                char buf[64] = {};
3339                snprintf(buf, sizeof(buf), "%p", sample);
3340                s = buf;
3341            } else {
3342                s = "---";
3343            }
3344            eSampleID.text.set_text(s);
3345        }
3346        // generate raw wave form data CRC-32 checksum string
3347        {
3348            Glib::ustring s = "---";
3349            if (sample) {
3350                char buf[64] = {};
3351                snprintf(buf, sizeof(buf), "%x", sample->GetWaveDataCRC32Checksum());
3352                s = buf;
3353            }
3354            eChecksum.text.set_text(s);
3355        }
3356        eLoopsCount.set_value(sample->Loops);
3357        eLoopStart.set_value(sample->LoopStart);
3358        eLoopLength.set_value(sample->LoopSize);
3359        eLoopType.set_value(sample->LoopType);
3360        eLoopPlayCount.set_value(sample->LoopPlayCount);
3361        // tab 2
3362        eName2.set_value(sample->pInfo->Name);
3363        eCreationDate.set_value(sample->pInfo->CreationDate);
3364        eComments.set_value(sample->pInfo->Comments);
3365        eProduct.set_value(sample->pInfo->Product);
3366        eCopyright.set_value(sample->pInfo->Copyright);
3367        eArtists.set_value(sample->pInfo->Artists);
3368        eGenre.set_value(sample->pInfo->Genre);
3369        eKeywords.set_value(sample->pInfo->Keywords);
3370        eEngineer.set_value(sample->pInfo->Engineer);
3371        eTechnician.set_value(sample->pInfo->Technician);
3372        eSoftware.set_value(sample->pInfo->Software);
3373        eMedium.set_value(sample->pInfo->Medium);
3374        eSource.set_value(sample->pInfo->Source);
3375        eSourceForm.set_value(sample->pInfo->SourceForm);
3376        eCommissioned.set_value(sample->pInfo->Commissioned);
3377        eSubject.set_value(sample->pInfo->Subject);
3378    
3379        update_model--;
3380    }
3381    
3382    void SampleProps::set_Name(const gig::String& name)
3383    {
3384        m->pInfo->Name = name;
3385    }
3386    
3387    void SampleProps::update_name()
3388    {
3389        update_model++;
3390        eName.set_value(m->pInfo->Name);
3391      update_model--;      update_model--;
3392  }  }
3393    
# Line 3011  void MainWindow::load_gig(gig::File* gig Line 3483  void MainWindow::load_gig(gig::File* gig
3483      file_has_name = filename;      file_has_name = filename;
3484      file_is_changed = false;      file_is_changed = false;
3485    
3486      propDialog.set_file(gig);      fileProps.set_file(gig);
3487    
3488      instrument_name_connection.block();      instrument_name_connection.block();
3489      int index = 0;      int index = 0;
# Line 3151  void MainWindow::instr_name_changed_by_i Line 3623  void MainWindow::instr_name_changed_by_i
3623      }      }
3624  }  }
3625    
3626    bool MainWindow::sample_props_set_sample()
3627    {
3628        sampleProps.signal_name_changed().clear();
3629    
3630        std::vector<Gtk::TreeModel::Path> rows = m_TreeViewSamples.get_selection()->get_selected_rows();
3631        if (rows.empty()) {
3632            sampleProps.hide();
3633            return false;
3634        }
3635        //NOTE: was const_iterator before, which did not compile with GTKMM4 development branch, probably going to be fixed before final GTKMM4 release though.
3636        Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
3637        if (it) {
3638            Gtk::TreeModel::Row row = *it;
3639            gig::Sample* sample = row[m_SamplesModel.m_col_sample];
3640    
3641            sampleProps.set_sample(sample);
3642    
3643            // make sure sample tree is updated when user changes the
3644            // sample name in sample properties window
3645            sampleProps.signal_name_changed().connect(
3646                sigc::bind(
3647                    sigc::mem_fun(*this,
3648                        &MainWindow::sample_name_changed_by_sample_props
3649                    ), it
3650                )
3651            );
3652        } else {
3653            sampleProps.hide();
3654        }
3655        //NOTE: explicit boolean cast required for GTKMM4 development branch here
3656        return it ? true : false;
3657    }
3658    
3659    void MainWindow::show_sample_props()
3660    {
3661        if (sample_props_set_sample()) {
3662            sampleProps.show();
3663            sampleProps.deiconify();
3664        }
3665    }
3666    
3667    void MainWindow::sample_name_changed_by_sample_props(Gtk::TreeModel::iterator& it)
3668    {
3669        Gtk::TreeModel::Row row = *it;
3670        Glib::ustring name = row[m_SamplesModel.m_col_name];
3671    
3672        gig::Sample* sample = row[m_SamplesModel.m_col_sample];
3673        Glib::ustring gigname(gig_to_utf8(sample->pInfo->Name));
3674        if (gigname != name) {
3675            Gtk::TreeModel::Path path(*it);
3676            row[m_SamplesModel.m_col_name] = gigname;
3677        }
3678    }
3679    
3680  void MainWindow::show_midi_rules()  void MainWindow::show_midi_rules()
3681  {  {
3682      if (gig::Instrument* instrument = get_instrument())      if (gig::Instrument* instrument = get_instrument())
# Line 3279  void MainWindow::on_auto_restore_win_dim Line 3805  void MainWindow::on_auto_restore_win_dim
3805  #endif  #endif
3806  }  }
3807    
3808    void MainWindow::on_instr_double_click_opens_props() {
3809    #if USE_GLIB_ACTION
3810        bool active = false;
3811        m_actionInstrDoubleClickOpensProps->get_state(active);
3812        // for some reason toggle state does not change automatically
3813        active = !active;
3814        m_actionInstrDoubleClickOpensProps->change_state(active);
3815        Settings::singleton()->instrumentDoubleClickOpensProps = active;
3816    #else
3817        Gtk::CheckMenuItem* item =
3818            dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/OpenInstrPropsByDoubleClick"));
3819        if (!item) {
3820            std::cerr << "/MenuBar/MenuView/OpenInstrPropsByDoubleClick == NULL\n";
3821            return;
3822        }
3823        Settings::singleton()->instrumentDoubleClickOpensProps = item->get_active();
3824    #endif
3825    }
3826    
3827  void MainWindow::on_save_with_temporary_file() {  void MainWindow::on_save_with_temporary_file() {
3828  #if USE_GLIB_ACTION  #if USE_GLIB_ACTION
3829      bool active = false;      bool active = false;
# Line 3353  bool MainWindow::on_button_release(Gdk:: Line 3898  bool MainWindow::on_button_release(Gdk::
3898  void MainWindow::on_button_release(GdkEventButton* button) {  void MainWindow::on_button_release(GdkEventButton* button) {
3899  #endif  #endif
3900      if (button->type == GDK_2BUTTON_PRESS) {      if (button->type == GDK_2BUTTON_PRESS) {
3901          show_instr_props();          if (Settings::singleton()->instrumentDoubleClickOpensProps)
3902                show_instr_props();
3903      } else if (button->type == GDK_BUTTON_PRESS && button->button == 3) {      } else if (button->type == GDK_BUTTON_PRESS && button->button == 3) {
3904          // gig v2 files have no midi rules          // gig v2 files have no midi rules
3905          const bool bEnabled = !(file->pVersion && file->pVersion->major == 2);          const bool bEnabled = !(file->pVersion && file->pVersion->major == 2);
# Line 3393  void MainWindow::on_instrument_selection Line 3939  void MainWindow::on_instrument_selection
3939  }  }
3940  #endif  #endif
3941    
3942    void MainWindow::on_action_move_instr() {
3943        gig::Instrument* instr = get_instrument();
3944        if (!instr) return;
3945    
3946        int currentIndex = getIndexOf(instr);
3947    
3948        Gtk::Dialog dialog(_("Move Instrument"), true /*modal*/);
3949    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
3950        Gtk::Adjustment adjustment(
3951            currentIndex,
3952            0 /*min*/, file->CountInstruments() - 1 /*max*/
3953        );
3954        Gtk::SpinButton spinBox(adjustment);
3955    #else
3956        Gtk::SpinButton spinBox(
3957            Gtk::Adjustment::create(
3958                currentIndex,
3959                0 /*min*/, file->CountInstruments() - 1 /*max*/
3960            )
3961        );
3962    #endif
3963    #if USE_GTKMM_BOX
3964        dialog.get_content_area()->pack_start(spinBox);
3965    #else
3966        dialog.get_vbox()->pack_start(spinBox);
3967    #endif
3968    #if HAS_GTKMM_STOCK
3969        Gtk::Button* okButton = dialog.add_button(Gtk::Stock::OK, 0);
3970        dialog.add_button(Gtk::Stock::CANCEL, 1);
3971    #else
3972        Gtk::Button* okButton = dialog.add_button(_("_OK"), 0);
3973        dialog.add_button(_("_Cancel"), 1);
3974    #endif
3975        okButton->set_sensitive(false);
3976        // show the dialog at a reasonable screen position
3977        dialog.set_position(Gtk::WIN_POS_MOUSE);
3978        // only enable the 'OK' button if entered new index is not instrument's
3979        // current index already
3980        spinBox.signal_value_changed().connect([&]{
3981            okButton->set_sensitive( spinBox.get_value_as_int() != currentIndex );
3982        });
3983        // usability acceleration: if user hits enter key on the text entry field
3984        // then auto trigger the 'OK' button
3985        spinBox.signal_activate().connect([&]{
3986            if (okButton->get_sensitive())
3987                okButton->clicked();
3988        });
3989    #if HAS_GTKMM_SHOW_ALL_CHILDREN
3990        dialog.show_all_children();
3991    #endif
3992        if (!dialog.run()) { // 'OK' selected ...
3993            int newIndex = spinBox.get_value_as_int();
3994            printf("MOVE TO %d\n", newIndex);
3995            gig::Instrument* dst = file->GetInstrument(newIndex);
3996            instr->MoveTo(dst);
3997            __refreshEntireGUI();
3998            select_instrument(instr);
3999        }
4000    }
4001    
4002  void MainWindow::select_instrument(gig::Instrument* instrument) {  void MainWindow::select_instrument(gig::Instrument* instrument) {
4003      if (!instrument) return;      if (!instrument) return;
4004    
# Line 3857  void MainWindow::on_action_remove_instru Line 4463  void MainWindow::on_action_remove_instru
4463  }  }
4464    
4465  void MainWindow::on_action_sample_properties() {  void MainWindow::on_action_sample_properties() {
4466      //TODO: show a dialog where the selected sample's properties can be edited      show_sample_props();
     Gtk::MessageDialog msg(  
         *this, _("Sorry, yet to be implemented!"), false, Gtk::MESSAGE_INFO  
     );  
     msg.run();  
4467  }  }
4468    
4469  void MainWindow::on_action_add_script_group() {  void MainWindow::on_action_add_script_group() {
# Line 4080  void MainWindow::add_or_replace_sample(b Line 4682  void MainWindow::add_or_replace_sample(b
4682          dialog.set_current_folder(current_sample_dir);          dialog.set_current_folder(current_sample_dir);
4683      }      }
4684      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
4685            dialog.hide();
4686          current_sample_dir = dialog.get_current_folder();          current_sample_dir = dialog.get_current_folder();
4687          Glib::ustring error_files;          Glib::ustring error_files;
4688          std::vector<std::string> filenames = dialog.get_filenames();          std::vector<std::string> filenames = dialog.get_filenames();
# Line 4260  void MainWindow::on_action_replace_all_s Line 4863  void MainWindow::on_action_replace_all_s
4863      }      }
4864      if (dialog.run() == Gtk::RESPONSE_OK)      if (dialog.run() == Gtk::RESPONSE_OK)
4865      {      {
4866            dialog.hide();
4867          current_sample_dir = dialog.get_current_folder();          current_sample_dir = dialog.get_current_folder();
4868          Glib::ustring error_files;          Glib::ustring error_files;
4869          std::string folder = dialog.get_filename();          std::string folder = dialog.get_filename();
# Line 4658  void MainWindow::sample_name_changed(con Line 5262  void MainWindow::sample_name_changed(con
5262              file_changed();              file_changed();
5263          }          }
5264      }      }
5265        // change name in the sample properties window
5266        if (sampleProps.get_sample() == sample && sample) {
5267            sampleProps.set_sample(sample);
5268        }
5269  }  }
5270    
5271  void MainWindow::script_name_changed(const Gtk::TreeModel::Path& path,  void MainWindow::script_name_changed(const Gtk::TreeModel::Path& path,
# Line 4988  void MainWindow::on_action_merge_files() Line 5596  void MainWindow::on_action_merge_files()
5596  #endif  #endif
5597    
5598      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
5599            dialog.hide();
5600    #ifdef GLIB_THREADS
5601          printf("on_action_merge_files self=%p\n",          printf("on_action_merge_files self=%p\n",
5602                 static_cast<void*>(Glib::Threads::Thread::self()));                 static_cast<void*>(Glib::Threads::Thread::self()));
5603    #else
5604            std::cout << "on_action_merge_files self=" <<
5605                std::this_thread::get_id() << "\n";
5606    #endif
5607          std::vector<std::string> filenames = dialog.get_filenames();          std::vector<std::string> filenames = dialog.get_filenames();
5608    
5609          // merge the selected files to the currently open .gig file          // merge the selected files to the currently open .gig file
Legend:
Removed from v.3471  
changed lines
  Added in v.3712
  ViewVC Help
Powered by ViewVC