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

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

Parent Directory | Revision Log | View Patch Patch

-revision 3089 by schoenebeck,
Sun Jan 15 19:18:39 2017 UTC
+revision 3783 by schoenebeck,
Sat May 30 00:14:27 2020 UTC
 Line 1
  /*
-     Copyright (c) 2014-2017 Christian Schoenebeck
+     Copyright (c) 2014-2020 Christian Schoenebeck
      This file is part of "gigedit" and released under the terms of the
      GNU General Public License version 2.
  */
+ #include "global.h"
  #include "CombineInstrumentsDialog.h"
  // enable this for debug messages being printed while combining the instruments
  #define DEBUG_COMBINE_INSTRUMENTS 0
- #include "global.h"
  #include "compat.h"
  #include <set>
 Line 20
  #include <string.h>
  #include <glibmm/ustring.h>
+ #if HAS_GTKMM_STOCK
+ # include <gtkmm/stock.h>
+ #endif
  #include <gtkmm/messagedialog.h>
  #include <gtkmm/label.h>
+ #include <gtk/gtkwidget.h> // for gtk_widget_modify_*()
- Glib::ustring gig_to_utf8(const gig::String& gig_string);
  Glib::ustring dimTypeAsString(gig::dimension_t d);
  typedef std::vector< std::pair<gig::Instrument*, gig::Region*> > OrderedRegionGroup;
-Line 214 
 static RegionGroups groupByRegionInterse
+Line 217 
 static RegionGroups groupByRegionInterse
   *
   * Takes a planned new region (@a regionGroup) as argument and identifies which
   * precise dimensions would have to be created for that new region, along with
-  * the amount of dimension zones and their precise individual zone sizes.
+  * the amount of dimension zones.
   *
   * @param regionGroup - planned new region for a new instrument
   * @returns set of dimensions that shall be created for the given planned region
-Line 222 
 static RegionGroups groupByRegionInterse
+Line 225 
 static RegionGroups groupByRegionInterse
  static Dimensions getDimensionsForRegionGroup(RegionGroup& regionGroup) {
      std::map<gig::dimension_t, std::set<int> > dimUpperLimits;
+     #if DEBUG_COMBINE_INSTRUMENTS
+     printf("dimUpperLimits = {\n");
+     #endif
      // collect all dimension region zones' upper limits
      for (RegionGroup::iterator it = regionGroup.begin();
           it != regionGroup.end(); ++it)
-Line 230 
 static Dimensions getDimensionsForRegion
+Line 236 
 static Dimensions getDimensionsForRegion
          int previousBits = 0;
          for (uint d = 0; d < rgn->Dimensions; ++d) {
              const gig::dimension_def_t& def = rgn->pDimensionDefinitions[d];
+             #if DEBUG_COMBINE_INSTRUMENTS
+             printf("\t[rgn=%p,dim=%#x] = {", rgn, def.dimension);
+             #endif
              for (uint z = 0; z < def.zones; ++z) {
                  int dr = z << previousBits;
                  gig::DimensionRegion* dimRgn = rgn->pDimensionRegions[dr];
-                 // Store the individual dimension zone sizes (or actually their
+                 // NOTE: Originally this function collected dimensions' upper
-                 // upper limits here) for each dimension.
+                 // limits. However that caused combined instruments (e.g. with
-                 // HACK: Note that the velocity dimension is specially handled
+                 // unequal dimension zone counts, not being a power of two) to
-                 // here. Instead of taking over custom velocity split sizes
+                 // end up having too many dimension zones and those extra zones
-                 // here, only a bogus number (zone index number) is stored for
+                 // containing no sample. For that reason we simply collect the
-                 // each velocity zone, that way only the maxiumum amount of
+                 // required amount of output dimension zones here now instead.
-                 // velocity splits of all regions is stored here, and when their
+                 const int upperLimit =
-                 // individual DimensionRegions are finally copied (later), the
+ /*
-                 // individual velocity split size are copied by that.
-                 dimUpperLimits[def.dimension].insert(
                      (def.dimension == gig::dimension_velocity) ?
                          z : (def.split_type == gig::split_type_bit) ?
-                             ((z+1) * 128/def.zones - 1) : dimRgn->DimensionUpperLimits[dr]
+                             ((z+1) * 128/def.zones - 1) : dimRgn->DimensionUpperLimits[dr];
-                 );
+  */
+                     z;
+                 #if DEBUG_COMBINE_INSTRUMENTS
+                 printf(" %d,", upperLimit);
+                 #endif
+                 dimUpperLimits[def.dimension].insert(upperLimit);
              }
              previousBits += def.bits;
+             #if DEBUG_COMBINE_INSTRUMENTS
+             printf(" }\n");
+             #endif
          }
      }
