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

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

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

revision 2579 by persson, Sat May 24 06:44:39 2014 UTC revision 3300 by schoenebeck, Sun Jul 9 18:15:02 2017 UTC
# Line 1  Line 1 
1  /*  /*
2      Copyright (c) 2014 Christian Schoenebeck      Copyright (c) 2014-2017 Christian Schoenebeck
3            
4      This file is part of "gigedit" and released under the terms of the      This file is part of "gigedit" and released under the terms of the
5      GNU General Public License version 2.      GNU General Public License version 2.
6  */  */
7    
8    #include "global.h"
9  #include "CombineInstrumentsDialog.h"  #include "CombineInstrumentsDialog.h"
10    
11  // enable this for debug messages being printed while combining the instruments  // enable this for debug messages being printed while combining the instruments
12  #define DEBUG_COMBINE_INSTRUMENTS 0  #define DEBUG_COMBINE_INSTRUMENTS 0
13    
 #include "global.h"  
14  #include "compat.h"  #include "compat.h"
15    
16  #include <set>  #include <set>
# Line 24  Line 24 
24  #include <gtkmm/messagedialog.h>  #include <gtkmm/messagedialog.h>
25  #include <gtkmm/label.h>  #include <gtkmm/label.h>
26    
 Glib::ustring gig_to_utf8(const gig::String& gig_string);  
27  Glib::ustring dimTypeAsString(gig::dimension_t d);  Glib::ustring dimTypeAsString(gig::dimension_t d);
28    
29  typedef std::vector< std::pair<gig::Instrument*, gig::Region*> > OrderedRegionGroup;  typedef std::vector< std::pair<gig::Instrument*, gig::Region*> > OrderedRegionGroup;
# Line 34  typedef std::map<DLS::range_t,RegionGrou Line 33  typedef std::map<DLS::range_t,RegionGrou
33  typedef std::vector<DLS::range_t> DimensionZones;  typedef std::vector<DLS::range_t> DimensionZones;
34  typedef std::map<gig::dimension_t,DimensionZones> Dimensions;  typedef std::map<gig::dimension_t,DimensionZones> Dimensions;
35    
 typedef std::map<gig::dimension_t,int> DimensionCase;  
   
