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

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

Parent Directory | Revision Log | View Patch Patch

-revision 3471 by persson,
Sat Feb 16 19:13:37 2019 UTC
+revision 3831 by schoenebeck,
Thu Oct 15 18:08:49 2020 UTC
 Line 1
  /*
-  * Copyright (C) 2006-2019 Andreas Persson
+  * Copyright (C) 2006-2020 Andreas Persson
   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public License as
 Line 21
  #include <cstring>
  #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
  #include <glibmm/convert.h>
  #include <glibmm/dispatcher.h>
-Line 102 
 MainWindow::MainWindow() :
+Line 96 
 MainWindow::MainWindow() :
      if (!Settings::singleton()->autoRestoreWindowDimension) {
  #if GTKMM_MAJOR_VERSION >= 3
-         set_default_size(895, 600);
+         set_default_size(1010, -1);
  #else
-         set_default_size(800, 600);
+         set_default_size(915, -1);
  #endif
          set_position(Gtk::WIN_POS_CENTER);
      }
-Line 112 
 MainWindow::MainWindow() :
+Line 106 
 MainWindow::MainWindow() :
      add(m_VBox);
      // Handle selection
-     m_TreeView.get_selection()->signal_changed().connect(
+     m_TreeViewInstruments.get_selection()->signal_changed().connect(
          sigc::mem_fun(*this, &MainWindow::on_sel_change));
-     // m_TreeView.set_reorderable();
+     // m_TreeViewInstruments.set_reorderable();
  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
-     m_TreeView.signal_button_press_event().connect(
+     m_TreeViewInstruments.signal_button_press_event().connect(
          sigc::mem_fun(*this, &MainWindow::on_button_release));
  #else
-     m_TreeView.signal_button_press_event().connect_notify(
+     m_TreeViewInstruments.signal_button_press_event().connect_notify(
          sigc::mem_fun(*this, &MainWindow::on_button_release));
  #endif
      // Add the TreeView tab, inside a ScrolledWindow, with the button underneath:
-     m_ScrolledWindow.add(m_TreeView);
+     m_ScrolledWindow.add(m_TreeViewInstruments);
  //    m_ScrolledWindow.set_size_request(200, 600);
      m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
-Line 457 
 MainWindow::MainWindow() :
+Line 451 
 MainWindow::MainWindow() :
          m_actionGroup->add_action_bool("Statusbar", sigc::mem_fun(*this, &MainWindow::on_action_view_status_bar), true);
      m_actionToggleRestoreWinDim =
          m_actionGroup->add_action_bool("AutoRestoreWinDim", sigc::mem_fun(*this, &MainWindow::on_auto_restore_win_dim), Settings::singleton()->autoRestoreWindowDimension);
+     m_actionInstrDoubleClickOpensProps =
+         m_actionGroup->add_action_bool(
+             "OpenInstrPropsByDoubleClick",
+             sigc::mem_fun(*this, &MainWindow::on_instr_double_click_opens_props),
+             Settings::singleton()->instrumentDoubleClickOpensProps
+         );
      m_actionToggleShowTooltips = m_actionGroup->add_action_bool(
          "ShowTooltips", sigc::mem_fun(*this, &MainWindow::on_action_show_tooltips),
          Settings::singleton()->showTooltips
 Line 484 
 MainWindow::MainWindow() :
                           *this, &MainWindow::on_auto_restore_win_dim));
      toggle_action =
+         Gtk::ToggleAction::create("OpenInstrPropsByDoubleClick", _("Instrument Properties by Double Click"));
+     toggle_action->set_active(Settings::singleton()->instrumentDoubleClickOpensProps);
+     actionGroup->add(toggle_action,
+                      sigc::mem_fun(
+                          *this, &MainWindow::on_instr_double_click_opens_props));
+     toggle_action =
          Gtk::ToggleAction::create("ShowTooltips", _("Tooltips for Beginners"));
      toggle_action->set_active(Settings::singleton()->showTooltips);
      actionGroup->add(
-Line 515 
 MainWindow::MainWindow() :
+Line 522 
 MainWindow::MainWindow() :
          "DupInstrument", sigc::mem_fun(*this, &MainWindow::on_action_duplicate_instrument)
      );
      m_actionGroup->add_action(
+         "MoveInstrument", sigc::mem_fun(*this, &MainWindow::on_action_move_instr)
+     );
+     m_actionGroup->add_action(
          "CombInstruments", sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)
      );
      m_actionGroup->add_action(
-Line 536 
 MainWindow::MainWindow() :
+Line 546 
 MainWindow::MainWindow() :
          sigc::mem_fun(*this, &MainWindow::on_action_duplicate_instrument)
      );
      actionGroup->add(
+         Gtk::Action::create("MoveInstrument", _("Move _Instrument To ...")),
+         Gtk::AccelKey(GDK_KEY_i, primaryModifierKey),
+         sigc::mem_fun(*this, &MainWindow::on_action_move_instr)
+     );
+     actionGroup->add(
          Gtk::Action::create("CombInstruments", _("_Combine Instruments ...")),
          Gtk::AccelKey(GDK_KEY_j, primaryModifierKey),
          sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)
-Line 891 
 MainWindow::MainWindow() :
+Line 906 
 MainWindow::MainWindow() :
          "          <attribute name='label' translatable='yes'>Duplicate Instrument</attribute>"
          "          <attribute name='action'>AppMenu.DupInstrument</attribute>"
          "        </item>"
+         "        <item id='MoveInstrument'>"
+         "          <attribute name='label' translatable='yes'>Move Instrument To ...</attribute>"
+         "          <attribute name='action'>AppMenu.MoveInstrument</attribute>"
+         "        </item>"
          "        <item id='CombInstruments'>"
          "          <attribute name='label' translatable='yes'>Combine Instrument</attribute>"
          "          <attribute name='action'>AppMenu.CombInstruments</attribute>"
-Line 941 
 MainWindow::MainWindow() :
+Line 960 
 MainWindow::MainWindow() :
          "          <attribute name='label' translatable='yes'>Auto restore Window Dimensions</attribute>"
          "          <attribute name='action'>AppMenu.AutoRestoreWinDim</attribute>"
          "        </item>"
+         "        <item id='OpenInstrPropsByDoubleClick'>"
+         "          <attribute name='label' translatable='yes'>Instrument Properties by Double Click</attribute>"
+         "          <attribute name='action'>AppMenu.OpenInstrPropsByDoubleClick</attribute>"
+         "        </item>"
          "      </section>"
          "      <section>"
          "        <item id='RefreshAll'>"
-Line 1016 
 MainWindow::MainWindow() :
+Line 1039 
 MainWindow::MainWindow() :
          "        <attribute name='label' translatable='yes'>Duplicate Instrument</attribute>"
          "        <attribute name='action'>AppMenu.DupInstrument</attribute>"
          "      </item>"
+         "      <item id='MoveInstrument'>"
+         "        <attribute name='label' translatable='yes'>Move Instrument To ...</attribute>"
+         "        <attribute name='action'>AppMenu.MoveInstrument</attribute>"
+         "      </item>"
          "      <item id='CombInstruments'>"
          "        <attribute name='label' translatable='yes'>Combine Instruments</attribute>"
          "        <attribute name='action'>AppMenu.CombInstruments</attribute>"
-Line 1154 
 MainWindow::MainWindow() :
+Line 1181 
 MainWindow::MainWindow() :
          "      <menu action='AssignScripts'/>"
          "      <menuitem action='AddInstrument'/>"
          "      <menuitem action='DupInstrument'/>"
+         "      <menuitem action='MoveInstrument'/>"
          "      <menuitem action='CombInstruments'/>"
          "      <separator/>"
          "      <menuitem action='RemoveInstrument'/>"
-Line 1169 
 MainWindow::MainWindow() :
+Line 1197 
 MainWindow::MainWindow() :
          "      <menuitem action='Statusbar'/>"
          "      <menuitem action='ShowTooltips'/>"
          "      <menuitem action='AutoRestoreWinDim'/>"
+         "      <menuitem action='OpenInstrPropsByDoubleClick'/>"
          "      <separator/>"
          "      <menuitem action='RefreshAll'/>"
          "    </menu>"
-Line 1192 
 MainWindow::MainWindow() :
+Line 1221 
 MainWindow::MainWindow() :
          "    <menuitem action='ScriptSlots'/>"
          "    <menuitem action='AddInstrument'/>"
          "    <menuitem action='DupInstrument'/>"
+         "    <menuitem action='MoveInstrument'/>"
          "    <menuitem action='CombInstruments'/>"
          "    <separator/>"
          "    <menuitem action='RemoveInstrument'/>"
-Line 1292 
 MainWindow::MainWindow() :
+Line 1322 
 MainWindow::MainWindow() :
      }
      {
          Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
+             uiManager->get_widget("/MenuBar/MenuView/OpenInstrPropsByDoubleClick"));
+         item->set_tooltip_text(_("If checked, double clicking an instrument opens its properties dialog."));
+     }
+     {
+         Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
              uiManager->get_widget("/MenuBar/MenuTools/CombineInstruments"));
          item->set_tooltip_text(_("Create combi sounds out of individual sounds of this .gig file."));
      }
-Line 1348 
 MainWindow::MainWindow() :
+Line 1383 
 MainWindow::MainWindow() :
      // Create the Tree model:
-     m_refTreeModel = Gtk::ListStore::create(m_Columns);
+     m_refInstrumentsTreeModel = Gtk::ListStore::create(m_InstrumentsModel);
-     m_refTreeModelFilter = Gtk::TreeModelFilter::create(m_refTreeModel);
+     m_refInstrumentsModelFilter = Gtk::TreeModelFilter::create(m_refInstrumentsTreeModel);
-     m_refTreeModelFilter->set_visible_func(
+     m_refInstrumentsModelFilter->set_visible_func(
          sigc::mem_fun(*this, &MainWindow::instrument_row_visible)
      );
-     m_TreeView.set_model(m_refTreeModelFilter);
+     m_TreeViewInstruments.set_model(m_refInstrumentsModelFilter);
-     m_TreeView.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
+     m_TreeViewInstruments.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
-     m_TreeView.set_has_tooltip(true);
+     m_TreeViewInstruments.set_has_tooltip(true);
-     m_TreeView.signal_query_tooltip().connect(
+     m_TreeViewInstruments.signal_query_tooltip().connect(
          sigc::mem_fun(*this, &MainWindow::onQueryTreeViewTooltip)
      );
-     instrument_name_connection = m_refTreeModel->signal_row_changed().connect(
+     instrument_name_connection = m_refInstrumentsTreeModel->signal_row_changed().connect(
          sigc::mem_fun(*this, &MainWindow::instrument_name_changed)
      );
      // Add the TreeView's view columns:
-     m_TreeView.append_column(_("Nr"), m_Columns.m_col_nr);
+     m_TreeViewInstruments.append_column(_("Nr"), m_InstrumentsModel.m_col_nr);
-     m_TreeView.append_column_editable(_("Instrument"), m_Columns.m_col_name);
+     m_TreeViewInstruments.append_column_editable(_("Instrument"), m_InstrumentsModel.m_col_name);
-     m_TreeView.append_column(_("Scripts"), m_Columns.m_col_scripts);
+     m_TreeViewInstruments.append_column(_("Scripts"), m_InstrumentsModel.m_col_scripts);
-     m_TreeView.set_headers_visible(true);
+     m_TreeViewInstruments.set_headers_visible(true);
      // establish drag&drop within the instrument tree view, allowing to reorder
      // the sequence of instruments within the gig file
      {
          std::vector<Gtk::TargetEntry> drag_target_instrument;
          drag_target_instrument.push_back(Gtk::TargetEntry("gig::Instrument"));
-         m_TreeView.drag_source_set(drag_target_instrument);
+         m_TreeViewInstruments.drag_source_set(drag_target_instrument);
-         m_TreeView.drag_dest_set(drag_target_instrument);
+         m_TreeViewInstruments.drag_dest_set(drag_target_instrument);
-         m_TreeView.signal_drag_begin().connect(
+         m_TreeViewInstruments.signal_drag_begin().connect(
              sigc::mem_fun(*this, &MainWindow::on_instruments_treeview_drag_begin)
          );
-         m_TreeView.signal_drag_data_get().connect(
+         m_TreeViewInstruments.signal_drag_data_get().connect(
              sigc::mem_fun(*this, &MainWindow::on_instruments_treeview_drag_data_get)
          );
-         m_TreeView.signal_drag_data_received().connect(
+         m_TreeViewInstruments.signal_drag_data_received().connect(
              sigc::mem_fun(*this, &MainWindow::on_instruments_treeview_drop_drag_data_received)
          );
      }
-Line 1490 
 MainWindow::MainWindow() :
+Line 1525 
 MainWindow::MainWindow() :
          sigc::mem_fun(*this, &MainWindow::file_changed));
      instrumentProps.signal_changed().connect(
          sigc::mem_fun(*this, &MainWindow::file_changed));
-     propDialog.signal_changed().connect(
+     sampleProps.signal_changed().connect(
+         sigc::mem_fun(*this, &MainWindow::file_changed));
+     fileProps.signal_changed().connect(
          sigc::mem_fun(*this, &MainWindow::file_changed));
      midiRules.signal_changed().connect(
          sigc::mem_fun(*this, &MainWindow::file_changed));
-Line 1512 
 MainWindow::MainWindow() :
+Line 1549 
 MainWindow::MainWindow() :
          sigc::mem_fun(*this, &MainWindow::select_sample)
      );
+     dimreg_edit.editScriptSlotsButton.signal_clicked().connect(
+         sigc::mem_fun(*this, &MainWindow::show_script_slots)
+     );
+     // simply sending the same signal (pair) to the sampler on 'patch' variable
+     // changes as the already existing signal (pair) when the user edits the
+     // script's source code, because the sampler would reload the source code
+     // and the 'patch' variables from the instrument on this signal anyway
+     dimreg_edit.scriptVars.signal_vars_to_be_changed.connect(
+         [this](gig::Instrument* instr) {
+             for (int i = 0; i < instr->ScriptSlotCount(); ++i) {
+                 gig::Script* script = instr->GetScriptOfSlot(i);
+                 signal_script_to_be_changed.emit(script);
+             }
+         }
+     );
+     dimreg_edit.scriptVars.signal_vars_changed.connect(
+         [this](gig::Instrument* instr) {
+             for (int i = 0; i < instr->ScriptSlotCount(); ++i) {
+                 gig::Script* script = instr->GetScriptOfSlot(i);
+                 signal_script_changed.emit(script);
+             }
+         }
+     );
+     dimreg_edit.scriptVars.signal_edit_script.connect(
+         [this](gig::Script* script) {
+             editScript(script);
+         }
+     );
      m_RegionChooser.signal_instrument_struct_to_be_changed().connect(
          sigc::hide(
              sigc::bind(
-Line 1554 
 MainWindow::MainWindow() :
+Line 1620 
 MainWindow::MainWindow() :
          sigc::mem_fun(*this, &MainWindow::update_dimregs));
      m_searchText.signal_changed().connect(
-         sigc::mem_fun(*m_refTreeModelFilter.operator->(), &Gtk::TreeModelFilter::refilter)
+         sigc::mem_fun(*m_refInstrumentsModelFilter.operator->(), &Gtk::TreeModelFilter::refilter)
      );
      file = 0;
-Line 1668 
 void MainWindow::bringToFront() {
+Line 1734 
 void MainWindow::bringToFront() {
      #endif
      raise();
      present();
+     // restore user specified splitter position
+     if (Settings::singleton()->mainWindowSplitterPosX >= 0 &&
+         Settings::singleton()->autoRestoreWindowDimension)
+     {
+         const int pos = Settings::singleton()->mainWindowSplitterPosX;
+         printf("Restoring user's preferred splitter position=%d\n", pos);
+         m_HPaned.set_position(pos);
+     }
+     // this signal handler is late-connected after the UI build-up has settled
+     // to prevent the UI build-up from overwriting user's setting for splitter
+     // position unintentionally
+     m_HPaned.property_position().signal_changed().connect([this]{
+         if (!Settings::singleton()->autoRestoreWindowDimension) return;
+         const int pos = m_HPaned.get_position();
+         printf("Saving user's preferred splitter position=%d\n", pos);
+         Settings::singleton()->mainWindowSplitterPosX = pos;
+     });
  }
  void MainWindow::updateMacroMenu() {
-Line 1798 
 void MainWindow::region_changed()
+Line 1882 
 void MainWindow::region_changed()
  gig::Instrument* MainWindow::get_instrument()
  {
-     gig::Instrument* instrument = 0;
+     gig::Instrument* instrument = NULL;
-     std::vector<Gtk::TreeModel::Path> rows = m_TreeView.get_selection()->get_selected_rows();
+     // get indeces of visual selection
+     std::vector<Gtk::TreeModel::Path> rows = m_TreeViewInstruments.get_selection()->get_selected_rows();
      if (rows.empty()) return NULL;
+     // convert index of visual selection (i.e. if filtered) to index of model
+     Gtk::TreeModel::Path path = m_refInstrumentsModelFilter->convert_path_to_child_path(rows[0]);
+     if (!path) return NULL;
      //NOTE: was const_iterator before, which did not compile with GTKMM4 development branch, probably going to be fixed before final GTKMM4 release though.
-     Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
+     Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(path);
      if (it) {
          Gtk::TreeModel::Row row = *it;
-         instrument = row[m_Columns.m_col_instr];
+         instrument = row[m_InstrumentsModel.m_col_instr];
      }
      return instrument;
  }
-Line 1870 
 void MainWindow::on_sel_change()
+Line 1961 
 void MainWindow::on_sel_change()
  {
  #if !USE_GTKMM_BUILDER
      // select item in instrument menu
-     std::vector<Gtk::TreeModel::Path> rows = m_TreeView.get_selection()->get_selected_rows();
+     std::vector<Gtk::TreeModel::Path> rows = m_TreeViewInstruments.get_selection()->get_selected_rows();
      if (!rows.empty()) {
-         Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
+         // convert index of visual selection (i.e. if filtered) to index of model
+         Gtk::TreeModel::Path row = m_refInstrumentsModelFilter->convert_path_to_child_path(rows[0]);
+         Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(row);
          if (it) {
              Gtk::TreePath path(it);
              int index = path[0];
-Line 1885 
 void MainWindow::on_sel_change()
+Line 1978 
 void MainWindow::on_sel_change()
      updateScriptListOfMenu();
-     m_RegionChooser.set_instrument(get_instrument());
+     gig::Instrument* instr = get_instrument();
+     m_RegionChooser.set_instrument(instr);
+     dimreg_edit.scriptVars.setInstrument(instr, true/*force update*/);
      if (Settings::singleton()->syncSamplerInstrumentSelection) {
          switch_sampler_instrument_signal.emit(get_instrument());
-Line 1894 
 void MainWindow::on_sel_change()
+Line 1990 
 void MainWindow::on_sel_change()
  LoaderSaverBase::LoaderSaverBase(const Glib::ustring filename, gig::File* gig) :
-     filename(filename), gig(gig), thread(0), progress(0.f)
+     filename(filename), gig(gig),
+ #ifdef GLIB_THREADS
+     thread(0),
+ #endif
+     progress(0.f)
  {
  }
-Line 1907 
 void loader_progress_callback(gig::progr
+Line 2007 
 void loader_progress_callback(gig::progr
  void LoaderSaverBase::progress_callback(float fraction)
  {
      {
+ #ifdef GLIB_THREADS
          Glib::Threads::Mutex::Lock lock(progressMutex);
+ #else
+         std::lock_guard<std::mutex> lock(progressMutex);
+ #endif
          progress = fraction;
      }
      progress_dispatcher();
-Line 1919 
 __attribute__((force_align_arg_pointer))
+Line 2023 
 __attribute__((force_align_arg_pointer))
  #endif
  void LoaderSaverBase::thread_function()
  {
+ #ifdef GLIB_THREADS
      printf("thread_function self=%p\n",
             static_cast<void*>(Glib::Threads::Thread::self()));
+ #else
+     std::cout << "thread_function self=" << std::this_thread::get_id() << "\n";
+ #endif
      printf("Start %s\n", filename.c_str());
      try {
          gig::progress_t progress;
-Line 1941 
 void LoaderSaverBase::thread_function()
+Line 2049 
 void LoaderSaverBase::thread_function()
  void LoaderSaverBase::launch()
  {
+ #ifdef GLIB_THREADS
  #ifdef OLD_THREADS
      thread = Glib::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function), true);
  #else
      thread = Glib::Threads::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function));
  #endif
      printf("launch thread=%p\n", static_cast<void*>(thread));
+ #else
+     thread = std::thread([this](){ thread_function(); });
+     std::cout << "launch thread=" << thread.get_id() << "\n";
+ #endif
  }
  float LoaderSaverBase::get_progress()
  {
+ #ifdef GLIB_THREADS
      Glib::Threads::Mutex::Lock lock(progressMutex);
+ #else
+     std::lock_guard<std::mutex> lock(progressMutex);
+ #endif
      return progress;
  }
-Line 1971 
 Glib::Dispatcher& LoaderSaverBase::signa
+Line 2088 
 Glib::Dispatcher& LoaderSaverBase::signa
  }
  void LoaderSaverBase::join() {
+ #ifdef GLIB_THREADS
      thread->join();
+ #else
+     thread.join();
+ #endif
  }
-Line 2052 
 void MainWindow::__clear() {
+Line 2173 
 void MainWindow::__clear() {
      // forget all samples that ought to be imported
      m_SampleImportQueue.clear();
      // clear the samples and instruments tree views
-     m_refTreeModel->clear();
+     m_refInstrumentsTreeModel->clear();
      m_refSamplesTreeModel->clear();
      m_refScriptsTreeModel->clear();
  #if !USE_GTKMM_BUILDER
-Line 2069 
 void MainWindow::__clear() {
+Line 2190 
 void MainWindow::__clear() {
  void MainWindow::__refreshEntireGUI() {
      // clear the samples and instruments tree views
-     m_refTreeModel->clear();
+     m_refInstrumentsTreeModel->clear();
      m_refSamplesTreeModel->clear();
      m_refScriptsTreeModel->clear();
  #if !USE_GTKMM_BUILDER
-Line 2186 
 void MainWindow::on_action_file_open()
+Line 2307 
 void MainWindow::on_action_file_open()
          dialog.set_current_folder(current_gig_dir);
      }
      if (dialog.run() == Gtk::RESPONSE_OK) {
+         dialog.hide();
          std::string filename = dialog.get_filename();
          printf("filename=%s\n", filename.c_str());
+ #ifdef GLIB_THREADS
          printf("on_action_file_open self=%p\n",
                 static_cast<void*>(Glib::Threads::Thread::self()));
+ #else
+         std::cout << "on_action_file_open self=" <<
+             std::this_thread::get_id() << "\n";
+ #endif
          load_file(filename.c_str());
          current_gig_dir = Glib::path_get_dirname(filename);
      }
-Line 2236 
 void MainWindow::load_instrument(gig::In
+Line 2363 
 void MainWindow::load_instrument(gig::In
      {
          if (instrument == instr) {
              // select item in "instruments" tree view
-             m_TreeView.get_selection()->select(Gtk::TreePath(ToString(i)));
+             m_TreeViewInstruments.get_selection()->select(Gtk::TreePath(ToString(i)));
              // make sure the selected item in the "instruments" tree view is
              // visible (scroll to it)
-             m_TreeView.scroll_to_row(Gtk::TreePath(ToString(i)));
+             m_TreeViewInstruments.scroll_to_row(Gtk::TreePath(ToString(i)));
  #if !USE_GTKMM_BUILDER
              // select item in instrument menu
              {
-Line 2264 
 void MainWindow::on_loader_finished()
+Line 2391 
 void MainWindow::on_loader_finished()
  {
      loader->join();
      printf("Loader finished!\n");
+ #ifdef GLIB_THREADS
      printf("on_loader_finished self=%p\n",
             static_cast<void*>(Glib::Threads::Thread::self()));
+ #else
+     std::cout << "on_loader_finished self=" <<
+         std::this_thread::get_id() << "\n";
+ #endif
      load_gig(loader->gig, loader->filename.c_str());
      progress_dialog->hide();
  }
-Line 2444 
 bool MainWindow::file_save_as()
+Line 2576 
 bool MainWindow::file_save_as()
  #endif
      if (dialog.run() == Gtk::RESPONSE_OK) {
+         dialog.hide();
          std::string filename = dialog.get_filename();
          if (!Glib::str_has_suffix(filename, ".gig")) {
              filename += ".gig";
-Line 2572 
 void MainWindow::__import_queued_samples
+Line 2705 
 void MainWindow::__import_queued_samples
  void MainWindow::on_action_file_properties()
  {
-     propDialog.show();
+     fileProps.show();
-     propDialog.deiconify();
+     fileProps.deiconify();
  }
  void MainWindow::on_action_warn_user_on_extensions() {
-Line 2597 
 void MainWindow::on_show_tooltips_change
+Line 2730 
 void MainWindow::on_show_tooltips_change
      dimreg_stereo.set_has_tooltip(b);
      // Not doing this here, we let onQueryTreeViewTooltip() handle this per cell
-     //m_TreeView.set_has_tooltip(b);
+     //m_TreeViewInstruments.set_has_tooltip(b);
      m_TreeViewSamples.set_has_tooltip(b);
      m_TreeViewScripts.set_has_tooltip(b);
-Line 2635 
 void MainWindow::on_action_help_about()
+Line 2768 
 void MainWindow::on_action_help_about()
              "backup your Gigasampler/GigaStudio files before editing them with "
              "this application.\n"
              "\n"
-             "Please report bugs to: http://bugs.linuxsampler.org"
+             "Please report bugs to: https://bugs.linuxsampler.org"
          );
      dialog.set_comments(sComment.c_str());
-     dialog.set_website("http://www.linuxsampler.org");
+     dialog.set_website("https://www.linuxsampler.org");
-     dialog.set_website_label("http://www.linuxsampler.org");
+     dialog.set_website_label("https://www.linuxsampler.org");
      dialog.set_position(Gtk::WIN_POS_CENTER);
      dialog.run();
  }
- PropDialog::PropDialog()
+ FilePropDialog::FilePropDialog()
      : eFileFormat(_("File Format")),
        eName(_("Name")),
        eCreationDate(_("Creation date")),
-Line 2678 
 PropDialog::PropDialog()
+Line 2811 
 PropDialog::PropDialog()
      set_title(_("File Properties"));
      eName.set_width_chars(50);
-     connect(eFileFormat, &PropDialog::set_FileFormat);
+     connect(eFileFormat, &FilePropDialog::set_FileFormat);
      connect(eName, &DLS::Info::Name);
      connect(eCreationDate, &DLS::Info::CreationDate);
      connect(eComments, &DLS::Info::Comments);
-Line 2739 
 PropDialog::PropDialog()
+Line 2872 
 PropDialog::PropDialog()
      quitButton.set_can_default();
      quitButton.grab_focus();
      quitButton.signal_clicked().connect(
-         sigc::mem_fun(*this, &PropDialog::hide));
+         sigc::mem_fun(*this, &FilePropDialog::hide));
      quitButton.show();
      vbox.show();
-Line 2748 
 PropDialog::PropDialog()
+Line 2881 
 PropDialog::PropDialog()
  #endif
  }
- void PropDialog::set_file(gig::File* file)
+ void FilePropDialog::set_file(gig::File* file)
  {
      m_file = file;
      update(file->pInfo);
-Line 2774 
 void PropDialog::set_file(gig::File* fil
+Line 2907 
 void PropDialog::set_file(gig::File* fil
      update_model--;
  }
- void PropDialog::set_FileFormat(int value)
+ void FilePropDialog::set_FileFormat(int value)
  {
      m_file->pVersion->major = value;
  }
-Line 2818 
 InstrumentProps::InstrumentProps() :
+Line 2951 
 InstrumentProps::InstrumentProps() :
      eIsDrum(_("Is drum")),
      eMIDIBank(_("MIDI bank"), 0, 16383),
      eMIDIProgram(_("MIDI program")),
-     eAttenuation(_("Attenuation"), 0, 96, 0, 1),
+     eAttenuation(_("Attenuation (dB)"), -96, +96, 0, 1),
-     eGainPlus6(_("Gain +6dB"), eAttenuation, -6),
      eEffectSend(_("Effect send"), 0, 65535),
      eFineTune(_("Fine tune"), -8400, 8400),
-     ePitchbendRange(_("Pitchbend range"), 0, 48),
+     ePitchbendRange(_("Pitchbend range (halftones)"), 0, 48),
      ePianoReleaseMode(_("Piano release mode")),
      eDimensionKeyRangeLow(_("Keyswitching range low")),
-     eDimensionKeyRangeHigh(_("Keyswitching range high"))
+     eDimensionKeyRangeHigh(_("Keyswitching range high")),
+     table2(2,1),
+     eName2(_("Name")),
+     eCreationDate(_("Creation date")),
+     eComments(_("Comments")),
+     eProduct(_("Product")),
+     eCopyright(_("Copyright")),
+     eArtists(_("Artists")),
+     eGenre(_("Genre")),
+     eKeywords(_("Keywords")),
+     eEngineer(_("Engineer")),
+     eTechnician(_("Technician")),
+     eSoftware(_("Software")),
+     eMedium(_("Medium")),
+     eSource(_("Source")),
+     eSourceForm(_("Source form")),
+     eCommissioned(_("Commissioned")),
+     eSubject(_("Subject"))
  {
      if (!Settings::singleton()->autoRestoreWindowDimension) {
          //set_default_size(470, 390);
-Line 2834 
 InstrumentProps::InstrumentProps() :
+Line 2983 
 InstrumentProps::InstrumentProps() :
      set_title(_("Instrument Properties"));
+     tabs.append_page(vbox[1], _("Settings"));
+     tabs.append_page(vbox[2], _("Info"));
      eDimensionKeyRangeLow.set_tip(
          _("start of the keyboard area which should switch the "
            "\"keyswitching\" dimension")
-Line 2848 
 InstrumentProps::InstrumentProps() :
+Line 3000 
 InstrumentProps::InstrumentProps() :
      connect(eMIDIBank, &InstrumentProps::set_MIDIBank);
      connect(eMIDIProgram, &InstrumentProps::set_MIDIProgram);
      connect(eAttenuation, &gig::Instrument::Attenuation);
-     connect(eGainPlus6, &gig::Instrument::Attenuation);
      connect(eEffectSend, &gig::Instrument::EffectSend);
      connect(eFineTune, &gig::Instrument::FineTune);
      connect(ePitchbendRange, &gig::Instrument::PitchbendRange);
-Line 2858 
 InstrumentProps::InstrumentProps() :
+Line 3009 
 InstrumentProps::InstrumentProps() :
      eName.signal_value_changed().connect(sig_name_changed.make_slot());
+     connect(eName2, &InstrumentProps::set_Name);
+     connectLambda(eCreationDate, [this](gig::String s) {
+         m->pInfo->CreationDate = s;
+     });
+     connectLambda(eComments, [this](gig::String s) {
+         m->pInfo->Comments = s;
+     });
+     connectLambda(eProduct, [this](gig::String s) {
+         m->pInfo->Product = s;
+     });
+     connectLambda(eCopyright, [this](gig::String s) {
+         m->pInfo->Copyright = s;
+     });
+     connectLambda(eArtists, [this](gig::String s) {
+         m->pInfo->Artists = s;
+     });
+     connectLambda(eGenre, [this](gig::String s) {
+         m->pInfo->Genre = s;
+     });
+     connectLambda(eKeywords, [this](gig::String s) {
+         m->pInfo->Keywords = s;
+     });
+     connectLambda(eEngineer, [this](gig::String s) {
+         m->pInfo->Engineer = s;
+     });
+     connectLambda(eTechnician, [this](gig::String s) {
+         m->pInfo->Technician = s;
+     });
+     connectLambda(eSoftware, [this](gig::String s) {
+         m->pInfo->Software = s;
+     });
+     connectLambda(eMedium, [this](gig::String s) {
+         m->pInfo->Medium = s;
+     });
+     connectLambda(eSource, [this](gig::String s) {
+         m->pInfo->Source = s;
+     });
+     connectLambda(eSourceForm, [this](gig::String s) {
+         m->pInfo->SourceForm = s;
+     });
+     connectLambda(eCommissioned, [this](gig::String s) {
+         m->pInfo->Commissioned = s;
+     });
+     connectLambda(eSubject, [this](gig::String s) {
+         m->pInfo->Subject = s;
+     });
+     // tab 1
  #if USE_GTKMM_GRID
      table.set_column_spacing(5);
  #else
      table.set_col_spacings(5);
  #endif
      table.add(eName);
      table.add(eIsDrum);
      table.add(eMIDIBank);
      table.add(eMIDIProgram);
      table.add(eAttenuation);
-     table.add(eGainPlus6);
      table.add(eEffectSend);
      table.add(eFineTune);
      table.add(ePitchbendRange);
-Line 2877 
 InstrumentProps::InstrumentProps() :
+Line 3074 
 InstrumentProps::InstrumentProps() :
      table.add(eDimensionKeyRangeLow);
      table.add(eDimensionKeyRangeHigh);
-     add(vbox);
+     // tab 2
+ #if USE_GTKMM_GRID
+     table2.set_column_spacing(5);
+ #else
+     table2.set_col_spacings(5);
+ #endif
+     table2.add(eName2);
+     table2.add(eCreationDate);
+     table2.add(eComments);
+     table2.add(eProduct);
+     table2.add(eCopyright);
+     table2.add(eArtists);
+     table2.add(eGenre);
+     table2.add(eKeywords);
+     table2.add(eEngineer);
+     table2.add(eTechnician);
+     table2.add(eSoftware);
+     table2.add(eMedium);
+     table2.add(eSource);
+     table2.add(eSourceForm);
+     table2.add(eCommissioned);
+     table2.add(eSubject);
+     add(vbox[0]);
  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
      table.set_margin(5);
  #else
      table.set_border_width(5);
  #endif
-     vbox.pack_start(table);
+     vbox[1].pack_start(table);
+     vbox[2].pack_start(table2);
      table.show();
-     vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);
+     table2.show();
+     vbox[0].pack_start(tabs);
+     vbox[0].pack_start(buttonBox, Gtk::PACK_SHRINK);
      buttonBox.set_layout(Gtk::BUTTONBOX_END);
  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
      buttonBox.set_margin(5);
-Line 2901 
 InstrumentProps::InstrumentProps() :
+Line 3124 
 InstrumentProps::InstrumentProps() :
          sigc::mem_fun(*this, &InstrumentProps::hide));
      quitButton.show();
-     vbox.show();
+     vbox[0].show();
  #if HAS_GTKMM_SHOW_ALL_CHILDREN
      show_all_children();
  #endif
-Line 2912 
 void InstrumentProps::set_instrument(gig
+Line 3135 
 void InstrumentProps::set_instrument(gig
      update(instrument);
      update_model++;
+     // tab 1
      eName.set_value(instrument->pInfo->Name);
      eIsDrum.set_value(instrument->IsDrum);
      eMIDIBank.set_value(instrument->MIDIBank);
      eMIDIProgram.set_value(instrument->MIDIProgram);
+     // tab 2
+     eName2.set_value(instrument->pInfo->Name);
+     eCreationDate.set_value(instrument->pInfo->CreationDate);
+     eComments.set_value(instrument->pInfo->Comments);
+     eProduct.set_value(instrument->pInfo->Product);
+     eCopyright.set_value(instrument->pInfo->Copyright);
+     eArtists.set_value(instrument->pInfo->Artists);
+     eGenre.set_value(instrument->pInfo->Genre);
+     eKeywords.set_value(instrument->pInfo->Keywords);
+     eEngineer.set_value(instrument->pInfo->Engineer);
+     eTechnician.set_value(instrument->pInfo->Technician);
+     eSoftware.set_value(instrument->pInfo->Software);
+     eMedium.set_value(instrument->pInfo->Medium);
+     eSource.set_value(instrument->pInfo->Source);
+     eSourceForm.set_value(instrument->pInfo->SourceForm);
+     eCommissioned.set_value(instrument->pInfo->Commissioned);
+     eSubject.set_value(instrument->pInfo->Subject);
+     update_model--;
+ }
+ SampleProps::SampleProps() :
+ #if HAS_GTKMM_STOCK
+     quitButton(Gtk::Stock::CLOSE),
+ #else
+     quitButton(_("_Close")),
+ #endif
+     table(2,1),
+     eName(_("Name")),
+     eUnityNote(_("Unity Note")),
+     eSampleGroup(_("Sample Group")),
+     eSampleFormatInfo(_("Sample Format")),
+     eSampleID("Sample ID"),
+     eChecksum("Wave Data CRC-32"),
+     eLoopsCount(_("Loops"), 0, 1), // we might support more than 1 loop in future
+     eLoopStart(_("Loop start position"), 0, 9999999),
+     eLoopLength(_("Loop size"), 0, 9999999),
+     eLoopType(_("Loop type")),
+     eLoopPlayCount(_("Playback count")),
+     table2(2,1),
+     eName2(_("Name")),
+     eCreationDate(_("Creation date")),
+     eComments(_("Comments")),
+     eProduct(_("Product")),
+     eCopyright(_("Copyright")),
+     eArtists(_("Artists")),
+     eGenre(_("Genre")),
+     eKeywords(_("Keywords")),
+     eEngineer(_("Engineer")),
+     eTechnician(_("Technician")),
+     eSoftware(_("Software")),
+     eMedium(_("Medium")),
+     eSource(_("Source")),
+     eSourceForm(_("Source form")),
+     eCommissioned(_("Commissioned")),
+     eSubject(_("Subject"))
+ {
+     if (!Settings::singleton()->autoRestoreWindowDimension) {
+         //set_default_size(470, 390);
+         set_position(Gtk::WIN_POS_MOUSE);
+     }
+     set_title(_("Sample Properties"));
+     tabs.append_page(vbox[1], _("Settings"));
+     tabs.append_page(vbox[2], _("Info"));
+     connect(eName, &SampleProps::set_Name);
+     connect(eUnityNote, &gig::Sample::MIDIUnityNote);
+     connect(eLoopsCount, &gig::Sample::Loops);
+     connectLambda(eLoopStart, [this](uint32_t start){
+         m->LoopStart = start;
+         m->LoopEnd = start + m->LoopSize;
+     });
+     connectLambda(eLoopLength, [this](uint32_t length){
+         m->LoopSize = length;
+         m->LoopEnd = m->LoopStart + length;
+     });
+     {
+         const char* choices[] = { _("normal"), _("bidirectional"), _("backward"), 0 };
+         static const gig::loop_type_t values[] = {
+             gig::loop_type_normal,
+             gig::loop_type_bidirectional,
+             gig::loop_type_backward
+         };
+         eLoopType.set_choices(choices, values);
+     }
+     connect(eLoopType, &gig::Sample::LoopType);
+     connect(eLoopPlayCount, &gig::Sample::LoopPlayCount);
+     eName.signal_value_changed().connect(sig_name_changed.make_slot());
+     connect(eName2, &SampleProps::set_Name);
+     connectLambda(eCreationDate, [this](gig::String s) {
+         m->pInfo->CreationDate = s;
+     });
+     connectLambda(eComments, [this](gig::String s) {
+         m->pInfo->Comments = s;
+     });
+     connectLambda(eProduct, [this](gig::String s) {
+         m->pInfo->Product = s;
+     });
+     connectLambda(eCopyright, [this](gig::String s) {
+         m->pInfo->Copyright = s;
+     });
+     connectLambda(eArtists, [this](gig::String s) {
+         m->pInfo->Artists = s;
+     });
+     connectLambda(eGenre, [this](gig::String s) {
+         m->pInfo->Genre = s;
+     });
+     connectLambda(eKeywords, [this](gig::String s) {
+         m->pInfo->Keywords = s;
+     });
+     connectLambda(eEngineer, [this](gig::String s) {
+         m->pInfo->Engineer = s;
+     });
+     connectLambda(eTechnician, [this](gig::String s) {
+         m->pInfo->Technician = s;
+     });
+     connectLambda(eSoftware, [this](gig::String s) {
+         m->pInfo->Software = s;
+     });
+     connectLambda(eMedium, [this](gig::String s) {
+         m->pInfo->Medium = s;
+     });
+     connectLambda(eSource, [this](gig::String s) {
+         m->pInfo->Source = s;
+     });
+     connectLambda(eSourceForm, [this](gig::String s) {
+         m->pInfo->SourceForm = s;
+     });
+     connectLambda(eCommissioned, [this](gig::String s) {
+         m->pInfo->Commissioned = s;
+     });
+     connectLambda(eSubject, [this](gig::String s) {
+         m->pInfo->Subject = s;
+     });
+     // tab 1
+ #if USE_GTKMM_GRID
+     table.set_column_spacing(5);
+ #else
+     table.set_col_spacings(5);
+ #endif
+     table.add(eName);
+     table.add(eUnityNote);
+     table.add(eSampleGroup);
+     table.add(eSampleFormatInfo);
+     table.add(eSampleID);
+     table.add(eChecksum);
+     table.add(eLoopsCount);
+     table.add(eLoopStart);
+     table.add(eLoopLength);
+     table.add(eLoopType);
+     table.add(eLoopPlayCount);
+     // tab 2
+ #if USE_GTKMM_GRID
+     table2.set_column_spacing(5);
+ #else
+     table2.set_col_spacings(5);
+ #endif
+     table2.add(eName2);
+     table2.add(eCreationDate);
+     table2.add(eComments);
+     table2.add(eProduct);
+     table2.add(eCopyright);
+     table2.add(eArtists);
+     table2.add(eGenre);
+     table2.add(eKeywords);
+     table2.add(eEngineer);
+     table2.add(eTechnician);
+     table2.add(eSoftware);
+     table2.add(eMedium);
+     table2.add(eSource);
+     table2.add(eSourceForm);
+     table2.add(eCommissioned);
+     table2.add(eSubject);
+     add(vbox[0]);
+ #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
+     table.set_margin(5);
+ #else
+     table.set_border_width(5);
+ #endif
+     vbox[1].pack_start(table);
+     vbox[2].pack_start(table2);
+     table.show();
+     table2.show();
+     vbox[0].pack_start(tabs);
+     vbox[0].pack_start(buttonBox, Gtk::PACK_SHRINK);
+     buttonBox.set_layout(Gtk::BUTTONBOX_END);
+ #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
+     buttonBox.set_margin(5);
+ #else
+     buttonBox.set_border_width(5);
+ #endif
+     buttonBox.show();
+     buttonBox.pack_start(quitButton);
+     quitButton.set_can_default();
+     quitButton.grab_focus();
+     quitButton.signal_clicked().connect(
+         sigc::mem_fun(*this, &SampleProps::hide));
+     quitButton.show();
+     vbox[0].show();
+ #if HAS_GTKMM_SHOW_ALL_CHILDREN
+     show_all_children();
+ #endif
+ }
+ void SampleProps::set_sample(gig::Sample* sample)
+ {
+     update(sample);
+     update_model++;
+     // tab 1
+     eName.set_value(sample->pInfo->Name);
+     eUnityNote.set_value(sample->MIDIUnityNote);
+     // show sample group name
+     {
+         Glib::ustring s = "---";
+         if (sample && sample->GetGroup())
+             s = sample->GetGroup()->Name;
+         eSampleGroup.text.set_text(s);
+     }
+     // assemble sample format info string
+     {
+         Glib::ustring s;
+         if (sample) {
+             switch (sample->Channels) {
+                 case 1: s = _("Mono"); break;
+                 case 2: s = _("Stereo"); break;
+                 default:
+                     s = ToString(sample->Channels) + _(" audio channels");
+                     break;
+             }
+             s += " " + ToString(sample->BitDepth) + " Bits";
+             s += " " + ToString(sample->SamplesPerSecond/1000) + "."
+                      + ToString((sample->SamplesPerSecond%1000)/100) + " kHz";
+         } else {
+             s = _("No sample assigned to this dimension region.");
+         }
+         eSampleFormatInfo.text.set_text(s);
+     }
+     // generate sample's memory address pointer string
+     {
+         Glib::ustring s;
+         if (sample) {
+             char buf[64] = {};
+             snprintf(buf, sizeof(buf), "%p", sample);
+             s = buf;
+         } else {
+             s = "---";
+         }
+         eSampleID.text.set_text(s);
+     }
+     // generate raw wave form data CRC-32 checksum string
+     {
+         Glib::ustring s = "---";
+         if (sample) {
+             char buf[64] = {};
+             snprintf(buf, sizeof(buf), "%x", sample->GetWaveDataCRC32Checksum());
+             s = buf;
+         }
+         eChecksum.text.set_text(s);
+     }
+     eLoopsCount.set_value(sample->Loops);
+     eLoopStart.set_value(sample->LoopStart);
+     eLoopLength.set_value(sample->LoopSize);
+     eLoopType.set_value(sample->LoopType);
+     eLoopPlayCount.set_value(sample->LoopPlayCount);
+     // tab 2
+     eName2.set_value(sample->pInfo->Name);
+     eCreationDate.set_value(sample->pInfo->CreationDate);
+     eComments.set_value(sample->pInfo->Comments);
+     eProduct.set_value(sample->pInfo->Product);
+     eCopyright.set_value(sample->pInfo->Copyright);
+     eArtists.set_value(sample->pInfo->Artists);
+     eGenre.set_value(sample->pInfo->Genre);
+     eKeywords.set_value(sample->pInfo->Keywords);
+     eEngineer.set_value(sample->pInfo->Engineer);
+     eTechnician.set_value(sample->pInfo->Technician);
+     eSoftware.set_value(sample->pInfo->Software);
+     eMedium.set_value(sample->pInfo->Medium);
+     eSource.set_value(sample->pInfo->Source);
+     eSourceForm.set_value(sample->pInfo->SourceForm);
+     eCommissioned.set_value(sample->pInfo->Commissioned);
+     eSubject.set_value(sample->pInfo->Subject);
+     update_model--;
+ }
+ void SampleProps::set_Name(const gig::String& name)
+ {
+     m->pInfo->Name = name;
+ }
+ void SampleProps::update_name()
+ {
+     update_model++;
+     eName.set_value(m->pInfo->Name);
      update_model--;
  }
-Line 2951 
 void MainWindow::updateSampleRefCountMap
+Line 3482 
 void MainWindow::updateSampleRefCountMap
  bool MainWindow::onQueryTreeViewTooltip(int x, int y, bool keyboardTip, const Glib::RefPtr<Gtk::Tooltip>& tooltip) {
      Gtk::TreeModel::iterator iter;
-     if (!m_TreeView.get_tooltip_context_iter(x, y, keyboardTip, iter)) {
+     if (!m_TreeViewInstruments.get_tooltip_context_iter(x, y, keyboardTip, iter)) {
          return false;
      }
      Gtk::TreeModel::Path path(iter);
-Line 2961 
 bool MainWindow::onQueryTreeViewTooltip(
+Line 3492 
 bool MainWindow::onQueryTreeViewTooltip(
      {
          Gtk::TreeModel::Path path; // unused
          int cellX, cellY; // unused
-         m_TreeView.get_path_at_pos(x, y, path, pointedColumn, cellX, cellY);
+         m_TreeViewInstruments.get_path_at_pos(x, y, path, pointedColumn, cellX, cellY);
      }
-     Gtk::TreeViewColumn* scriptsColumn = m_TreeView.get_column(2);
+     Gtk::TreeViewColumn* scriptsColumn = m_TreeViewInstruments.get_column(2);
      if (pointedColumn == scriptsColumn) { // mouse hovers scripts column ...
          // show the script(s) assigned to the hovered instrument as tooltip
-         tooltip->set_markup( row[m_Columns.m_col_tooltip] );
+         tooltip->set_markup( row[m_InstrumentsModel.m_col_tooltip] );
-         m_TreeView.set_tooltip_cell(tooltip, &path, scriptsColumn, NULL);
+         m_TreeViewInstruments.set_tooltip_cell(tooltip, &path, scriptsColumn, NULL);
      } else {
          // if beginners' tooltips is disabled then don't show the following one
          if (!Settings::singleton()->showTooltips)
-Line 2977 
 bool MainWindow::onQueryTreeViewTooltip(
+Line 3508 
 bool MainWindow::onQueryTreeViewTooltip(
              "Right click here for actions on instruments & MIDI Rules. "
              "Drag & drop to change the order of instruments."
          ));
-         m_TreeView.set_tooltip_cell(tooltip, &path, pointedColumn, NULL);
+         m_TreeViewInstruments.set_tooltip_cell(tooltip, &path, pointedColumn, NULL);
      }
      return true;
  }
-Line 3011 
 void MainWindow::load_gig(gig::File* gig
+Line 3542 
 void MainWindow::load_gig(gig::File* gig
      file_has_name = filename;
      file_is_changed = false;
-     propDialog.set_file(gig);
+     fileProps.set_file(gig);
      instrument_name_connection.block();
      int index = 0;
-Line 3020 
 void MainWindow::load_gig(gig::File* gig
+Line 3551 
 void MainWindow::load_gig(gig::File* gig
          Glib::ustring name(gig_to_utf8(instrument->pInfo->Name));
          const int iScriptSlots = instrument->ScriptSlotCount();
-         Gtk::TreeModel::iterator iter = m_refTreeModel->append();
+         Gtk::TreeModel::iterator iter = m_refInstrumentsTreeModel->append();
          Gtk::TreeModel::Row row = *iter;
-         row[m_Columns.m_col_nr] = index;
+         row[m_InstrumentsModel.m_col_nr] = index;
-         row[m_Columns.m_col_name] = name;
+         row[m_InstrumentsModel.m_col_name] = name;
-         row[m_Columns.m_col_instr] = instrument;
+         row[m_InstrumentsModel.m_col_instr] = instrument;
-         row[m_Columns.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
+         row[m_InstrumentsModel.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
-         row[m_Columns.m_col_tooltip] = scriptTooltipFor(instrument, index);
+         row[m_InstrumentsModel.m_col_tooltip] = scriptTooltipFor(instrument, index);
  #if !USE_GTKMM_BUILDER
          add_instrument_to_menu(name);
-Line 3088 
 void MainWindow::load_gig(gig::File* gig
+Line 3619 
 void MainWindow::load_gig(gig::File* gig
      file = gig;
      // select the first instrument
-     m_TreeView.get_selection()->select(Gtk::TreePath("0"));
+     m_TreeViewInstruments.get_selection()->select(Gtk::TreePath("0"));
      instr_props_set_instrument();
      gig::Instrument* instrument = get_instrument();
-Line 3101 
 bool MainWindow::instr_props_set_instrum
+Line 3632 
 bool MainWindow::instr_props_set_instrum
  {
      instrumentProps.signal_name_changed().clear();
-     std::vector<Gtk::TreeModel::Path> rows = m_TreeView.get_selection()->get_selected_rows();
+     // get visual selection
+     std::vector<Gtk::TreeModel::Path> rows = m_TreeViewInstruments.get_selection()->get_selected_rows();
      if (rows.empty()) {
          instrumentProps.hide();
          return false;
      }
+     // convert index of visual selection (i.e. if filtered) to index of model
+     Gtk::TreeModel::Path path = m_refInstrumentsModelFilter->convert_path_to_child_path(rows[0]);
      //NOTE: was const_iterator before, which did not compile with GTKMM4 development branch, probably going to be fixed before final GTKMM4 release though.
-     Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
+     Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(path);
      if (it) {
          Gtk::TreeModel::Row row = *it;
-         gig::Instrument* instrument = row[m_Columns.m_col_instr];
+         gig::Instrument* instrument = row[m_InstrumentsModel.m_col_instr];
          instrumentProps.set_instrument(instrument);
-Line 3139 
 void MainWindow::show_instr_props()
+Line 3675 
 void MainWindow::show_instr_props()
  void MainWindow::instr_name_changed_by_instr_props(Gtk::TreeModel::iterator& it)
  {
      Gtk::TreeModel::Row row = *it;
-     Glib::ustring name = row[m_Columns.m_col_name];
+     Glib::ustring name = row[m_InstrumentsModel.m_col_name];
-     gig::Instrument* instrument = row[m_Columns.m_col_instr];
+     gig::Instrument* instrument = row[m_InstrumentsModel.m_col_instr];
      Glib::ustring gigname(gig_to_utf8(instrument->pInfo->Name));
      if (gigname != name) {
          Gtk::TreeModel::Path path(*it);
          const int index = path[0];
-         row[m_Columns.m_col_name] = gigname;
+         row[m_InstrumentsModel.m_col_name] = gigname;
-         row[m_Columns.m_col_tooltip] = scriptTooltipFor(instrument, index);
+         row[m_InstrumentsModel.m_col_tooltip] = scriptTooltipFor(instrument, index);
+     }
+ }
+ bool MainWindow::sample_props_set_sample()
+ {
+     sampleProps.signal_name_changed().clear();
+     std::vector<Gtk::TreeModel::Path> rows = m_TreeViewSamples.get_selection()->get_selected_rows();
+     if (rows.empty()) {
+         sampleProps.hide();
+         return false;
+     }
+     //NOTE: was const_iterator before, which did not compile with GTKMM4 development branch, probably going to be fixed before final GTKMM4 release though.
+     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
+     if (it) {
+         Gtk::TreeModel::Row row = *it;
+         gig::Sample* sample = row[m_SamplesModel.m_col_sample];
+         sampleProps.set_sample(sample);
+         // make sure sample tree is updated when user changes the
+         // sample name in sample properties window
+         sampleProps.signal_name_changed().connect(
+             sigc::bind(
+                 sigc::mem_fun(*this,
+                     &MainWindow::sample_name_changed_by_sample_props
+                 ), it
+             )
+         );
+     } else {
+         sampleProps.hide();
+     }
+     //NOTE: explicit boolean cast required for GTKMM4 development branch here
+     return it ? true : false;
+ }
+ void MainWindow::show_sample_props()
+ {
+     if (sample_props_set_sample()) {
+         sampleProps.show();
+         sampleProps.deiconify();
+     }
+ }
+ void MainWindow::sample_name_changed_by_sample_props(Gtk::TreeModel::iterator& it)
+ {
+     Gtk::TreeModel::Row row = *it;
+     Glib::ustring name = row[m_SamplesModel.m_col_name];
+     gig::Sample* sample = row[m_SamplesModel.m_col_sample];
+     Glib::ustring gigname(gig_to_utf8(sample->pInfo->Name));
+     if (gigname != name) {
+         Gtk::TreeModel::Path path(*it);
+         row[m_SamplesModel.m_col_name] = gigname;
      }
  }
-Line 3163 
 void MainWindow::show_midi_rules()
+Line 3753 
 void MainWindow::show_midi_rules()
  void MainWindow::show_script_slots() {
      if (!file) return;
      // get selected instrument
-     std::vector<Gtk::TreeModel::Path> rows = m_TreeView.get_selection()->get_selected_rows();
+     gig::Instrument* instrument = get_instrument();
-     if (rows.empty()) return;
-     Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
-     if (!it) return;
-     Gtk::TreeModel::Row row = *it;
-     gig::Instrument* instrument = row[m_Columns.m_col_instr];
      if (!instrument) return;
      ScriptSlots* window = new ScriptSlots;
-Line 3185 
 void MainWindow::onScriptSlotsModified(g
+Line 3771 
 void MainWindow::onScriptSlotsModified(g
      if (!pInstrument) return;
      const int iScriptSlots = pInstrument->ScriptSlotCount();
-     //NOTE: This is a big mess! Sometimes GTK requires m_TreeView.get_model(), here we need m_refTreeModelFilter->get_model(), otherwise accessing children below causes an error!
+     //NOTE: This is a big mess! Sometimes GTK requires m_TreeViewInstruments.get_model(), here we need m_refInstrumentsModelFilter->get_model(), otherwise accessing children below causes an error!
-     //Glib::RefPtr<Gtk::TreeModel> model = m_TreeView.get_model();
+     //Glib::RefPtr<Gtk::TreeModel> model = m_TreeViewInstruments.get_model();
-     Glib::RefPtr<Gtk::TreeModel> model = m_refTreeModelFilter->get_model();
+     Glib::RefPtr<Gtk::TreeModel> model = m_refInstrumentsModelFilter->get_model();
      for (int i = 0; i < model->children().size(); ++i) {
          Gtk::TreeModel::Row row = model->children()[i];
-         if (row[m_Columns.m_col_instr] != pInstrument) continue;
+         if (row[m_InstrumentsModel.m_col_instr] != pInstrument) continue;
-         row[m_Columns.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
+         row[m_InstrumentsModel.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
-         row[m_Columns.m_col_tooltip] = scriptTooltipFor(pInstrument, i);
+         row[m_InstrumentsModel.m_col_tooltip] = scriptTooltipFor(pInstrument, i);
          break;
      }
      // causes the sampler to reload the instrument with the new script
      on_sel_change();
+     // force script 'patch' variables editor ("Script" tab) to be refreshed
+     dimreg_edit.scriptVars.setInstrument(pInstrument, true/*force update*/);
  }
  void MainWindow::assignScript(gig::Script* pScript) {
-Line 3279 
 void MainWindow::on_auto_restore_win_dim
+Line 3868 
 void MainWindow::on_auto_restore_win_dim
  #endif
  }
+ void MainWindow::on_instr_double_click_opens_props() {
+ #if USE_GLIB_ACTION
+     bool active = false;
+     m_actionInstrDoubleClickOpensProps->get_state(active);
+     // for some reason toggle state does not change automatically
+     active = !active;
+     m_actionInstrDoubleClickOpensProps->change_state(active);
+     Settings::singleton()->instrumentDoubleClickOpensProps = active;
+ #else
+     Gtk::CheckMenuItem* item =
+         dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/OpenInstrPropsByDoubleClick"));
+     if (!item) {
+         std::cerr << "/MenuBar/MenuView/OpenInstrPropsByDoubleClick == NULL\n";
+         return;
+     }
+     Settings::singleton()->instrumentDoubleClickOpensProps = item->get_active();
+ #endif
+ }
  void MainWindow::on_save_with_temporary_file() {
  #if USE_GLIB_ACTION
      bool active = false;
-Line 3353 
 bool MainWindow::on_button_release(Gdk::
+Line 3961 
 bool MainWindow::on_button_release(Gdk::
  void MainWindow::on_button_release(GdkEventButton* button) {
  #endif
      if (button->type == GDK_2BUTTON_PRESS) {
-         show_instr_props();
+         if (Settings::singleton()->instrumentDoubleClickOpensProps)
+             show_instr_props();
      } else if (button->type == GDK_BUTTON_PRESS && button->button == 3) {
          // gig v2 files have no midi rules
          const bool bEnabled = !(file->pVersion && file->pVersion->major == 2);
-Line 3385 
 void MainWindow::on_instrument_selection
+Line 3994 
 void MainWindow::on_instrument_selection
              find(children.begin(), children.end(), item);
          if (it != children.end()) {
              int index = it - children.begin();
-             m_TreeView.get_selection()->select(Gtk::TreePath(ToString(index)));
+             // convert index of model to index of visual presentation (i.e. if filtered)
+             Gtk::TreeModel::Path path = m_refInstrumentsModelFilter->convert_child_path_to_path(Gtk::TreePath(ToString(index)));
+             if (path)
+                 m_TreeViewInstruments.get_selection()->select(path);
+             else
+                 m_TreeViewInstruments.get_selection()->unselect_all();
              m_RegionChooser.set_instrument(file->GetInstrument(index));
          }
-Line 3393 
 void MainWindow::on_instrument_selection
+Line 4009 
 void MainWindow::on_instrument_selection
  }
  #endif
+ void MainWindow::on_action_move_instr() {
+     gig::Instrument* instr = get_instrument();
+     if (!instr) return;
+     int currentIndex = getIndexOf(instr);
+     Gtk::Dialog dialog(_("Move Instrument"), true /*modal*/);
+ #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
+     Gtk::Adjustment adjustment(
+         currentIndex,
+/*min*/, file->CountInstruments() - 1 /*max*/
+     );
+     Gtk::SpinButton spinBox(adjustment);
+ #else
+     Gtk::SpinButton spinBox(
+         Gtk::Adjustment::create(
+             currentIndex,
+/*min*/, file->CountInstruments() - 1 /*max*/
+         )
+     );
+ #endif
+ #if USE_GTKMM_BOX
+     dialog.get_content_area()->pack_start(spinBox);
+ #else
+     dialog.get_vbox()->pack_start(spinBox);
+ #endif
+ #if HAS_GTKMM_STOCK
+     Gtk::Button* okButton = dialog.add_button(Gtk::Stock::OK, 0);
+     dialog.add_button(Gtk::Stock::CANCEL, 1);
+ #else
+     Gtk::Button* okButton = dialog.add_button(_("_OK"), 0);
+     dialog.add_button(_("_Cancel"), 1);
+ #endif
+     okButton->set_sensitive(false);
+     // show the dialog at a reasonable screen position
+     dialog.set_position(Gtk::WIN_POS_MOUSE);
+     // only enable the 'OK' button if entered new index is not instrument's
+     // current index already
+     spinBox.signal_value_changed().connect([&]{
+         okButton->set_sensitive( spinBox.get_value_as_int() != currentIndex );
+     });
+     // usability acceleration: if user hits enter key on the text entry field
+     // then auto trigger the 'OK' button
+     spinBox.signal_activate().connect([&]{
+         if (okButton->get_sensitive())
+             okButton->clicked();
+     });
+ #if HAS_GTKMM_SHOW_ALL_CHILDREN
+     dialog.show_all_children();
+ #endif
+     if (!dialog.run()) { // 'OK' selected ...
+         int newIndex = spinBox.get_value_as_int();
+         printf("MOVE TO %d\n", newIndex);
+         gig::Instrument* dst = file->GetInstrument(newIndex);
+         instr->MoveTo(dst);
+         __refreshEntireGUI();
+         select_instrument(instr);
+     }
+ }
  void MainWindow::select_instrument(gig::Instrument* instrument) {
      if (!instrument) return;
-     //NOTE: This is a big mess! Sometimes GTK requires m_refTreeModelFilter->get_model(), here we need m_TreeView.get_model(), otherwise treeview selection below causes an error!
+     //NOTE: This is a big mess! Sometimes GTK requires m_refInstrumentsModelFilter->get_model(), here we need m_TreeViewInstruments.get_model(), otherwise treeview selection below causes an error!
-     Glib::RefPtr<Gtk::TreeModel> model = m_TreeView.get_model();
+     Glib::RefPtr<Gtk::TreeModel> model = m_TreeViewInstruments.get_model();
-     //Glib::RefPtr<Gtk::TreeModel> model = m_refTreeModelFilter->get_model();
+     //Glib::RefPtr<Gtk::TreeModel> model = m_refInstrumentsModelFilter->get_model();
      for (int i = 0; i < model->children().size(); ++i) {
          Gtk::TreeModel::Row row = model->children()[i];
-         if (row[m_Columns.m_col_instr] == instrument) {
+         if (row[m_InstrumentsModel.m_col_instr] == instrument) {
              // select and show the respective instrument in the list view
              show_intruments_tab();
-             m_TreeView.get_selection()->unselect_all();
+             m_TreeViewInstruments.get_selection()->unselect_all();
  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
              auto iterSel = model->children()[i].get_iter();
-             m_TreeView.get_selection()->select(iterSel);
+             m_TreeViewInstruments.get_selection()->select(iterSel);
  #else
-             m_TreeView.get_selection()->select(model->children()[i]);
+             m_TreeViewInstruments.get_selection()->select(model->children()[i]);
  #endif
              std::vector<Gtk::TreeModel::Path> rows =
-                 m_TreeView.get_selection()->get_selected_rows();
+                 m_TreeViewInstruments.get_selection()->get_selected_rows();
              if (!rows.empty())
-                 m_TreeView.scroll_to_row(rows[0]);
+                 m_TreeViewInstruments.scroll_to_row(rows[0]);
              on_sel_change(); // the regular instrument selection change callback
          }
      }
-Line 3427 
 bool MainWindow::select_dimension_region
+Line 4103 
 bool MainWindow::select_dimension_region
      gig::Region* pRegion = (gig::Region*) dimRgn->GetParent();
      gig::Instrument* pInstrument = (gig::Instrument*) pRegion->GetParent();
-     //NOTE: This is a big mess! Sometimes GTK requires m_refTreeModelFilter->get_model(), here we need m_TreeView.get_model(), otherwise treeview selection below causes an error!
+     //NOTE: This is a big mess! Sometimes GTK requires m_refInstrumentsModelFilter->get_model(), here we need m_TreeViewInstruments.get_model(), otherwise treeview selection below causes an error!
-     Glib::RefPtr<Gtk::TreeModel> model = m_TreeView.get_model();
+     Glib::RefPtr<Gtk::TreeModel> model = m_TreeViewInstruments.get_model();
-     //Glib::RefPtr<Gtk::TreeModel> model = m_refTreeModelFilter->get_model();
+     //Glib::RefPtr<Gtk::TreeModel> model = m_refInstrumentsModelFilter->get_model();
      for (int i = 0; i < model->children().size(); ++i) {
          Gtk::TreeModel::Row row = model->children()[i];
-         if (row[m_Columns.m_col_instr] == pInstrument) {
+         if (row[m_InstrumentsModel.m_col_instr] == pInstrument) {
              // select and show the respective instrument in the list view
              show_intruments_tab();
-             m_TreeView.get_selection()->unselect_all();
+             m_TreeViewInstruments.get_selection()->unselect_all();
  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
              auto iterSel = model->children()[i].get_iter();
-             m_TreeView.get_selection()->select(iterSel);
+             m_TreeViewInstruments.get_selection()->select(iterSel);
  #else
-             m_TreeView.get_selection()->select(model->children()[i]);
+             m_TreeViewInstruments.get_selection()->select(model->children()[i]);
  #endif
              std::vector<Gtk::TreeModel::Path> rows =
-                 m_TreeView.get_selection()->get_selected_rows();
+                 m_TreeViewInstruments.get_selection()->get_selected_rows();
              if (!rows.empty())
-                 m_TreeView.scroll_to_row(rows[0]);
+                 m_TreeViewInstruments.scroll_to_row(rows[0]);
              on_sel_change(); // the regular instrument selection change callback
              // select respective region in the region selector
-Line 3731 
 void MainWindow::add_instrument(gig::Ins
+Line 4407 
 void MainWindow::add_instrument(gig::Ins
      // update instrument tree view
      instrument_name_connection.block();
-     Gtk::TreeModel::iterator iterInstr = m_refTreeModel->append();
+     Gtk::TreeModel::iterator iterInstr = m_refInstrumentsTreeModel->append();
      Gtk::TreeModel::Row rowInstr = *iterInstr;
-     const int index = m_refTreeModel->children().size() - 1;
+     const int index = m_refInstrumentsTreeModel->children().size() - 1;
-     rowInstr[m_Columns.m_col_nr] = index;
+     const int iScriptSlots = instrument->ScriptSlotCount();
-     rowInstr[m_Columns.m_col_name] = name;
+     rowInstr[m_InstrumentsModel.m_col_nr] = index;
-     rowInstr[m_Columns.m_col_instr] = instrument;
+     rowInstr[m_InstrumentsModel.m_col_name] = name;
-     rowInstr[m_Columns.m_col_scripts] = "";
+     rowInstr[m_InstrumentsModel.m_col_instr] = instrument;
-     rowInstr[m_Columns.m_col_tooltip] = scriptTooltipFor(instrument, index);
+     rowInstr[m_InstrumentsModel.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
+     rowInstr[m_InstrumentsModel.m_col_tooltip] = scriptTooltipFor(instrument, index);
      instrument_name_connection.unblock();
  #if !USE_GTKMM_BUILDER
-Line 3764 
 void MainWindow::on_action_duplicate_ins
+Line 4441 
 void MainWindow::on_action_duplicate_ins
      // retrieve the currently selected instrument
      // (being the original instrument to be duplicated)
-     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
+     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewInstruments.get_selection();
      std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
      for (int r = 0; r < rows.size(); ++r) {
-         Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[r]);
+         // convert index of visual selection (i.e. if filtered) to index of model
+         Gtk::TreeModel::Path path = m_refInstrumentsModelFilter->convert_path_to_child_path(rows[r]);
+         Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(path);
          if (it) {
              Gtk::TreeModel::Row row = *it;
-             gig::Instrument* instrOrig = row[m_Columns.m_col_instr];
+             gig::Instrument* instrOrig = row[m_InstrumentsModel.m_col_instr];
              if (instrOrig) {
                  // duplicate the orginal instrument
                  gig::Instrument* instrNew = file->AddDuplicateInstrument(instrOrig);
-Line 3797 
 void MainWindow::on_action_remove_instru
+Line 4476 
 void MainWindow::on_action_remove_instru
          return;
      }
-     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
+     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewInstruments.get_selection();
-     std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
+     std::vector<Gtk::TreeModel::Path> rowsVisual = sel->get_selected_rows();
+     // convert indeces of visual selection (i.e. if filtered) to indeces of model
+     std::vector<Gtk::TreeModel::Path> rows;
+     for (int rv = 0; rv < rowsVisual.size(); ++rv) {
+         Gtk::TreeModel::Path path = m_refInstrumentsModelFilter->convert_path_to_child_path(rowsVisual[rv]);
+         if (path)
+             rows.push_back(path);
+     }
      for (int r = rows.size() - 1; r >= 0; --r) {
-         Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[r]);
+         Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(rows[r]);
          if (!it) continue;
          Gtk::TreeModel::Row row = *it;
-         gig::Instrument* instr = row[m_Columns.m_col_instr];
+         gig::Instrument* instr = row[m_InstrumentsModel.m_col_instr];
          try {
              Gtk::TreePath path(it);
              int index = path[0];
-Line 3817 
 void MainWindow::on_action_remove_instru
+Line 4505 
 void MainWindow::on_action_remove_instru
  #endif
              // remove row from instruments tree view
-             m_refTreeModel->erase(it);
+             m_refInstrumentsTreeModel->erase(it);
              // update "Nr" column of all instrument rows
              {
                  int index = 0;
-                 for (Gtk::TreeModel::iterator it = m_refTreeModel->children().begin();
+                 for (Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->children().begin();
-                      it != m_refTreeModel->children().end(); ++it, ++index)
+                      it != m_refInstrumentsTreeModel->children().end(); ++it, ++index)
                  {
                      Gtk::TreeModel::Row row = *it;
-                     gig::Instrument* instrument = row[m_Columns.m_col_instr];
+                     gig::Instrument* instrument = row[m_InstrumentsModel.m_col_instr];
-                     row[m_Columns.m_col_nr] = index;
+                     row[m_InstrumentsModel.m_col_nr] = index;
-                     row[m_Columns.m_col_tooltip] = scriptTooltipFor(instrument, index);
+                     row[m_InstrumentsModel.m_col_tooltip] = scriptTooltipFor(instrument, index);
                  }
              }
  #if GTKMM_MAJOR_VERSION < 3
              // select another instrument (in gtk3 this is done
              // automatically)
-             if (!m_refTreeModel->children().empty()) {
+             if (!m_refInstrumentsTreeModel->children().empty()) {
-                 if (index == m_refTreeModel->children().size()) {
+                 if (index == m_refInstrumentsTreeModel->children().size()) {
                      index--;
                  }
-                 m_TreeView.get_selection()->select(
+                 m_TreeViewInstruments.get_selection()->select(
                      Gtk::TreePath(ToString(index)));
              }
  #endif
-Line 3857 
 void MainWindow::on_action_remove_instru
+Line 4545 
 void MainWindow::on_action_remove_instru
  }
  void MainWindow::on_action_sample_properties() {
-     //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();
  }
  void MainWindow::on_action_add_script_group() {
-Line 3924 
 void MainWindow::on_action_edit_script()
+Line 4608 
 void MainWindow::on_action_edit_script()
      if (!it) return;
      Gtk::TreeModel::Row row = *it;
      gig::Script* script = row[m_ScriptsModel.m_col_script];
-     if (!script) return;
+     editScript(script);
+ }
+ void MainWindow::editScript(gig::Script* script) {
+     if (!script) return;
      ScriptEditor* editor = new ScriptEditor;
      editor->signal_script_to_be_changed.connect(
          signal_script_to_be_changed.make_slot()
      );
-     editor->signal_script_changed.connect(
+     editor->signal_script_changed.connect([this](gig::Script* script) {
-         signal_script_changed.make_slot()
+         // signal to sampler (which will reload the script due to this)
-     );
+         signal_script_changed.emit(script);
+         // force script 'patch' variables editor ("Script" tab) to be refreshed
+         gig::Instrument* instr = get_instrument();
+         dimreg_edit.scriptVars.setInstrument(instr, true/*force update*/);
+     });
      editor->setScript(script);
      //editor->reparent(*this);
      editor->show();
-Line 4080 
 void MainWindow::add_or_replace_sample(b
+Line 4771 
 void MainWindow::add_or_replace_sample(b
          dialog.set_current_folder(current_sample_dir);
      }
      if (dialog.run() == Gtk::RESPONSE_OK) {
+         dialog.hide();
          current_sample_dir = dialog.get_current_folder();
          Glib::ustring error_files;
          std::vector<std::string> filenames = dialog.get_filenames();
-Line 4260 
 void MainWindow::on_action_replace_all_s
+Line 4952 
 void MainWindow::on_action_replace_all_s
      }
      if (dialog.run() == Gtk::RESPONSE_OK)
      {
+         dialog.hide();
          current_sample_dir = dialog.get_current_folder();
          Glib::ustring error_files;
          std::string folder = dialog.get_filename();
-Line 4388 
 void MainWindow::on_action_remove_unused
+Line 5081 
 void MainWindow::on_action_remove_unused
      if (!file) return;
      // collect all samples that are not referenced by any instrument
-     std::list<gig::Sample*> lsamples;
+     std::list<gig::Sample*> lsamples = unusedSamples(file);
-     for (int iSample = 0; file->GetSample(iSample); ++iSample) {
-         gig::Sample* sample = file->GetSample(iSample);
-         bool isUsed = false;
-         for (gig::Instrument* instrument = file->GetFirstInstrument(); instrument;
-                               instrument = file->GetNextInstrument())
-         {
-             for (gig::Region* rgn = instrument->GetFirstRegion(); rgn;
-                               rgn = instrument->GetNextRegion())
-             {
-                 for (int i = 0; i < 256; ++i) {
-                     if (!rgn->pDimensionRegions[i]) continue;
-                     if (rgn->pDimensionRegions[i]->pSample != sample) continue;
-                     isUsed = true;
-                     goto endOfRefSearch;
-                 }
-             }
-         }
-         endOfRefSearch:
-         if (!isUsed) lsamples.push_back(sample);
-     }
      if (lsamples.empty()) return;
      // notify everybody that we're going to remove these samples
-Line 4485 
 void MainWindow::on_instruments_treeview
+Line 5157 
 void MainWindow::on_instruments_treeview
      // get selected source instrument
      gig::Instrument* src = NULL;
      {
-         Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
+         Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewInstruments.get_selection();
          std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
          if (!rows.empty()) {
-             Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
+             // convert index of visual selection (i.e. if filtered) to index of model
+             Gtk::TreeModel::Path path = m_refInstrumentsModelFilter->convert_path_to_child_path(rows[0]);
+             Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(path);
              if (it) {
                  Gtk::TreeModel::Row row = *it;
-                 src = row[m_Columns.m_col_instr];
+                 src = row[m_InstrumentsModel.m_col_instr];
              }
          }
      }
-Line 4513 
 void MainWindow::on_instruments_treeview
+Line 5187 
 void MainWindow::on_instruments_treeview
      gig::Instrument* dst = NULL;
      {
          Gtk::TreeModel::Path path;
-         const bool found = m_TreeView.get_path_at_pos(x, y, path);
+         const bool found = m_TreeViewInstruments.get_path_at_pos(x, y, path);
          if (!found) return;
-         Gtk::TreeModel::iterator iter = m_refTreeModel->get_iter(path);
+         // convert index of visual selection (i.e. if filtered) to index of model
+         path = m_refInstrumentsModelFilter->convert_path_to_child_path(path);
+         if (!path) return;
+         Gtk::TreeModel::iterator iter = m_refInstrumentsTreeModel->get_iter(path);
          if (!iter) return;
          Gtk::TreeModel::Row row = *iter;
-         dst = row[m_Columns.m_col_instr];
+         dst = row[m_InstrumentsModel.m_col_instr];
      }
      if (!dst) return;
-Line 4658 
 void MainWindow::sample_name_changed(con
+Line 5336 
 void MainWindow::sample_name_changed(con
              file_changed();
          }
      }
+     // change name in the sample properties window
+     if (sampleProps.get_sample() == sample && sample) {
+         sampleProps.set_sample(sample);
+     }
  }
  void MainWindow::script_name_changed(const Gtk::TreeModel::Path& path,
-Line 4690 
 void MainWindow::script_double_clicked(c
+Line 5372 
 void MainWindow::script_double_clicked(c
      if (!iter) return;
      Gtk::TreeModel::Row row = *iter;
      gig::Script* script = row[m_ScriptsModel.m_col_script];
-     if (!script) return;
+     editScript(script);
-     ScriptEditor* editor = new ScriptEditor;
-     editor->signal_script_to_be_changed.connect(
-         signal_script_to_be_changed.make_slot()
-     );
-     editor->signal_script_changed.connect(
-         signal_script_changed.make_slot()
-     );
-     editor->setScript(script);
-     //editor->reparent(*this);
-     editor->show();
  }
  void MainWindow::instrument_name_changed(const Gtk::TreeModel::Path& path,
                                           const Gtk::TreeModel::iterator& iter) {
      if (!iter) return;
      Gtk::TreeModel::Row row = *iter;
-     Glib::ustring name = row[m_Columns.m_col_name];
+     Glib::ustring name = row[m_InstrumentsModel.m_col_name];
  #if !USE_GTKMM_BUILDER
      // change name in instrument menu
-Line 4726 
 void MainWindow::instrument_name_changed
+Line 5397 
 void MainWindow::instrument_name_changed
  #endif
      // change name in gig
-     gig::Instrument* instrument = row[m_Columns.m_col_instr];
+     gig::Instrument* instrument = row[m_InstrumentsModel.m_col_instr];
      gig::String gigname(gig_from_utf8(name));
      if (instrument && instrument->pInfo->Name != gigname) {
          instrument->pInfo->Name = gigname;
-Line 4754 
 bool MainWindow::instrument_row_visible(
+Line 5425 
 bool MainWindow::instrument_row_visible(
  #else
      Gtk::TreeModel::Row row = *iter;
  #endif
-     Glib::ustring name = row[m_Columns.m_col_name];
+     Glib::ustring name = row[m_InstrumentsModel.m_col_name];
      name = name.lowercase();
      std::vector<Glib::ustring> tokens = Glib::Regex::split_simple(" ", pattern);
-Line 4772 
 void MainWindow::on_action_combine_instr
+Line 5443 
 void MainWindow::on_action_combine_instr
      // list view as pre-selection
      std::set<int> indeces;
      {
-         Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
+         Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewInstruments.get_selection();
          std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
          for (int r = 0; r < rows.size(); ++r) {
-             Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[r]);
+             // convert index of visual selection (i.e. if filtered) to index of model
+             Gtk::TreeModel::Path path = m_refInstrumentsModelFilter->convert_path_to_child_path(rows[r]);
+             Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(path);
              if (it) {
                  Gtk::TreeModel::Row row = *it;
-                 int index = row[m_Columns.m_col_nr];
+                 int index = row[m_InstrumentsModel.m_col_nr];
                  indeces.insert(index);
              }
          }
-Line 4988 
 void MainWindow::on_action_merge_files()
+Line 5661 
 void MainWindow::on_action_merge_files()
  #endif
      if (dialog.run() == Gtk::RESPONSE_OK) {
+         dialog.hide();
+ #ifdef GLIB_THREADS
          printf("on_action_merge_files self=%p\n",
                 static_cast<void*>(Glib::Threads::Thread::self()));
+ #else
+         std::cout << "on_action_merge_files self=" <<
+             std::this_thread::get_id() << "\n";
+ #endif
          std::vector<std::string> filenames = dialog.get_filenames();
          // merge the selected files to the currently open .gig file

 Legend:



Removed from v.3471
 


changed lines


 
Added in v.3831
 Legend:



Removed from v.3471
 


changed lines


 
Added in v.3831
-Removed from v.3471
+Added in v.3831

	ViewVC Help
Powered by ViewVC