+     #if DEBUG_COMBINE_INSTRUMENTS
+     printf("}\n");
+     #endif
      // convert upper limit set to range vector
      Dimensions dims;
+     #if DEBUG_COMBINE_INSTRUMENTS
+     printf("dims = {\n");
+     #endif
      for (std::map<gig::dimension_t, std::set<int> >::const_iterator it = dimUpperLimits.begin();
           it != dimUpperLimits.end(); ++it)
      {
          gig::dimension_t type = it->first;
+         #if DEBUG_COMBINE_INSTRUMENTS
+         printf("\t[dim=%#x] = {", type);
+         #endif
          int iLow = 0;
          for (std::set<int>::const_iterator itNums = it->second.begin();
               itNums != it->second.end(); ++itNums)
-Line 265 
 static Dimensions getDimensionsForRegion
+Line 289 
 static Dimensions getDimensionsForRegion
              const int iUpperLimit = *itNums;
              DLS::range_t range = { uint16_t(iLow), uint16_t(iUpperLimit) };
              dims[type].push_back(range);
+             #if DEBUG_COMBINE_INSTRUMENTS
+             printf(" %d..%d,", iLow, iUpperLimit);
+             #endif
              iLow = iUpperLimit + 1;
          }
+         #if DEBUG_COMBINE_INSTRUMENTS
+         printf(" }\n");
+         #endif
      }
+     #if DEBUG_COMBINE_INSTRUMENTS
+     printf("}\n");
+     #endif
      return dims;
  }