36  typedef std::map<gig::dimension_t, int> DimensionRegionUpperLimits;  typedef std::map<gig::dimension_t, int> DimensionRegionUpperLimits;
37    
38  typedef std::set<Glib::ustring> Warnings;  typedef std::set<Glib::ustring> Warnings;
# Line 97  inline int smallestOverlapPoint(const DL Line 94  inline int smallestOverlapPoint(const DL
94   *          found with a range member point >= iStart   *          found with a range member point >= iStart
95   */   */
96  static int findLowestRegionPoint(std::vector<gig::Instrument*>& instruments, int iStart) {  static int findLowestRegionPoint(std::vector<gig::Instrument*>& instruments, int iStart) {
97      DLS::range_t searchRange = { iStart, 127 };      DLS::range_t searchRange = { uint16_t(iStart), 127 };
98      int result = -1;      int result = -1;
99      for (uint i = 0; i < instruments.size(); ++i) {      for (uint i = 0; i < instruments.size(); ++i) {
100          gig::Instrument* instr = instruments[i];          gig::Instrument* instr = instruments[i];
# Line 119  static int findLowestRegionPoint(std::ve Line 116  static int findLowestRegionPoint(std::ve
116   *          with a range end >= iStart   *          with a range end >= iStart
117   */   */
118  static int findFirstRegionEnd(std::vector<gig::Instrument*>& instruments, int iStart) {  static int findFirstRegionEnd(std::vector<gig::Instrument*>& instruments, int iStart) {
119      DLS::range_t searchRange = { iStart, 127 };      DLS::range_t searchRange = { uint16_t(iStart), 127 };
120      int result = -1;      int result = -1;
121      for (uint i = 0; i < instruments.size(); ++i) {      for (uint i = 0; i < instruments.size(); ++i) {
122          gig::Instrument* instr = instruments[i];          gig::Instrument* instr = instruments[i];
# Line 195  static RegionGroups groupByRegionInterse Line 192  static RegionGroups groupByRegionInterse
192          iStart = findLowestRegionPoint(instruments, iStart);          iStart = findLowestRegionPoint(instruments, iStart);
193          if (iStart < 0) break;          if (iStart < 0) break;
194          const int iEnd = findFirstRegionEnd(instruments, iStart);          const int iEnd = findFirstRegionEnd(instruments, iStart);
195          DLS::range_t range = { iStart, iEnd };          DLS::range_t range = { uint16_t(iStart), uint16_t(iEnd) };
196          intersections.push_back(range);          intersections.push_back(range);
197          iStart = iEnd + 1;          iStart = iEnd + 1;
198      }      }
# Line 266  static Dimensions getDimensionsForRegion Line 263  static Dimensions getDimensionsForRegion
263               itNums != it->second.end(); ++itNums)               itNums != it->second.end(); ++itNums)
264          {          {
265              const int iUpperLimit = *itNums;              const int iUpperLimit = *itNums;
266              DLS::range_t range = { iLow, iUpperLimit };              DLS::range_t range = { uint16_t(iLow), uint16_t(iUpperLimit) };
267              dims[type].push_back(range);              dims[type].push_back(range);
268              iLow = iUpperLimit + 1;              iLow = iUpperLimit + 1;
269          }          }
# Line 275  static Dimensions getDimensionsForRegion Line 272  static Dimensions getDimensionsForRegion
272      return dims;      return dims;
273  }  }
274    
 inline int getDimensionIndex(gig::dimension_t type, gig::Region* rgn) {  
     for (uint i = 0; i < rgn->Dimensions; ++i)  
         if (rgn->pDimensionDefinitions[i].dimension == type)  
             return i;  
     return -1;  
 }  
   
275  static void fillDimValues(uint* values/*[8]*/, DimensionCase dimCase, gig::Region* rgn, bool bShouldHaveAllDimensionsPassed) {  static void fillDimValues(uint* values/*[8]*/, DimensionCase dimCase, gig::Region* rgn, bool bShouldHaveAllDimensionsPassed) {
276      #if DEBUG_COMBINE_INSTRUMENTS      #if DEBUG_COMBINE_INSTRUMENTS
277      printf("dimvalues = { ");      printf("dimvalues = { ");
# Line 323  static void restoreDimensionRegionUpperL Line 313  static void restoreDimensionRegionUpperL
313      }      }
314  }  }
315    
 /**  
  * Returns the sum of all bits of all dimensions defined before the given  
  * dimensions (@a type). This allows to access cases of that particular  
  * dimension directly.  
  *  
  * @param type - dimension that shall be used  
  * @param rgn - parent region of that dimension  
  */  
 inline int baseBits(gig::dimension_t type, gig::Region* rgn) {  
     int previousBits = 0;  
     for (uint i = 0; i < rgn->Dimensions; ++i) {  
         if (rgn->pDimensionDefinitions[i].dimension == type) break;  
         previousBits += rgn->pDimensionDefinitions[i].bits;  
     }  
     return previousBits;  
 }  
   
