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

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

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

revision 1225 by schoenebeck, Sun Jun 10 10:56:11 2007 UTC revision 2507 by persson, Sun Jan 12 19:37:55 2014 UTC
# Line 1  Line 1 
1  /*                                                         -*- c++ -*-  /*
2   * Copyright (C) 2006, 2007 Andreas Persson   * Copyright (C) 2006-2014 Andreas Persson
3   *   *
4   * This program is free software; you can redistribute it and/or   * This program is free software; you can redistribute it and/or
5   * modify it under the terms of the GNU General Public License as   * modify it under the terms of the GNU General Public License as
# Line 23  Line 23 
23  #include <gtkmm/messagedialog.h>  #include <gtkmm/messagedialog.h>
24  #include <gtkmm/dialog.h>  #include <gtkmm/dialog.h>
25  #include <gtkmm/comboboxtext.h>  #include <gtkmm/comboboxtext.h>
26    #include <gtkmm/spinbutton.h>
27    #include <gtkmm/table.h>
28    
29    #include "global.h"
30    #include "compat.h"
31    
32  // returns a human readable name of the given dimension type  // returns a human readable name of the given dimension type
33  static Glib::ustring __dimTypeAsString(gig::dimension_t d) {  static Glib::ustring __dimTypeAsString(gig::dimension_t d) {
34      char buf[32];      char buf[32];
35      switch (d) {      switch (d) {
36          case gig::dimension_none:          case gig::dimension_none:
37              return "None";              return _("None");
38          case gig::dimension_samplechannel:          case gig::dimension_samplechannel:
39              return "Sample Channel";              return _("Sample Channel");
40          case gig::dimension_layer:          case gig::dimension_layer:
41              return "Layer";              return _("Layer");
42          case gig::dimension_velocity:          case gig::dimension_velocity:
43              return "Velocity";              return _("Velocity");
44          case gig::dimension_channelaftertouch:          case gig::dimension_channelaftertouch:
45              return "Aftertouch";              return _("Aftertouch");
46          case gig::dimension_releasetrigger:          case gig::dimension_releasetrigger:
47              return "Release Trigger";              return _("Release Trigger");
48          case gig::dimension_keyboard:          case gig::dimension_keyboard:
49              return "Keyswitching";              return _("Keyswitching");
50          case gig::dimension_roundrobin:          case gig::dimension_roundrobin:
51              return "Round Robin";              return _("Round Robin");
52          case gig::dimension_random:          case gig::dimension_random:
53              return "Random Generator";              return _("Random Generator");
54          case gig::dimension_smartmidi:          case gig::dimension_smartmidi:
55              return "Smart MIDI";              return _("Smart MIDI");
56          case gig::dimension_roundrobinkeyboard:          case gig::dimension_roundrobinkeyboard:
57              return "Keyboard Round Robin";              return _("Keyboard Round Robin");
58          case gig::dimension_modwheel:          case gig::dimension_modwheel:
59              return "Modulation Wheel";              return _("Modulation Wheel");
60          case gig::dimension_breath:          case gig::dimension_breath:
61              return "Breath Ctrl.";              return _("Breath Ctrl.");
62          case gig::dimension_foot:          case gig::dimension_foot:
63              return "Foot Ctrl.";              return _("Foot Ctrl.");
64          case gig::dimension_portamentotime:          case gig::dimension_portamentotime:
65              return "Portamento Time Ctrl.";              return _("Portamento Time Ctrl.");
66          case gig::dimension_effect1:          case gig::dimension_effect1:
67              return "Effect Ctrl. 1";              return _("Effect Ctrl. 1");
68          case gig::dimension_effect2:          case gig::dimension_effect2:
69              return "Effect Ctrl. 2";              return _("Effect Ctrl. 2");
70          case gig::dimension_genpurpose1:          case gig::dimension_genpurpose1:
71              return "General Purpose Ctrl. 1";              return _("General Purpose Ctrl. 1");
72          case gig::dimension_genpurpose2:          case gig::dimension_genpurpose2:
73              return "General Purpose Ctrl. 2";              return _("General Purpose Ctrl. 2");
74          case gig::dimension_genpurpose3:          case gig::dimension_genpurpose3:
75              return "General Purpose Ctrl. 3";              return _("General Purpose Ctrl. 3");
76          case gig::dimension_genpurpose4:          case gig::dimension_genpurpose4:
77              return "General Purpose Ctrl. 4";              return _("General Purpose Ctrl. 4");
78          case gig::dimension_sustainpedal:          case gig::dimension_sustainpedal:
79              return "Sustain Pedal";              return _("Sustain Pedal");
80          case gig::dimension_portamento:          case gig::dimension_portamento:
81              return "Portamento Ctrl.";              return _("Portamento Ctrl.");
82          case gig::dimension_sostenutopedal:          case gig::dimension_sostenutopedal:
83              return "Sostenuto Pedal";              return _("Sostenuto Pedal");
84          case gig::dimension_softpedal:          case gig::dimension_softpedal:
85              return "Soft Pedal";              return _("Soft Pedal");
86          case gig::dimension_genpurpose5:          case gig::dimension_genpurpose5:
87              return "General Purpose Ctrl. 5";              return _("General Purpose Ctrl. 5");
88          case gig::dimension_genpurpose6:          case gig::dimension_genpurpose6:
89              return "General Purpose Ctrl. 6";              return _("General Purpose Ctrl. 6");
90          case gig::dimension_genpurpose7:          case gig::dimension_genpurpose7:
91              return "General Purpose Ctrl. 7";              return _("General Purpose Ctrl. 7");
92          case gig::dimension_genpurpose8:          case gig::dimension_genpurpose8:
93              return "General Purpose Ctrl. 8";              return _("General Purpose Ctrl. 8");
94          case gig::dimension_effect1depth:          case gig::dimension_effect1depth:
95              return "Effect 1 Depth";              return _("Effect 1 Depth");
96          case gig::dimension_effect2depth:          case gig::dimension_effect2depth:
97              return "Effect 2 Depth";              return _("Effect 2 Depth");
98          case gig::dimension_effect3depth:          case gig::dimension_effect3depth:
99              return "Effect 3 Depth";              return _("Effect 3 Depth");
100          case gig::dimension_effect4depth:          case gig::dimension_effect4depth:
101              return "Effect 4 Depth";              return _("Effect 4 Depth");
102          case gig::dimension_effect5depth:          case gig::dimension_effect5depth:
103              return "Effect 5 Depth";              return _("Effect 5 Depth");
104          default:          default:
105              sprintf(buf, "Unknown Type (0x%x) !!!", d);              sprintf(buf, "Unknown Type (0x%x) !!!", d);
106              return buf;              return buf;
# Line 106  static Glib::ustring __dimTypeAsString(g Line 111  static Glib::ustring __dimTypeAsString(g
111  static Glib::ustring __dimDescriptionAsString(gig::dimension_t d) {  static Glib::ustring __dimDescriptionAsString(gig::dimension_t d) {
112      switch (d) {      switch (d) {
113          case gig::dimension_none:          case gig::dimension_none:
114              return "Dimension not in use";              return _("Dimension not in use");
115          case gig::dimension_samplechannel:          case gig::dimension_samplechannel:
116              return "If used sample has more than one channel (thus is not mono)";              return _("If used sample has more than one channel (thus is not mono)");
117          case gig::dimension_layer:          case gig::dimension_layer:
118              return "For layering of up to 8 instruments (and eventually crossfading of 2 or 4 layers";              return _("For layering of up to 8 instruments (and eventually crossfading of 2 or 4 layers");
119          case gig::dimension_velocity:          case gig::dimension_velocity:
120              return "Key Velocity (this is the only dimension in gig2 where the ranges can exactly be defined)";              return _("Key Velocity (this is the only dimension in gig2 where the ranges can exactly be defined)");
121          case gig::dimension_channelaftertouch:          case gig::dimension_channelaftertouch:
122              return "Channel Key Pressure";              return _("Channel Key Pressure");
123          case gig::dimension_releasetrigger:          case gig::dimension_releasetrigger:
124              return "Special dimension for triggering samples on releasing a key";              return _("Special dimension for triggering samples on releasing a key");
125          case gig::dimension_keyboard:          case gig::dimension_keyboard:
126              return "Dimension for keyswitching (keyboard)";              return _("Dimension for keyswitching (keyboard)");
127          case gig::dimension_roundrobin:          case gig::dimension_roundrobin:
128              return "Different samples triggered each time a note is played, dimension regions selected in sequence";              return _("Different samples triggered each time a note is played, dimension regions selected in sequence");
129          case gig::dimension_random:          case gig::dimension_random:
130              return "Different samples triggered each time a note is played, random order";              return _("Different samples triggered each time a note is played, random order");
131          case gig::dimension_smartmidi:          case gig::dimension_smartmidi:
132              return "For MIDI tools like legato and repetition mode";              return _("For MIDI tools like legato and repetition mode");
133          case gig::dimension_roundrobinkeyboard:          case gig::dimension_roundrobinkeyboard:
134              return "Different samples triggered each time a note is played, any key advances the counter";              return _("Different samples triggered each time a note is played, any key advances the counter");
135          case gig::dimension_modwheel:          case gig::dimension_modwheel:
136              return "MIDI Controller 1";              return _("MIDI Controller 1");
137          case gig::dimension_breath:          case gig::dimension_breath:
138              return "MIDI Controller 2";              return _("MIDI Controller 2");
139          case gig::dimension_foot:          case gig::dimension_foot:
140              return "MIDI Controller 4";              return _("MIDI Controller 4");
141          case gig::dimension_portamentotime:          case gig::dimension_portamentotime:
142              return "MIDI Controller 5";              return _("MIDI Controller 5");
143          case gig::dimension_effect1:          case gig::dimension_effect1:
144              return "MIDI Controller 12";              return _("MIDI Controller 12");
145          case gig::dimension_effect2:          case gig::dimension_effect2:
146              return "MIDI Controller 13";              return _("MIDI Controller 13");
147          case gig::dimension_genpurpose1:          case gig::dimension_genpurpose1:
148              return "Slider, MIDI Controller 16";              return _("Slider, MIDI Controller 16");
149          case gig::dimension_genpurpose2:          case gig::dimension_genpurpose2:
150              return "Slider, MIDI Controller 17";              return _("Slider, MIDI Controller 17");
151          case gig::dimension_genpurpose3:          case gig::dimension_genpurpose3:
152              return "Slider, MIDI Controller 18";              return _("Slider, MIDI Controller 18");
153          case gig::dimension_genpurpose4:          case gig::dimension_genpurpose4:
154              return "Slider, MIDI Controller 19";              return _("Slider, MIDI Controller 19");
155          case gig::dimension_sustainpedal:          case gig::dimension_sustainpedal:
156              return "MIDI Controller 64";              return _("MIDI Controller 64");
157          case gig::dimension_portamento:          case gig::dimension_portamento:
158              return "MIDI Controller 65";              return _("MIDI Controller 65");
159          case gig::dimension_sostenutopedal:          case gig::dimension_sostenutopedal:
160              return "MIDI Controller 66";              return _("MIDI Controller 66");
161          case gig::dimension_softpedal:          case gig::dimension_softpedal:
162              return "MIDI Controller 67";              return _("MIDI Controller 67");
163          case gig::dimension_genpurpose5:          case gig::dimension_genpurpose5:
164              return "Button, MIDI Controller 80";              return _("Button, MIDI Controller 80");
165          case gig::dimension_genpurpose6:          case gig::dimension_genpurpose6:
166              return "Button, MIDI Controller 81";              return _("Button, MIDI Controller 81");
167          case gig::dimension_genpurpose7:          case gig::dimension_genpurpose7:
168              return "Button, MIDI Controller 82";              return _("Button, MIDI Controller 82");
169          case gig::dimension_genpurpose8:          case gig::dimension_genpurpose8:
170              return "Button, MIDI Controller 83";              return _("Button, MIDI Controller 83");
171          case gig::dimension_effect1depth:          case gig::dimension_effect1depth:
172              return "MIDI Controller 91";              return _("MIDI Controller 91");
173          case gig::dimension_effect2depth:          case gig::dimension_effect2depth:
174              return "MIDI Controller 92";              return _("MIDI Controller 92");
175          case gig::dimension_effect3depth:          case gig::dimension_effect3depth:
176              return "MIDI Controller 93";              return _("MIDI Controller 93");
177          case gig::dimension_effect4depth:          case gig::dimension_effect4depth:
178              return "MIDI Controller 94";              return _("MIDI Controller 94");
179          case gig::dimension_effect5depth:          case gig::dimension_effect5depth:
180              return "MIDI Controller 95";              return _("MIDI Controller 95");
181          default:          default:
182              return "Please report this !!!";              return _("Please report this !!!");
183      }      }
184  }  }
185    
186  DimensionManager::DimensionManager() :  DimensionManager::DimensionManager() :
187  addButton(Gtk::Stock::ADD), removeButton(Gtk::Stock::REMOVE)  addButton(Gtk::Stock::ADD), removeButton(Gtk::Stock::REMOVE)
188  {  {
189      set_title("Dimensions of selected Region");      set_title(_("Dimensions of selected Region"));
190      add(vbox);      add(vbox);
191      scrolledWindow.add(treeView);      scrolledWindow.add(treeView);
192      vbox.pack_start(scrolledWindow);      vbox.pack_start(scrolledWindow);
193      scrolledWindow.show();      scrolledWindow.show();
194      vbox.pack_start(buttonBox);      vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);
195      buttonBox.set_layout(Gtk::BUTTONBOX_END);      buttonBox.set_layout(Gtk::BUTTONBOX_END);
196      buttonBox.set_border_width(5);      buttonBox.set_border_width(5);
197      buttonBox.show();      buttonBox.show();
198      buttonBox.pack_start(addButton);      buttonBox.pack_start(addButton, Gtk::PACK_SHRINK);
199      buttonBox.pack_start(removeButton);      buttonBox.pack_start(removeButton, Gtk::PACK_SHRINK);
200      addButton.show();      addButton.show();
201      removeButton.show();      removeButton.show();
202    
203      // setup the table      // setup the table
204      refTableModel = Gtk::ListStore::create(tableModel);      refTableModel = Gtk::ListStore::create(tableModel);
205      treeView.set_model(refTableModel);      treeView.set_model(refTableModel);
206      treeView.append_column("Dimension Type", tableModel.m_dim_type);      treeView.append_column(_("Dimension Type"), tableModel.m_dim_type);
207      treeView.append_column_numeric("Bits", tableModel.m_bits, "%d");      treeView.append_column(_("Bits"), tableModel.m_bits);
208      treeView.append_column_numeric("Zones", tableModel.m_zones, "%d");      treeView.append_column(_("Zones"), tableModel.m_zones);
209      treeView.append_column("Description", tableModel.m_description);      treeView.append_column(_("Description"), tableModel.m_description);
210      treeView.show();      treeView.show();
211    
212      addButton.signal_clicked().connect(      addButton.signal_clicked().connect(
# Line 218  addButton(Gtk::Stock::ADD), removeButton Line 223  addButton(Gtk::Stock::ADD), removeButton
223  // update all GUI elements according to current gig::Region informations  // update all GUI elements according to current gig::Region informations
224  void DimensionManager::refreshManager() {  void DimensionManager::refreshManager() {
225      refTableModel->clear();      refTableModel->clear();
226      for (int i = 0; i < region->Dimensions; i++) {      if (region) {
227          gig::dimension_def_t* dim = &region->pDimensionDefinitions[i];          for (int i = 0; i < region->Dimensions; i++) {
228          Gtk::TreeModel::Row row = *(refTableModel->append());              gig::dimension_def_t* dim = &region->pDimensionDefinitions[i];
229          row[tableModel.m_dim_type] = __dimTypeAsString(dim->dimension);              Gtk::TreeModel::Row row = *(refTableModel->append());
230          row[tableModel.m_bits] = dim->bits;              row[tableModel.m_dim_type] = __dimTypeAsString(dim->dimension);
231          row[tableModel.m_zones] = 1 << dim->bits; //TODO: for now we calculate it here until libgig always ensures 'zones' to be correct              row[tableModel.m_bits] = dim->bits;
232          row[tableModel.m_description] = __dimDescriptionAsString(dim->dimension);              row[tableModel.m_zones] = dim->zones;
233          row[tableModel.m_definition] = dim;              row[tableModel.m_description] = __dimDescriptionAsString(dim->dimension);
234                row[tableModel.m_definition] = dim;
235            }
236      }      }
237        set_sensitive(region);
238  }  }
239    
240  void DimensionManager::show(gig::Region* region) {  void DimensionManager::show(gig::Region* region) {
# Line 236  void DimensionManager::show(gig::Region* Line 244  void DimensionManager::show(gig::Region*
244      deiconify();      deiconify();
245  }  }
246    
247    void DimensionManager::set_region(gig::Region* region) {
248        this->region = region;
249        refreshManager();
250    }
251    
252  void DimensionManager::addDimension() {  void DimensionManager::addDimension() {
253      try {      try {
254          Gtk::Dialog dialog("New Dimension", true /*modal*/);          Gtk::Dialog dialog(_("New Dimension"), true /*modal*/);
255          // add dimension type combo box to the dialog          // add dimension type combo box to the dialog
256          Glib::RefPtr<Gtk::ListStore> refComboModel = Gtk::ListStore::create(comboModel);          Glib::RefPtr<Gtk::ListStore> refComboModel = Gtk::ListStore::create(comboModel);
257          for (int i = 0x01; i < 0xff; i++) {          for (int i = 0x01; i < 0xff; i++) {
# Line 250  void DimensionManager::addDimension() { Line 263  void DimensionManager::addDimension() {
263                  row[comboModel.m_type_name] = sType;                  row[comboModel.m_type_name] = sType;
264              }              }
265          }          }
266            Gtk::Table table(2, 2);
267            Gtk::Label labelDimType(_("Dimension:"), Gtk::ALIGN_START);
268          Gtk::ComboBox comboDimType;          Gtk::ComboBox comboDimType;
269          comboDimType.set_model(refComboModel);          comboDimType.set_model(refComboModel);
270          comboDimType.pack_start(comboModel.m_type_id);          comboDimType.pack_start(comboModel.m_type_id);
271          comboDimType.pack_start(comboModel.m_type_name);          comboDimType.pack_start(comboModel.m_type_name);
272          dialog.get_vbox()->pack_start(comboDimType);          Gtk::Label labelZones(_("Zones:"), Gtk::ALIGN_START);
273          comboDimType.show();          table.attach(labelDimType, 0, 1, 0, 1);
274          // add zones combo box to the dialog          table.attach(comboDimType, 1, 2, 0, 1);
275            table.attach(labelZones, 0, 1, 1, 2);
276            dialog.get_vbox()->pack_start(table);
277    
278            // number of zones: use a combo box with fix values for gig
279            // v2 and a spin button for v3
280          Gtk::ComboBoxText comboZones;          Gtk::ComboBoxText comboZones;
281          for (int i = 1; i <= 7; i++) { //FIXME: is 7 the correct amount of max. bits ???          Gtk::SpinButton spinZones;
282              char buf[64];          bool version2 = false;
283              sprintf(buf, "%d Zones (%d Bits)", 1 << i, i);          if (region) {
284              comboZones.append_text(buf);              gig::File* file = (gig::File*)region->GetParent()->GetParent();
285                version2 = file->pVersion && file->pVersion->major == 2;
286          }          }
287          dialog.get_vbox()->pack_start(comboZones);          if (version2) {
288          comboZones.show();              for (int i = 1; i <= 5; i++) {
289          // add OK and CANCEL buttons to the dialog                  char buf[3];
290                    sprintf(buf, "%d", 1 << i);
291    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 24) || GTKMM_MAJOR_VERSION < 2
292                    comboZones.append_text(buf);
293    #else
294                    comboZones.append(buf);
295    #endif
296                }
297                table.attach(comboZones, 1, 2, 1, 2);
298            } else {
299                spinZones.set_increments(1, 8);
300                spinZones.set_numeric(true);
301                spinZones.set_range(2, 128);
302                spinZones.set_value(2);
303                table.attach(spinZones, 1, 2, 1, 2);
304            }
305    
306          dialog.add_button(Gtk::Stock::OK, 0);          dialog.add_button(Gtk::Stock::OK, 0);
307          dialog.add_button(Gtk::Stock::CANCEL, 1);          dialog.add_button(Gtk::Stock::CANCEL, 1);
308          dialog.show_all_children();          dialog.show_all_children();
309    
310          if (!dialog.run()) { // OK selected ...          if (!dialog.run()) { // OK selected ...
311              Gtk::TreeModel::iterator iterType = comboDimType.get_active();              Gtk::TreeModel::iterator iterType = comboDimType.get_active();
312              if (!iterType) return;              if (!iterType) return;
# Line 277  void DimensionManager::addDimension() { Line 315  void DimensionManager::addDimension() {
315              gig::dimension_def_t dim;              gig::dimension_def_t dim;
316              int iTypeID = rowType[comboModel.m_type_id];              int iTypeID = rowType[comboModel.m_type_id];
317              dim.dimension = static_cast<gig::dimension_t>(iTypeID);              dim.dimension = static_cast<gig::dimension_t>(iTypeID);
318              if (comboZones.get_active_row_number() < 0) return;  
319              dim.bits = comboZones.get_active_row_number() + 1;              if (version2) {
320              dim.zones = 1 << dim.bits; //TODO: support zones != pow(2,bits) - feature of gig v3                  if (comboZones.get_active_row_number() < 0) return;
321                    dim.bits = comboZones.get_active_row_number() + 1;
322                    dim.zones = 1 << dim.bits;
323                } else {
324                    dim.zones = spinZones.get_value_as_int();
325                    // Find the number of bits required to hold the
326                    // specified amount of zones.
327                    int zoneBits = dim.zones - 1;
328                    for (dim.bits = 0; zoneBits > 1; dim.bits += 2, zoneBits >>= 2);
329                    dim.bits += zoneBits;
330                }
331              printf(              printf(
332                  "Adding dimension (type=0x%x, bits=%d, zones=%d)\n",                  "Adding dimension (type=0x%x, bits=%d, zones=%d)\n",
333                  dim.dimension, dim.bits, dim.zones                  dim.dimension, dim.bits, dim.zones
334              );              );
335                // notify everybody that we're going to update the region
336                region_to_be_changed_signal.emit(region);
337              // add the new dimension to the region              // add the new dimension to the region
338              // (implicitly creates new dimension regions)              // (implicitly creates new dimension regions)
339              region->AddDimension(&dim);              region->AddDimension(&dim);
340              // let everybody know there was a change              // let everybody know there was a change
341              articulation_changed_signal.emit();              region_changed_signal.emit(region);
342              // update all GUI elements              // update all GUI elements
343              refreshManager();              refreshManager();
344          }          }
345      } catch (RIFF::Exception e) {      } catch (RIFF::Exception e) {
346          Glib::ustring txt = "Could not add dimension: " + e.Message;          // notify that the changes are over (i.e. to avoid dead locks)
347            region_changed_signal.emit(region);
348            // show error message
349            Glib::ustring txt = _("Could not add dimension: ") + e.Message;
350          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
351          msg.run();          msg.run();
352      }      }
# Line 304  void DimensionManager::removeDimension() Line 357  void DimensionManager::removeDimension()
357      Gtk::TreeModel::iterator it = sel->get_selected();      Gtk::TreeModel::iterator it = sel->get_selected();
358      if (it) {      if (it) {
359          try {          try {
360                // notify everybody that we're going to update the region
361                region_to_be_changed_signal.emit(region);
362              // remove selected dimension              // remove selected dimension
363              Gtk::TreeModel::Row row = *it;              Gtk::TreeModel::Row row = *it;
364              gig::dimension_def_t* dim = row[tableModel.m_definition];              gig::dimension_def_t* dim = row[tableModel.m_definition];
365              region->DeleteDimension(dim);              region->DeleteDimension(dim);
             // remove respective row from table  
             refTableModel->erase(it);  
366              // let everybody know there was a change              // let everybody know there was a change
367              articulation_changed_signal.emit();              region_changed_signal.emit(region);
368                // update all GUI elements
369                refreshManager();
370          } catch (RIFF::Exception e) {          } catch (RIFF::Exception e) {
371              Glib::ustring txt = "Could not remove dimension: " + e.Message;              // notify that the changes are over (i.e. to avoid dead locks)
372                region_changed_signal.emit(region);
373                // show error message
374                Glib::ustring txt = _("Could not remove dimension: ") + e.Message;
375              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
376              msg.run();              msg.run();
377          }          }
Legend:
Removed from v.1225  
changed lines
  Added in v.2507
  ViewVC Help
Powered by ViewVC