-Line 284 
 static void fillDimValues(uint* values/*
+Line 317 
 static void fillDimValues(uint* values/*
          else if (iDimIndex < 0) continue;
          values[iDimIndex] = it->second;
          #if DEBUG_COMBINE_INSTRUMENTS
-         printf("%x=%d, ", type, it->second);
+         printf("0x%x=%d, ", type, it->second);
          #endif
      }
      #if DEBUG_COMBINE_INSTRUMENTS
-Line 379 
 struct CopyAssignSchedEntry {
+Line 412 
 struct CopyAssignSchedEntry {
  };
  typedef std::vector<CopyAssignSchedEntry> CopyAssignSchedule;
+ /** @brief Constrain @a dimCase according to @a rgn's dimension zones.
+  *
+  * To avoid @a dimCase being an invalid dimension region selection on @a rgn,
+  * this function automatically wraps (if required) the individual dimension case
+  * entries according to region's actual amount of dimension zones.
+  *
+  * @param dimCase - dimension case to be potentially corrected
+  * @param rgn - the region upon @a dimCase shall be corrected for
+  */
+ static void wrapDimCase(DimensionCase& dimCase, gig::Region* rgn) {
+     for (auto& it : dimCase) {
+         gig::dimension_def_t* def = rgn->GetDimensionDefinition(it.first);
+         const int zones = (def) ? def->zones : 1;
+         it.second %= zones;
+     }
+ }
  /** @brief Schedule copying DimensionRegions from source Region to target Region.
   *
   * Schedules copying the entire articulation informations (including sample
-Line 423 
 static void scheduleCopyDimensionRegions
+Line 473 
 static void scheduleCopyDimensionRegions
          uint dstDimValues[8] = {};
          DimensionCase srcDimCase = dimCase;
          DimensionCase dstDimCase = dimCase;
+         // source might have less zones than destination, so to prevent output
+         // instrument ending up with NULL samples in some of the dimension
+         // zones, wrap here the source zone according to the amount of zones the
+         // source really has
+         wrapDimCase(srcDimCase, inRgn);
          srcDimCase[mainDim] = iSrcMainBit;
          dstDimCase[mainDim] = iDstMainBit;
-Line 781 
 static void combineInstruments(std::vect
+Line 838 
 static void combineInstruments(std::vect
  CombineInstrumentsDialog::CombineInstrumentsDialog(Gtk::Window& parent, gig::File* gig)
      : ManagedDialog(_("Combine Instruments"), parent, true),
        m_gig(gig), m_fileWasChanged(false), m_newCombinedInstrument(NULL),
+ #if HAS_GTKMM_STOCK
+       m_cancelButton(Gtk::Stock::CANCEL), m_OKButton(Gtk::Stock::OK),
+ #else
        m_cancelButton(_("_Cancel"), true), m_OKButton(_("_OK"), true),
-       m_descriptionLabel(), m_tableDimCombo(2, 2), m_comboDimType(),
+ #endif
+       m_descriptionLabel(),
+ #if USE_GTKMM_GRID
+       m_tableDimCombo(),
+ #else
+       m_tableDimCombo(2, 2),
+ #endif
+       m_comboDimType(),
        m_labelDimType(Glib::ustring(_("Combine by Dimension:")) + "  ", Gtk::ALIGN_END)
  {
+     if (!Settings::singleton()->autoRestoreWindowDimension) {
+         set_default_size(500, 600);
+         set_position(Gtk::WIN_POS_MOUSE);
+     }
      m_scrolledWindow.add(m_treeView);
      m_scrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
+ #if USE_GTKMM_BOX
+     get_content_area()->pack_start(m_descriptionLabel, Gtk::PACK_SHRINK);
+     get_content_area()->pack_start(m_tableDimCombo, Gtk::PACK_SHRINK);
+     get_content_area()->pack_start(m_scrolledWindow);
+     get_content_area()->pack_start(m_labelOrder, Gtk::PACK_SHRINK);
+     get_content_area()->pack_start(m_iconView, Gtk::PACK_SHRINK);
+     get_content_area()->pack_start(m_buttonBox, Gtk::PACK_SHRINK);
+ #else
      get_vbox()->pack_start(m_descriptionLabel, Gtk::PACK_SHRINK);
      get_vbox()->pack_start(m_tableDimCombo, Gtk::PACK_SHRINK);
      get_vbox()->pack_start(m_scrolledWindow);
+     get_vbox()->pack_start(m_labelOrder, Gtk::PACK_SHRINK);
+     get_vbox()->pack_start(m_iconView, Gtk::PACK_SHRINK);
      get_vbox()->pack_start(m_buttonBox, Gtk::PACK_SHRINK);
+ #endif
  #if GTKMM_MAJOR_VERSION >= 3
      m_descriptionLabel.set_line_wrap();
-Line 835 
 CombineInstrumentsDialog::CombineInstrum
+Line 918 
 CombineInstrumentsDialog::CombineInstrum
          "Use SHIFT + left click or CTRL + left click to select the instruments "
          "you want to combine."
      ));
-     m_treeView.append_column("Instrument", m_columns.m_col_name);
+     m_treeView.append_column(_("Nr"), m_columns.m_col_index);
-     m_treeView.set_headers_visible(false);
+     m_treeView.append_column(_("Instrument"), m_columns.m_col_name);
+     m_treeView.set_headers_visible(true);
      m_treeView.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
      m_treeView.get_selection()->signal_changed().connect(
          sigc::mem_fun(*this, &CombineInstrumentsDialog::onSelectionChanged)
-Line 861 
 CombineInstrumentsDialog::CombineInstrum
+Line 945 
 CombineInstrumentsDialog::CombineInstrum
          Glib::ustring name(gig_to_utf8(instr->pInfo->Name));
          Gtk::TreeModel::iterator iter = m_refTreeModel->append();
          Gtk::TreeModel::Row row = *iter;
+         row[m_columns.m_col_index] = i;
          row[m_columns.m_col_name] = name;
          row[m_columns.m_col_instr] = instr;
      }
+     m_refOrderModel = Gtk::ListStore::create(m_orderColumns);
+     m_iconView.set_model(m_refOrderModel);
+     m_iconView.set_tooltip_text(_("Use drag & drop to change the order."));
+     m_iconView.set_markup_column(1);
+     m_iconView.set_selection_mode(Gtk::SELECTION_SINGLE);
+     // force background to retain white also on selections
+     // (this also fixes a bug with GTK 2 which often causes visibility issue
+     //  with the text of the selected item)
+     {
+ #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
+         Gdk::Color white;
+ #else
+         Gdk::RGBA white;
+ #endif
+         white.set("#ffffff");
+         GtkWidget* widget = (GtkWidget*) m_iconView.gobj();
+ #if GTK_MAJOR_VERSION < 3
+         gtk_widget_modify_base(widget, GTK_STATE_SELECTED, white.gobj());
+         gtk_widget_modify_base(widget, GTK_STATE_ACTIVE, white.gobj());
+         gtk_widget_modify_bg(widget, GTK_STATE_SELECTED, white.gobj());
+         gtk_widget_modify_bg(widget, GTK_STATE_ACTIVE, white.gobj());
+ #endif
+     }
+     m_labelOrder.set_text(_("Order of the instruments to be combined:"));
+     // 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_iconView.drag_source_set(drag_target_instrument);
+         m_iconView.drag_dest_set(drag_target_instrument);
+         m_iconView.signal_drag_begin().connect(
+             sigc::mem_fun(*this, &CombineInstrumentsDialog::on_order_drag_begin)
+         );
+         m_iconView.signal_drag_data_get().connect(
+             sigc::mem_fun(*this, &CombineInstrumentsDialog::on_order_drag_data_get)
+         );
+         m_iconView.signal_drag_data_received().connect(
+             sigc::mem_fun(*this, &CombineInstrumentsDialog::on_order_drop_drag_data_received)
+         );
+     }
      m_buttonBox.set_layout(Gtk::BUTTONBOX_END);
+ #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
+     m_buttonBox.set_margin(5);
+ #else
      m_buttonBox.set_border_width(5);
+ #endif
      m_buttonBox.pack_start(m_cancelButton, Gtk::PACK_SHRINK);
      m_buttonBox.pack_start(m_OKButton, Gtk::PACK_SHRINK);
      m_buttonBox.show();
-Line 883 
 CombineInstrumentsDialog::CombineInstrum
+Line 1016 
 CombineInstrumentsDialog::CombineInstrum
          sigc::mem_fun(*this, &CombineInstrumentsDialog::combineSelectedInstruments)
      );
+ #if HAS_GTKMM_SHOW_ALL_CHILDREN
      show_all_children();
+ #endif
+     Settings::singleton()->showTooltips.get_proxy().signal_changed().connect(
+         sigc::mem_fun(*this, &CombineInstrumentsDialog::on_show_tooltips_changed)
+     );
+     on_show_tooltips_changed();
      // show a warning to user if he uses a .gig in v2 format
      if (gig->pVersion->major < 3) {
-Line 896 
 CombineInstrumentsDialog::CombineInstrum
+Line 1036 
 CombineInstrumentsDialog::CombineInstrum
          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_WARNING);
          msg.run();
      }
+     // OK button should have focus by default for quick combining with Return key
+     m_OKButton.grab_focus();
+ }
+ void CombineInstrumentsDialog::on_order_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
+ {
+     #if DEBUG_COMBINE_INSTRUMENTS
+     printf("Drag begin\n");
+     #endif
+     first_call_to_drag_data_get = true;
+ }
+ void CombineInstrumentsDialog::on_order_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context,
+                                                        Gtk::SelectionData& selection_data, guint, guint)
+ {
+     #if DEBUG_COMBINE_INSTRUMENTS
+     printf("Drag data get\n");
+     #endif
+     if (!first_call_to_drag_data_get) return;
+     first_call_to_drag_data_get = false;
+     // get selected source instrument
+     gig::Instrument* src = NULL;
+     {
+         std::vector<Gtk::TreeModel::Path> rows = m_iconView.get_selected_items();
+         if (!rows.empty()) {
+             Gtk::TreeModel::iterator it = m_refOrderModel->get_iter(rows[0]);
+             if (it) {
+                 Gtk::TreeModel::Row row = *it;
+                 src = row[m_orderColumns.m_col_instr];
+             }
+         }
+     }
+     if (!src) {
+         printf("Drag data get: !src\n");
+         return;
+     }
+     #if DEBUG_COMBINE_INSTRUMENTS
+     printf("src=%ld\n", (size_t)src);
+     #endif
+     // pass the source gig::Instrument as pointer
+     selection_data.set(selection_data.get_target(), 0/*unused*/, (const guchar*)&src,
+                        sizeof(src)/*length of data in bytes*/);
+ }
+ void CombineInstrumentsDialog::on_order_drop_drag_data_received(
+     const Glib::RefPtr<Gdk::DragContext>& context, int x, int y,
+     const Gtk::SelectionData& selection_data, guint, guint time)
+ {
+     #if DEBUG_COMBINE_INSTRUMENTS
+     printf("Drag data received\n");
+     #endif
+     if (!selection_data.get_data()) {
+         printf("selection_data.get_data() == NULL\n");
+         return;
+     }
+     gig::Instrument* src = *((gig::Instrument**) selection_data.get_data());
+     if (!src || selection_data.get_length() != sizeof(gig::Instrument*)) {
+         printf("!src\n");
+         return;
+     }
+     #if DEBUG_COMBINE_INSTRUMENTS
+     printf("src=%ld\n", (size_t)src);
+     #endif
+     gig::Instrument* dst = NULL;
+     {
+         Gtk::TreeModel::Path path = m_iconView.get_path_at_pos(x, y);
+         if (!path) return;
+         Gtk::TreeModel::iterator iter = m_refOrderModel->get_iter(path);
+         if (!iter) return;
+         Gtk::TreeModel::Row row = *iter;
+         dst = row[m_orderColumns.m_col_instr];
+     }
+     if (!dst) {
+         printf("!dst\n");
+         return;
+     }
+     #if DEBUG_COMBINE_INSTRUMENTS
+     printf("dragdrop received src='%s' dst='%s'\n", src->pInfo->Name.c_str(), dst->pInfo->Name.c_str());
+     #endif
+     // swap the two items
+     typedef Gtk::TreeModel::Children Children;
+     Children children = m_refOrderModel->children();
+     Children::iterator itSrc, itDst;
+     int i = 0, iSrc = -1, iDst = -1;
+     for (Children::iterator iter = children.begin();
+          iter != children.end(); ++iter, ++i)
+     {
+         Gtk::TreeModel::Row row = *iter;
+         if (row[m_orderColumns.m_col_instr] == src) {
+             itSrc = iter;
+             iSrc  = i;
+         } else if (row[m_orderColumns.m_col_instr] == dst) {
+             itDst = iter;
+             iDst  = i;
+         }
+     }
+     if (itSrc && itDst) {
+         // swap elements
+         m_refOrderModel->iter_swap(itSrc, itDst);
+         // update markup
+         Gtk::TreeModel::Row rowSrc = *itSrc;
+         Gtk::TreeModel::Row rowDst = *itDst;
+         {
+             Glib::ustring name = rowSrc[m_orderColumns.m_col_name];
+             Glib::ustring markup =
+                 "<span foreground='black' background='white'>" + ToString(iDst+1) + ".</span>\n<span foreground='green' background='white'>" + name + "</span>";
+             rowSrc[m_orderColumns.m_col_markup] = markup;
+         }
+         {
+             Glib::ustring name = rowDst[m_orderColumns.m_col_name];
+             Glib::ustring markup =
+                 "<span foreground='black' background='white'>" + ToString(iSrc+1) + ".</span>\n<span foreground='green' background='white'>" + name + "</span>";
+             rowDst[m_orderColumns.m_col_markup] = markup;
+         }
+     }
+ }
+ void CombineInstrumentsDialog::setSelectedInstruments(const std::set<int>& instrumentIndeces) {
+     typedef Gtk::TreeModel::Children Children;
+     Children children = m_refTreeModel->children();
+     for (Children::iterator iter = children.begin();
+          iter != children.end(); ++iter)
+     {
+         Gtk::TreeModel::Row row = *iter;
+         int index = row[m_columns.m_col_index];
+         if (instrumentIndeces.count(index))
+             m_treeView.get_selection()->select(iter);
+     }
+     // hack: OK button lost focus after doing the above, it should have focus by default for quick combining with Return key
+     m_OKButton.grab_focus();
  }
  void CombineInstrumentsDialog::combineSelectedInstruments() {
      std::vector<gig::Instrument*> instruments;
-     std::vector<Gtk::TreeModel::Path> v = m_treeView.get_selection()->get_selected_rows();
+     {
-     for (uint i = 0; i < v.size(); ++i) {
+         typedef Gtk::TreeModel::Children Children;
-         Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(v[i]);
+         int i = 0;
-         Gtk::TreeModel::Row row = *it;
+         Children selection = m_refOrderModel->children();
-         Glib::ustring name = row[m_columns.m_col_name];
+         for (Children::iterator it = selection.begin();
-         gig::Instrument* instrument = row[m_columns.m_col_instr];
+              it != selection.end(); ++it, ++i)
-         #if DEBUG_COMBINE_INSTRUMENTS
+         {
-         printf("Selection '%s' 0x%lx\n\n", name.c_str(), int64_t((void*)instrument));
+             Gtk::TreeModel::Row row = *it;
-         #endif
+             Glib::ustring name = row[m_orderColumns.m_col_name];
-         instruments.push_back(instrument);
+             gig::Instrument* instrument = row[m_orderColumns.m_col_instr];
+             #if DEBUG_COMBINE_INSTRUMENTS
+             printf("Selection %d. '%s' %p\n\n", (i+1), name.c_str(), instrument);
+             #endif
+             instruments.push_back(instrument);
+         }
      }
      g_warnings.clear();
-Line 926 
 void CombineInstrumentsDialog::combineSe
+Line 1209 
 void CombineInstrumentsDialog::combineSe
              mainDimension = static_cast<gig::dimension_t>(iTypeID);
          }
-         // now start the actual cobination task ...
+         // now start the actual combination task ...
          combineInstruments(instruments, m_gig, m_newCombinedInstrument, mainDimension);
      } catch (RIFF::Exception e) {;
          Gtk::MessageDialog msg(*this, e.Message, false, Gtk::MESSAGE_ERROR);
-Line 966 
 void CombineInstrumentsDialog::combineSe
+Line 1249 
 void CombineInstrumentsDialog::combineSe
  void CombineInstrumentsDialog::onSelectionChanged() {
      std::vector<Gtk::TreeModel::Path> v = m_treeView.get_selection()->get_selected_rows();
      m_OKButton.set_sensitive(v.size() >= 2);
+     typedef Gtk::TreeModel::Children Children;
+     // update horizontal selection list (icon view) ...
+     // remove items which are not part of the new selection anymore
+     {
+         Children allOrdered = m_refOrderModel->children();
+         for (Children::iterator itOrder = allOrdered.begin();
+              itOrder != allOrdered.end(); )
+         {
+             Gtk::TreeModel::Row rowOrder = *itOrder;
+             gig::Instrument* instr = rowOrder[m_orderColumns.m_col_instr];
+             for (uint i = 0; i < v.size(); ++i) {
+                 Gtk::TreeModel::iterator itSel = m_refTreeModel->get_iter(v[i]);
+                 Gtk::TreeModel::Row rowSel = *itSel;
+                 if (rowSel[m_columns.m_col_instr] == instr)
+                     goto nextOrderedItem;
+             }
+             goto removeOrderedItem;
+         nextOrderedItem:
+             ++itOrder;
+             continue;
+         removeOrderedItem:
+             // postfix increment here to avoid iterator invalidation
+             m_refOrderModel->erase(itOrder++);
+         }
+     }
+     // add items newly added to the selection
+     for (uint i = 0; i < v.size(); ++i) {
+         Gtk::TreeModel::iterator itSel = m_refTreeModel->get_iter(v[i]);
+         Gtk::TreeModel::Row rowSel = *itSel;
+         gig::Instrument* instr = rowSel[m_columns.m_col_instr];
+         Children allOrdered = m_refOrderModel->children();
+         for (Children::iterator itOrder = allOrdered.begin();
+              itOrder != allOrdered.end(); ++itOrder)
+         {
+             Gtk::TreeModel::Row rowOrder = *itOrder;
+             if (rowOrder[m_orderColumns.m_col_instr] == instr)
+                 goto nextSelectionItem;
+         }
+         goto addNewSelectionItem;
+     nextSelectionItem:
+         continue;
+     addNewSelectionItem:
+         Glib::ustring name = gig_to_utf8(instr->pInfo->Name);
+         Gtk::TreeModel::iterator iterOrder = m_refOrderModel->append();
+         Gtk::TreeModel::Row rowOrder = *iterOrder;
+         rowOrder[m_orderColumns.m_col_name] = name;
+         rowOrder[m_orderColumns.m_col_instr] = instr;
+     }
+     // update markup
+     {
+         int i = 0;
+         Children allOrdered = m_refOrderModel->children();
+         for (Children::iterator itOrder = allOrdered.begin();
+              itOrder != allOrdered.end(); ++itOrder, ++i)
+         {
+             Gtk::TreeModel::Row rowOrder = *itOrder;
+             Glib::ustring name = rowOrder[m_orderColumns.m_col_name];
+             Glib::ustring markup =
+                 "<span foreground='black' background='white'>" + ToString(i+1) + ".</span>\n<span foreground='green' background='white'>" + name + "</span>";
+             rowOrder[m_orderColumns.m_col_markup] = markup;
+         }
+     }
+ }
+ void CombineInstrumentsDialog::on_show_tooltips_changed() {
+     const bool b = Settings::singleton()->showTooltips;
+     m_treeView.set_has_tooltip(b);
+     m_iconView.set_has_tooltip(b);
+     set_has_tooltip(b);
  }
  bool CombineInstrumentsDialog::fileWasChanged() const {

 Legend:



Removed from v.3089
 


changed lines


 
Added in v.3783
 Legend:



Removed from v.3089
 


changed lines


 
Added in v.3783
-Removed from v.3089
+Added in v.3783

	ViewVC Help
Powered by ViewVC