316  inline int dimensionRegionIndex(gig::DimensionRegion* dimRgn) {  inline int dimensionRegionIndex(gig::DimensionRegion* dimRgn) {
317      gig::Region* rgn = dimRgn->GetParent();      gig::Region* rgn = dimRgn->GetParent();
318      int sz = sizeof(rgn->pDimensionRegions) / sizeof(gig::DimensionRegion*);      int sz = sizeof(rgn->pDimensionRegions) / sizeof(gig::DimensionRegion*);
# Line 372  static DimensionZones preciseDimensionZo Line 345  static DimensionZones preciseDimensionZo
345      const gig::dimension_def_t& def = rgn->pDimensionDefinitions[iDimension];      const gig::dimension_def_t& def = rgn->pDimensionDefinitions[iDimension];
346      int iDimRgn = dimensionRegionIndex(dimRgn);      int iDimRgn = dimensionRegionIndex(dimRgn);
347      int iBaseBits = baseBits(type, rgn);      int iBaseBits = baseBits(type, rgn);
348        assert(iBaseBits >= 0);
349      int mask = ~(((1 << def.bits) - 1) << iBaseBits);      int mask = ~(((1 << def.bits) - 1) << iBaseBits);
350    
351      #if DEBUG_COMBINE_INSTRUMENTS      #if DEBUG_COMBINE_INSTRUMENTS
# Line 383  static DimensionZones preciseDimensionZo Line 357  static DimensionZones preciseDimensionZo
357          gig::DimensionRegion* dimRgn2 =          gig::DimensionRegion* dimRgn2 =
358              rgn->pDimensionRegions[ (iDimRgn & mask) | ( z << iBaseBits) ];              rgn->pDimensionRegions[ (iDimRgn & mask) | ( z << iBaseBits) ];
359          int iHigh = dimRgn2->DimensionUpperLimits[iDimension];          int iHigh = dimRgn2->DimensionUpperLimits[iDimension];
360          DLS::range_t range = { iLow, iHigh};          DLS::range_t range = { uint16_t(iLow), uint16_t(iHigh) };
361          #if DEBUG_COMBINE_INSTRUMENTS          #if DEBUG_COMBINE_INSTRUMENTS
362          printf("%d..%d, ", iLow, iHigh);          printf("%d..%d, ", iLow, iHigh);
363          fflush(stdout);          fflush(stdout);
# Line 469  static void scheduleCopyDimensionRegions Line 443  static void scheduleCopyDimensionRegions
443          #if DEBUG_COMBINE_INSTRUMENTS          #if DEBUG_COMBINE_INSTRUMENTS
444          printf("dst "); fflush(stdout);          printf("dst "); fflush(stdout);
445          #endif          #endif
446          fillDimValues(dstDimValues, dstDimCase, outRgn, true);          fillDimValues(dstDimValues, dstDimCase, outRgn, false);
447          gig::DimensionRegion* srcDimRgn = inRgn->GetDimensionRegionByValue(srcDimValues);          gig::DimensionRegion* srcDimRgn = inRgn->GetDimensionRegionByValue(srcDimValues);
448          gig::DimensionRegion* dstDimRgn = outRgn->GetDimensionRegionByValue(dstDimValues);          gig::DimensionRegion* dstDimRgn = outRgn->GetDimensionRegionByValue(dstDimValues);
449          #if DEBUG_COMBINE_INSTRUMENTS          #if DEBUG_COMBINE_INSTRUMENTS
# Line 505  static void scheduleCopyDimensionRegions Line 479  static void scheduleCopyDimensionRegions
479              printf("dst velocity value = %d\n", dstDimCase[gig::dimension_velocity]);              printf("dst velocity value = %d\n", dstDimCase[gig::dimension_velocity]);
480              printf("dst refilled "); fflush(stdout);              printf("dst refilled "); fflush(stdout);
481              #endif              #endif
482              fillDimValues(dstDimValues, dstDimCase, outRgn, true);              fillDimValues(dstDimValues, dstDimCase, outRgn, false);
483              dstDimRgn = outRgn->GetDimensionRegionByValue(dstDimValues);              dstDimRgn = outRgn->GetDimensionRegionByValue(dstDimValues);
484              #if DEBUG_COMBINE_INSTRUMENTS              #if DEBUG_COMBINE_INSTRUMENTS
485              printf("reselected dstDimRgn=%lx\n", (uint64_t)dstDimRgn);              printf("reselected dstDimRgn=%lx\n", (uint64_t)dstDimRgn);
# Line 660  static void combineInstruments(std::vect Line 634  static void combineInstruments(std::vect
634              iTotalZones += (def) ? def->zones : 1;              iTotalZones += (def) ? def->zones : 1;
635          }          }
636          #if DEBUG_COMBINE_INSTRUMENTS          #if DEBUG_COMBINE_INSTRUMENTS
637          printf("Required total zones: %d\n", iTotalZones);          printf("Required total zones: %d, vertical regions: %d\n", iTotalZones, itGroup->second.size());
638          #endif          #endif
639    
640          // create all required dimensions for this output region          // create all required dimensions for this output region
# Line 722  static void combineInstruments(std::vect Line 696  static void combineInstruments(std::vect
696              #if DEBUG_COMBINE_INSTRUMENTS              #if DEBUG_COMBINE_INSTRUMENTS
697              std::cout << "OK" << std::endl << std::flush;              std::cout << "OK" << std::endl << std::flush;
698              #endif              #endif
699            } else {
700                dims.erase(mainDimension);
701          }          }
702    
703          // for the next task we need to have the current RegionGroup to be          // for the next task we need to have the current RegionGroup to be
# Line 803  static void combineInstruments(std::vect Line 779  static void combineInstruments(std::vect
779  // class 'CombineInstrumentsDialog'  // class 'CombineInstrumentsDialog'
780    
781  CombineInstrumentsDialog::CombineInstrumentsDialog(Gtk::Window& parent, gig::File* gig)  CombineInstrumentsDialog::CombineInstrumentsDialog(Gtk::Window& parent, gig::File* gig)
782      : Gtk::Dialog(_("Combine Instruments"), parent, true),      : ManagedDialog(_("Combine Instruments"), parent, true),
783        m_gig(gig), m_fileWasChanged(false), m_newCombinedInstrument(NULL),        m_gig(gig), m_fileWasChanged(false), m_newCombinedInstrument(NULL),
784        m_cancelButton(Gtk::Stock::CANCEL), m_OKButton(Gtk::Stock::OK),        m_cancelButton(Gtk::Stock::CANCEL), m_OKButton(Gtk::Stock::OK),
785        m_descriptionLabel(), m_tableDimCombo(2, 2), m_comboDimType(),        m_descriptionLabel(), m_tableDimCombo(2, 2), m_comboDimType(),
786        m_labelDimType(Glib::ustring(_("Combine by Dimension:")) + "  ", Gtk::ALIGN_END)        m_labelDimType(Glib::ustring(_("Combine by Dimension:")) + "  ", Gtk::ALIGN_END)
787  {  {
788        if (!Settings::singleton()->autoRestoreWindowDimension) {
789            set_default_size(500, 600);
790            set_position(Gtk::WIN_POS_MOUSE);
791        }
792    
793        m_scrolledWindow.add(m_treeView);
794        m_scrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
795    
796      get_vbox()->pack_start(m_descriptionLabel, Gtk::PACK_SHRINK);      get_vbox()->pack_start(m_descriptionLabel, Gtk::PACK_SHRINK);
797      get_vbox()->pack_start(m_tableDimCombo, Gtk::PACK_SHRINK);      get_vbox()->pack_start(m_tableDimCombo, Gtk::PACK_SHRINK);
798      get_vbox()->pack_start(m_treeView);      get_vbox()->pack_start(m_scrolledWindow);
799        get_vbox()->pack_start(m_labelOrder, Gtk::PACK_SHRINK);
800        get_vbox()->pack_start(m_iconView, Gtk::PACK_SHRINK);
801      get_vbox()->pack_start(m_buttonBox, Gtk::PACK_SHRINK);      get_vbox()->pack_start(m_buttonBox, Gtk::PACK_SHRINK);
802    
803  #if GTKMM_MAJOR_VERSION >= 3  #if GTKMM_MAJOR_VERSION >= 3
# Line 856  CombineInstrumentsDialog::CombineInstrum Line 842  CombineInstrumentsDialog::CombineInstrum
842          "Use SHIFT + left click or CTRL + left click to select the instruments "          "Use SHIFT + left click or CTRL + left click to select the instruments "
843          "you want to combine."          "you want to combine."
844      ));      ));
845      m_treeView.append_column("Instrument", m_columns.m_col_name);      m_treeView.append_column(_("Nr"), m_columns.m_col_index);
846      m_treeView.set_headers_visible(false);      m_treeView.append_column(_("Instrument"), m_columns.m_col_name);
847        m_treeView.set_headers_visible(true);
848      m_treeView.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);      m_treeView.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
849      m_treeView.get_selection()->signal_changed().connect(      m_treeView.get_selection()->signal_changed().connect(
850          sigc::mem_fun(*this, &CombineInstrumentsDialog::onSelectionChanged)          sigc::mem_fun(*this, &CombineInstrumentsDialog::onSelectionChanged)
# Line 882  CombineInstrumentsDialog::CombineInstrum Line 869  CombineInstrumentsDialog::CombineInstrum
869          Glib::ustring name(gig_to_utf8(instr->pInfo->Name));          Glib::ustring name(gig_to_utf8(instr->pInfo->Name));
870          Gtk::TreeModel::iterator iter = m_refTreeModel->append();          Gtk::TreeModel::iterator iter = m_refTreeModel->append();
871          Gtk::TreeModel::Row row = *iter;          Gtk::TreeModel::Row row = *iter;
872            row[m_columns.m_col_index] = i;
873          row[m_columns.m_col_name] = name;          row[m_columns.m_col_name] = name;
874          row[m_columns.m_col_instr] = instr;          row[m_columns.m_col_instr] = instr;
875      }      }
876    
877        m_refOrderModel = Gtk::ListStore::create(m_orderColumns);
878        m_iconView.set_model(m_refOrderModel);
879        m_iconView.set_tooltip_text(_("Use drag & drop to change the order."));
880        m_iconView.set_markup_column(1);
881        m_iconView.set_selection_mode(Gtk::SELECTION_SINGLE);
882        // force background to retain white also on selections
883        // (this also fixes a bug with GTK 2 which often causes visibility issue
884        //  with the text of the selected item)
885        {
886            Gdk::Color white;
887            white.set("#ffffff");
888            m_iconView.modify_base(Gtk::STATE_SELECTED, white);
889            m_iconView.modify_base(Gtk::STATE_ACTIVE, white);
890            m_iconView.modify_bg(Gtk::STATE_SELECTED, white);
891            m_iconView.modify_bg(Gtk::STATE_ACTIVE, white);
892        }
893    
894        m_labelOrder.set_text(_("Order of the instruments to be combined:"));
895    
896        // establish drag&drop within the instrument tree view, allowing to reorder
897        // the sequence of instruments within the gig file
898        {
899            std::vector<Gtk::TargetEntry> drag_target_instrument;
900            drag_target_instrument.push_back(Gtk::TargetEntry("gig::Instrument"));
901            m_iconView.drag_source_set(drag_target_instrument);
902            m_iconView.drag_dest_set(drag_target_instrument);
903            m_iconView.signal_drag_begin().connect(
904                sigc::mem_fun(*this, &CombineInstrumentsDialog::on_order_drag_begin)
905            );
906            m_iconView.signal_drag_data_get().connect(
907                sigc::mem_fun(*this, &CombineInstrumentsDialog::on_order_drag_data_get)
908            );
909            m_iconView.signal_drag_data_received().connect(
910                sigc::mem_fun(*this, &CombineInstrumentsDialog::on_order_drop_drag_data_received)
911            );
912        }
913    
914      m_buttonBox.set_layout(Gtk::BUTTONBOX_END);      m_buttonBox.set_layout(Gtk::BUTTONBOX_END);
915      m_buttonBox.set_border_width(5);      m_buttonBox.set_border_width(5);
916      m_buttonBox.pack_start(m_cancelButton, Gtk::PACK_SHRINK);      m_buttonBox.pack_start(m_cancelButton, Gtk::PACK_SHRINK);
# Line 919  CombineInstrumentsDialog::CombineInstrum Line 944  CombineInstrumentsDialog::CombineInstrum
944      }      }
945  }  }
946    
947    void CombineInstrumentsDialog::on_order_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
948    {
949        printf("Drag begin\n");
950        first_call_to_drag_data_get = true;
951    }
952    
953    void CombineInstrumentsDialog::on_order_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context,
954                                                           Gtk::SelectionData& selection_data, guint, guint)
955    {
956        printf("Drag data get\n");
957        if (!first_call_to_drag_data_get) return;
958        first_call_to_drag_data_get = false;
959    
960        // get selected source instrument
961        gig::Instrument* src = NULL;
962        {
963            std::vector<Gtk::TreeModel::Path> rows = m_iconView.get_selected_items();
964            if (!rows.empty()) {
965                Gtk::TreeModel::iterator it = m_refOrderModel->get_iter(rows[0]);
966                if (it) {
967                    Gtk::TreeModel::Row row = *it;
968                    src = row[m_orderColumns.m_col_instr];
969                }
970            }
971        }
972        if (!src) {
973            printf("Drag data get: !src\n");
974            return;
975        }
976        printf("src=%ld\n", (size_t)src);
977    
978        // pass the source gig::Instrument as pointer
979        selection_data.set(selection_data.get_target(), 0/*unused*/, (const guchar*)&src,
980                           sizeof(src)/*length of data in bytes*/);
981    }
982    
983    void CombineInstrumentsDialog::on_order_drop_drag_data_received(
984        const Glib::RefPtr<Gdk::DragContext>& context, int x, int y,
985        const Gtk::SelectionData& selection_data, guint, guint time)
986    {
987        printf("Drag data received\n");
988        if (&selection_data == NULL) {
989            printf("!selection_data\n");
990            return;
991        }
992        if (!selection_data.get_data()) {
993            printf("selection_data.get_data() == NULL\n");
994            return;
995        }
996    
997        gig::Instrument* src = *((gig::Instrument**) selection_data.get_data());
998        if (!src || selection_data.get_length() != sizeof(gig::Instrument*)) {
999            printf("!src\n");
1000            return;
1001        }
1002        printf("src=%d\n", src);
1003    
1004        gig::Instrument* dst = NULL;
1005        {
1006            Gtk::TreeModel::Path path = m_iconView.get_path_at_pos(x, y);
1007            if (!path) return;
1008    
1009            Gtk::TreeModel::iterator iter = m_refOrderModel->get_iter(path);
1010            if (!iter) return;
1011            Gtk::TreeModel::Row row = *iter;
1012            dst = row[m_orderColumns.m_col_instr];
1013        }
1014        if (!dst) {
1015            printf("!dst\n");
1016            return;
1017        }
1018    
1019        printf("dragdrop received src='%s' dst='%s'\n", src->pInfo->Name.c_str(), dst->pInfo->Name.c_str());
1020    
1021        // swap the two items
1022        typedef Gtk::TreeModel::Children Children;
1023        Children children = m_refOrderModel->children();
1024        Children::iterator itSrc, itDst;
1025        int i = 0, iSrc = -1, iDst = -1;
1026        for (Children::iterator iter = children.begin();
1027             iter != children.end(); ++iter, ++i)
1028        {
1029            Gtk::TreeModel::Row row = *iter;
1030            if (row[m_orderColumns.m_col_instr] == src) {
1031                itSrc = iter;
1032                iSrc  = i;
1033            } else if (row[m_orderColumns.m_col_instr] == dst) {
1034                itDst = iter;
1035                iDst  = i;
1036            }
1037        }
1038        if (itSrc && itDst) {
1039            // swap elements
1040            m_refOrderModel->iter_swap(itSrc, itDst);
1041            // update markup
1042            Gtk::TreeModel::Row rowSrc = *itSrc;
1043            Gtk::TreeModel::Row rowDst = *itDst;
1044            {
1045                Glib::ustring name = rowSrc[m_orderColumns.m_col_name];
1046                Glib::ustring markup =
1047                    "<span foreground='black' background='white'>" + ToString(iDst+1) + ".</span>\n<span foreground='green' background='white'>" + name + "</span>";
1048                rowSrc[m_orderColumns.m_col_markup] = markup;
1049            }
1050            {
1051                Glib::ustring name = rowDst[m_orderColumns.m_col_name];
1052                Glib::ustring markup =
1053                    "<span foreground='black' background='white'>" + ToString(iSrc+1) + ".</span>\n<span foreground='green' background='white'>" + name + "</span>";
1054                rowDst[m_orderColumns.m_col_markup] = markup;
1055            }
1056        }
1057    }
1058    
1059    void CombineInstrumentsDialog::setSelectedInstruments(const std::set<int>& instrumentIndeces) {
1060        typedef Gtk::TreeModel::Children Children;
1061        Children children = m_refTreeModel->children();
1062        for (Children::iterator iter = children.begin();
1063             iter != children.end(); ++iter)
1064        {
1065            Gtk::TreeModel::Row row = *iter;
1066            int index = row[m_columns.m_col_index];
1067            if (instrumentIndeces.count(index))
1068                m_treeView.get_selection()->select(iter);
1069        }
1070    }
1071    
1072  void CombineInstrumentsDialog::combineSelectedInstruments() {  void CombineInstrumentsDialog::combineSelectedInstruments() {
1073      std::vector<gig::Instrument*> instruments;      std::vector<gig::Instrument*> instruments;
1074      std::vector<Gtk::TreeModel::Path> v = m_treeView.get_selection()->get_selected_rows();      {
1075      for (uint i = 0; i < v.size(); ++i) {          typedef Gtk::TreeModel::Children Children;
1076          Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(v[i]);          int i = 0;
1077          Gtk::TreeModel::Row row = *it;          Children selection = m_refOrderModel->children();
1078          Glib::ustring name = row[m_columns.m_col_name];          for (Children::iterator it = selection.begin();
1079          gig::Instrument* instrument = row[m_columns.m_col_instr];               it != selection.end(); ++it, ++i)
1080          #if DEBUG_COMBINE_INSTRUMENTS          {
1081          printf("Selection '%s' 0x%lx\n\n", name.c_str(), int64_t((void*)instrument));              Gtk::TreeModel::Row row = *it;
1082          #endif              Glib::ustring name = row[m_orderColumns.m_col_name];
1083          instruments.push_back(instrument);              gig::Instrument* instrument = row[m_orderColumns.m_col_instr];
1084                #if DEBUG_COMBINE_INSTRUMENTS
1085                printf("Selection %d. '%s' %p\n\n", (i+1), name.c_str(), instrument));
1086                #endif
1087                instruments.push_back(instrument);
1088            }
1089      }      }
1090    
1091      g_warnings.clear();      g_warnings.clear();
# Line 947  void CombineInstrumentsDialog::combineSe Line 1102  void CombineInstrumentsDialog::combineSe
1102              mainDimension = static_cast<gig::dimension_t>(iTypeID);              mainDimension = static_cast<gig::dimension_t>(iTypeID);
1103          }          }
1104    
1105          // now start the actual cobination task ...          // now start the actual combination task ...
1106          combineInstruments(instruments, m_gig, m_newCombinedInstrument, mainDimension);          combineInstruments(instruments, m_gig, m_newCombinedInstrument, mainDimension);
1107      } catch (RIFF::Exception e) {;      } catch (RIFF::Exception e) {;
1108          Gtk::MessageDialog msg(*this, e.Message, false, Gtk::MESSAGE_ERROR);          Gtk::MessageDialog msg(*this, e.Message, false, Gtk::MESSAGE_ERROR);
# Line 987  void CombineInstrumentsDialog::combineSe Line 1142  void CombineInstrumentsDialog::combineSe
1142  void CombineInstrumentsDialog::onSelectionChanged() {  void CombineInstrumentsDialog::onSelectionChanged() {
1143      std::vector<Gtk::TreeModel::Path> v = m_treeView.get_selection()->get_selected_rows();      std::vector<Gtk::TreeModel::Path> v = m_treeView.get_selection()->get_selected_rows();
1144      m_OKButton.set_sensitive(v.size() >= 2);      m_OKButton.set_sensitive(v.size() >= 2);
1145    
1146        typedef Gtk::TreeModel::Children Children;
1147    
1148        // update horizontal selection list (icon view) ...
1149    
1150        // remove items which are not part of the new selection anymore
1151        {
1152            Children allOrdered = m_refOrderModel->children();
1153            for (Children::iterator itOrder = allOrdered.begin();
1154                 itOrder != allOrdered.end(); ++itOrder)
1155            {
1156                Gtk::TreeModel::Row rowOrder = *itOrder;
1157                gig::Instrument* instr = rowOrder[m_orderColumns.m_col_instr];
1158                for (uint i = 0; i < v.size(); ++i) {
1159                    Gtk::TreeModel::iterator itSel = m_refTreeModel->get_iter(v[i]);
1160                    Gtk::TreeModel::Row rowSel = *itSel;
1161                    if (rowSel[m_columns.m_col_instr] == instr)
1162                        goto nextOrderedItem;
1163                }
1164                goto removeOrderedItem;
1165            nextOrderedItem:
1166                continue;
1167            removeOrderedItem:
1168                m_refOrderModel->erase(itOrder);
1169            }
1170        }
1171    
1172        // add items newly added to the selection
1173        for (uint i = 0; i < v.size(); ++i) {
1174            Gtk::TreeModel::iterator itSel = m_refTreeModel->get_iter(v[i]);
1175            Gtk::TreeModel::Row rowSel = *itSel;
1176            gig::Instrument* instr = rowSel[m_columns.m_col_instr];
1177            Children allOrdered = m_refOrderModel->children();
1178            for (Children::iterator itOrder = allOrdered.begin();
1179                 itOrder != allOrdered.end(); ++itOrder)
1180            {
1181                Gtk::TreeModel::Row rowOrder = *itOrder;
1182                if (rowOrder[m_orderColumns.m_col_instr] == instr)
1183                    goto nextSelectionItem;
1184            }
1185            goto addNewSelectionItem;
1186        nextSelectionItem:
1187            continue;
1188        addNewSelectionItem:
1189            Glib::ustring name = gig_to_utf8(instr->pInfo->Name);
1190            Gtk::TreeModel::iterator iterOrder = m_refOrderModel->append();
1191            Gtk::TreeModel::Row rowOrder = *iterOrder;
1192            rowOrder[m_orderColumns.m_col_name] = name;
1193            rowOrder[m_orderColumns.m_col_instr] = instr;
1194        }
1195    
1196        // update markup
1197        {
1198            int i = 0;
1199            Children allOrdered = m_refOrderModel->children();
1200            for (Children::iterator itOrder = allOrdered.begin();
1201                 itOrder != allOrdered.end(); ++itOrder, ++i)
1202            {
1203                Gtk::TreeModel::Row rowOrder = *itOrder;
1204                Glib::ustring name = rowOrder[m_orderColumns.m_col_name];
1205                Glib::ustring markup =
1206                    "<span foreground='black' background='white'>" + ToString(i+1) + ".</span>\n<span foreground='green' background='white'>" + name + "</span>";
1207                rowOrder[m_orderColumns.m_col_markup] = markup;
1208            }
1209        }
1210  }  }
1211    
1212  bool CombineInstrumentsDialog::fileWasChanged() const {  bool CombineInstrumentsDialog::fileWasChanged() const {
Legend:
Removed from v.2579  
changed lines
  Added in v.3300
  ViewVC Help
Powered by ViewVC