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

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

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

revision 2151 by persson, Sun Nov 21 12:38:41 2010 UTC revision 2695 by schoenebeck, Tue Jan 6 18:11:27 2015 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (C) 2006-2010 Andreas Persson   * Copyright (C) 2006-2015 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 20  Line 20 
20  #include "regionchooser.h"  #include "regionchooser.h"
21    
22  #include <algorithm>  #include <algorithm>
 #include <cmath>  
 #include <sstream>  
23    
24  #include <cairomm/context.h>  #include <cairomm/context.h>
25  #include <gdkmm/general.h>  #include <gdkmm/general.h>
# Line 32  Line 30 
30    
31  #include "global.h"  #include "global.h"
32    
33  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 10) || GTKMM_MAJOR_VERSION < 2  #define REGION_BLOCK_HEIGHT             30
34    #define KEYBOARD_HEIGHT                 40
 #define create_cairo_context()                                          \  
     gobj() ? Cairo::RefPtr<Cairo::Context>(                             \  
         new Cairo::Context(gdk_cairo_create(get_window()->gobj()))) :   \  
     Cairo::RefPtr<Cairo::Context>()  
   
 namespace Gdk {  
     namespace Cairo {  
         void set_source_color(const ::Cairo::RefPtr< ::Cairo::Context >& cr,  
                               const Gdk::Color& color) {  
             gdk_cairo_set_source_color(cr->cobj(),  
                                        const_cast<GdkColor*>(color.gobj()));  
         }  
     }  
 }  
 #endif  
   
 #define REGION_BLOCK_HEIGHT             20  
 #define KEYBOARD_HEIGHT                 40  
35    
36  void SortedRegions::update(gig::Instrument* instrument) {  void SortedRegions::update(gig::Instrument* instrument) {
37      // Usually, the regions in a gig file are ordered after their key      // Usually, the regions in a gig file are ordered after their key
# Line 81  gig::Region* SortedRegions::next() { Line 61  gig::Region* SortedRegions::next() {
61    
62    
63  RegionChooser::RegionChooser() :  RegionChooser::RegionChooser() :
64        activeKeyColor("red"),
65        red("#8070ff"),
66        grey1("grey69"),
67        white("white"),
68        black("black"),
69      m_VirtKeybModeChoice(_("Virtual Keyboard Mode")),      m_VirtKeybModeChoice(_("Virtual Keyboard Mode")),
70      currentActiveKey(-1)      currentActiveKey(-1)
71  {  {
72      red = Gdk::Color("#8070ff");      set_size_request(500, KEYBOARD_HEIGHT + REGION_BLOCK_HEIGHT);
     grey1 = Gdk::Color("#b0b0b0");  
     activeKeyColor = Gdk::Color("#ff0000");  
     white = Gdk::Color("#ffffff");  
     black = Gdk::Color("#000000");  
73    
74      instrument = 0;      instrument = 0;
75      region = 0;      region = 0;
# Line 99  RegionChooser::RegionChooser() : Line 80  RegionChooser::RegionChooser() :
80    
81      // properties of the virtual keyboard      // properties of the virtual keyboard
82      {      {
83          const char* choices[] = { _("normal"), _("chord"), NULL };          const char* choices[] = { _("normal"), _("chord"), 0 };
84          static const virt_keyboard_mode_t values[] = {          static const virt_keyboard_mode_t values[] = {
85              VIRT_KEYBOARD_MODE_NORMAL,              VIRT_KEYBOARD_MODE_NORMAL,
86              VIRT_KEYBOARD_MODE_CHORD              VIRT_KEYBOARD_MODE_CHORD
# Line 119  RegionChooser::RegionChooser() : Line 100  RegionChooser::RegionChooser() :
100      m_VirtKeybPropsBox.pack_start(m_VirtKeybOffVelocityLabel, Gtk::PACK_SHRINK);      m_VirtKeybPropsBox.pack_start(m_VirtKeybOffVelocityLabel, Gtk::PACK_SHRINK);
101      m_VirtKeybPropsBox.set_spacing(10);      m_VirtKeybPropsBox.set_spacing(10);
102      m_VirtKeybPropsBox.show();      m_VirtKeybPropsBox.show();
103        for (int i = 0 ; i < 128 ; i++) key_pressed[i] = false;
104    
105      actionGroup = Gtk::ActionGroup::create();      actionGroup = Gtk::ActionGroup::create();
106      actionGroup->add(Gtk::Action::create("Properties",      actionGroup->add(Gtk::Action::create("Properties",
# Line 172  RegionChooser::RegionChooser() : Line 154  RegionChooser::RegionChooser() :
154      keyboard_key_released_signal.connect(      keyboard_key_released_signal.connect(
155          sigc::mem_fun(*this, &RegionChooser::on_note_off_event)          sigc::mem_fun(*this, &RegionChooser::on_note_off_event)
156      );      );
157        set_tooltip_text(_("Right click here for adding new region. Use mouse pointer for moving (dragging) or resizing existing regions (by pointing at region's boundary). Right click on an existing region for more actions."));
158  }  }
159    
160  RegionChooser::~RegionChooser()  RegionChooser::~RegionChooser()
161  {  {
162  }  }
163    
164  template<class T> inline std::string ToString(T o) {  void RegionChooser::invalidate_key(int key) {
165      std::stringstream ss;      const int h = KEYBOARD_HEIGHT;
166      ss << o;      const int w = get_width() - 1;
167      return ss.str();      int x1 = key_to_x(key - 0.5, w);
168        int x2 = key_to_x(key + 1.5, w);
169    
170        Gdk::Rectangle rect(x1 + 1, h1 + 1, x2 - x1 - 1, h - 2);
171        get_window()->invalidate_rect(rect, false);
172  }  }
173    
174  void RegionChooser::on_note_on_event(int key, int velocity) {  void RegionChooser::on_note_on_event(int key, int velocity) {
175      draw_key(key, activeKeyColor);      key_pressed[key] = true;
176        invalidate_key(key);
177      m_VirtKeybVelocityLabel.set_text(ToString(velocity));      m_VirtKeybVelocityLabel.set_text(ToString(velocity));
178  }  }
179    
180  void RegionChooser::on_note_off_event(int key, int velocity) {  void RegionChooser::on_note_off_event(int key, int velocity) {
181      if (is_black_key(key)) {      key_pressed[key] = false;
182          draw_key(key, black);      invalidate_key(key);
     } else {  
         draw_key(key, key >= 21 && key <= 108 ? white : grey1);  
     }  
183      m_VirtKeybOffVelocityLabel.set_text(ToString(velocity));      m_VirtKeybOffVelocityLabel.set_text(ToString(velocity));
184  }  }
185    
186    
187  bool RegionChooser::on_expose_event(GdkEventExpose* event)  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
188  {  bool RegionChooser::on_expose_event(GdkEventExpose* e) {
189      Glib::RefPtr<Gdk::Window> window = get_window();      double clipx1 = e->area.x;
190      if (window) {      double clipx2 = e->area.x + e->area.width;
191          Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();      double clipy1 = e->area.y;
192          if (event) {      double clipy2 = e->area.y + e->area.height;
193              cr->rectangle(event->area.x, event->area.y,  
194                            event->area.width, event->area.height);      const Cairo::RefPtr<Cairo::Context>& cr =
195              cr->clip();          get_window()->create_cairo_context();
196          }  #if 0
197          const int h = KEYBOARD_HEIGHT;  }
198          const int w = get_width() - 1;  #endif
199          const int bh = int(h * 0.55);  #else
200    bool RegionChooser::on_draw(const Cairo::RefPtr<Cairo::Context>& cr) {
201          cr->save();      double clipx1, clipx2, clipy1, clipy2;
202          cr->set_line_width(1);      cr->get_clip_extents(clipx1, clipy1, clipx2, clipy2);
203    #endif
         const Gdk::Color bg = get_style()->get_bg(Gtk::STATE_NORMAL);  
         Gdk::Cairo::set_source_color(cr, bg);  
         cr->paint();  
204    
205          Gdk::Cairo::set_source_color(cr, black);      cr->save();
206          cr->rectangle(0.5, h1 + 0.5, w, h - 1);      cr->set_line_width(1);
207          cr->stroke();  
208    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
209        const Gdk::Color bg = get_style()->get_bg(Gtk::STATE_NORMAL);
210    #else
211        const Gdk::RGBA bg = get_style_context()->get_background_color();
212    #endif
213        Gdk::Cairo::set_source_rgba(cr, bg);
214        cr->paint();
215    
216          int x1 = int(w * 20.5 / 128.0 + 0.5);      if (clipy2 > h1) {
217          int x2 = int(w * 109.5 / 128.0 + 0.5);          draw_keyboard(cr, clipx1, clipx2);
218        }
219    
220          Gdk::Cairo::set_source_color(cr, grey1);      if (clipy1 < h1 && instrument) {
221          cr->rectangle(1, h1 + 1, x1 - 1, h - 2);          draw_regions(cr, clipx1, clipx2);
222          cr->fill();      }
223    
224          Gdk::Cairo::set_source_color(cr, white);      cr->restore();
         cr->rectangle(x1 + 1, h1 + 1, x2 - x1 - 1, h - 2);  
         cr->fill();  
225    
226          Gdk::Cairo::set_source_color(cr, grey1);      return true;
227          cr->rectangle(x2 + 1, h1 + 1, w - x2 - 1, h - 2);  }
         cr->fill();  
228    
229          Gdk::Cairo::set_source_color(cr, black);  void RegionChooser::draw_keyboard(const Cairo::RefPtr<Cairo::Context>& cr,
230          for (int i = 0 ; i < 128 ; i++) {                                    int clip_low, int clip_high) {
231              int note = (i + 3) % 12;      const int h = KEYBOARD_HEIGHT;
232              int x = int(w * i / 128.0 + 0.5);      const int w = get_width() - 1;
233        const int bh = int(h * 0.55);
             if (note == 1 || note == 4 || note == 6 ||  
                 note == 9 || note == 11) {  
                 int x2 = int(w * (i + 0.5) / 128.0 + 0.5);  
                 cr->move_to(x2 + 0.5, h1 + bh + 0.5);  
                 cr->line_to(x2 + 0.5, h1 + h - 1);  
                 cr->stroke();  
234    
235                  int x3 = int(w * (i + 1) / 128.0 + 0.5);      Gdk::Cairo::set_source_rgba(cr, black);
236                  cr->rectangle(x, h1 + 1, x3 - x + 1, bh);      cr->rectangle(0.5, h1 + 0.5, w, h - 1);
237                  cr->fill();      cr->stroke();
             } else if (note == 3 || note == 8) {  
                 cr->move_to(x + 0.5, h1 + 1);  
                 cr->line_to(x + 0.5, h1 + h - 1);  
                 cr->stroke();  
238    
239                  if (note == 3) draw_digit(i);      int x1 = key_to_x(20.5, w);
240              }      Gdk::Cairo::set_source_rgba(cr, grey1);
241        cr->rectangle(1, h1 + 1, x1 - 1, h - 2);
242        cr->fill();
243    
244        int x2 = key_to_x(109.5, w);
245        Gdk::Cairo::set_source_rgba(cr, white);
246        cr->rectangle(x1 + 1, h1 + 1, x2 - x1 - 1, h - 2);
247        cr->fill();
248    
249        Gdk::Cairo::set_source_rgba(cr, grey1);
250        cr->rectangle(x2 + 1, h1 + 1, w - x2 - 1, h - 2);
251        cr->fill();
252    
253        Gdk::Cairo::set_source_rgba(cr, black);
254    
255        int clipkey1 = std::max(0, x_to_key_right(clip_low - 1, w));
256        int clipkey2 = std::min(x_to_key_right(clip_high - 1, w) + 1, 128);
257    
258        for (int i = clipkey1 ; i < clipkey2 ; i++) {
259            int note = (i + 3) % 12;
260            int x = key_to_x(i, w);
261    
262            if (note == 1 || note == 4 || note == 6 ||
263                note == 9 || note == 11) {
264                // black key: short line in the middle, with a rectangle
265                // on top
266                int x2 = key_to_x(i + 0.5, w);
267                cr->move_to(x2 + 0.5, h1 + bh + 0.5);
268                cr->line_to(x2 + 0.5, h1 + h - 1);
269                cr->stroke();
270    
271                int x3 = key_to_x(i + 1, w);
272                cr->rectangle(x, h1 + 1, x3 - x + 1, bh);
273                cr->fill();
274            } else if (note == 3 || note == 8) {
275                // C or F: long line to the left
276                cr->move_to(x + 0.5, h1 + 1);
277                cr->line_to(x + 0.5, h1 + h - 1);
278                cr->stroke();
279          }          }
280    
281          if (instrument) {          if (key_pressed[i]) draw_key(cr, i);
282              int i = 0;  
283              gig::Region* next_region;          if (note == 3) draw_digit(cr, i);
284              int x3 = -1;      }
285              for (gig::Region* r = regions.first() ; r ; r = next_region) {  }
   
                 if (x3 < 0) x3 = int(w * (r->KeyRange.low) / 128.0 + 0.5);  
                 next_region = regions.next();  
                 if (!next_region ||  
                     r->KeyRange.high + 1 != next_region->KeyRange.low) {  
                     int x2 = int(w * (r->KeyRange.high + 1) / 128.0 + 0.5);  
                     cr->move_to(x3, 0.5);  
                     cr->line_to(x2 + 0.5, 0.5);  
                     cr->line_to(x2 + 0.5, h1 - 0.5);  
                     cr->line_to(x3, h1 - 0.5);  
                     cr->stroke();  
   
                     Gdk::Cairo::set_source_color(cr, white);  
                     cr->rectangle(x3 + 1, 1, x2 - x3 - 1, h1 - 2);  
                     cr->fill();  
                     Gdk::Cairo::set_source_color(cr, black);  
286    
                     x3 = -1;  
                 }  
                 i++;  
             }  
287    
288              for (gig::Region* r = regions.first() ; r ; r = regions.next()) {  void RegionChooser::draw_regions(const Cairo::RefPtr<Cairo::Context>& cr,
289                  int x = int(w * (r->KeyRange.low) / 128.0 + 0.5);                                   int clip_low, int clip_high) {
290                  cr->move_to(x + 0.5, 1);      const int w = get_width() - 1;
291                  cr->line_to(x + 0.5, h1 - 1);  
292        Gdk::Cairo::set_source_rgba(cr, black);
293        gig::Region* next_region;
294        int x3 = -1;
295        for (gig::Region* r = regions.first() ; r ; r = next_region) {
296            next_region = regions.next();
297    
298            if (x3 < 0) {
299                x3 = key_to_x(r->KeyRange.low, w);
300                if (x3 >= clip_high) break;
301            }
302            if (!next_region ||
303                r->KeyRange.high + 1 != next_region->KeyRange.low ||
304                r == region || next_region == region) {
305    
306                int x2 = key_to_x(r->KeyRange.high + 1, w);
307                if (x2 >= clip_low) {
308                    cr->move_to(x3, 0.5);
309                    cr->line_to(x2 + 0.5, 0.5);
310                    cr->line_to(x2 + 0.5, h1 - 0.5);
311                    cr->line_to(x3, h1 - 0.5);
312                  cr->stroke();                  cr->stroke();
             }  
313    
314              if (region) {                  Gdk::Cairo::set_source_rgba(cr, region == r ? red : white);
315                  int x1 = int(w * (region->KeyRange.low) / 128.0 + 0.5);                  cr->rectangle(x3 + 1, 1, x2 - x3 - 1, h1 - 2);
                 int x2 = int(w * (region->KeyRange.high + 1) / 128.0 + 0.5);  
                 Gdk::Cairo::set_source_color(cr, red);  
                 cr->rectangle(x1 + 1, 1, x2 - x1 - 1, h1 - 2);  
316                  cr->fill();                  cr->fill();
317                    Gdk::Cairo::set_source_rgba(cr, black);
318              }              }
319                x3 = -1;
320          }          }
   
         cr->restore();  
321      }      }
322    
323      return true;      for (gig::Region* r = regions.first() ; r ; r = regions.next()) {
324  }          int x = key_to_x(r->KeyRange.low, w);
325    
326            if (x < clip_low) continue;
327            if (x >= clip_high) break;
328    
329  void RegionChooser::on_size_request(GtkRequisition* requisition)          cr->move_to(x + 0.5, 1);
330  {          cr->line_to(x + 0.5, h1 - 1);
331      *requisition = GtkRequisition();          cr->stroke();
332      requisition->height = KEYBOARD_HEIGHT + REGION_BLOCK_HEIGHT;      }
333      requisition->width = 500;  
334        // if there is no region yet, show the user some hint text that he may
335        // right click on this area to create a new region
336        if (!regions.first()) {
337            Glib::RefPtr<Pango::Context> context = get_pango_context();
338            Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create(context);
339            layout->set_alignment(Pango::ALIGN_CENTER);
340            layout->set_text(Glib::ustring("*** ") + _("Right click here to create a region.") + " ***");
341            layout->set_width(get_width() * Pango::SCALE);
342            //layout->set_height(get_height() * Pango::SCALE);
343            layout->set_spacing(10);
344            Gdk::Cairo::set_source_rgba(cr, red);        
345            // get the text dimensions
346            Pango::Rectangle rect = layout->get_logical_extents();
347            int text_width, text_height;
348            layout->get_pixel_size(text_width, text_height);
349            cr->move_to(0, (REGION_BLOCK_HEIGHT - text_height) / 2);
350    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 16) || GTKMM_MAJOR_VERSION < 2
351            pango_cairo_show_layout(cr->cobj(), layout->gobj());
352    #else
353            layout->show_in_cairo_context(cr);
354    #endif
355        }
356  }  }
357    
358  bool RegionChooser::is_black_key(int key) {  bool RegionChooser::is_black_key(int key) {
# Line 325  bool RegionChooser::is_black_key(int key Line 360  bool RegionChooser::is_black_key(int key
360      return note == 1 || note == 4 || note == 6 || note == 9 || note == 11;      return note == 1 || note == 4 || note == 6 || note == 9 || note == 11;
361  }  }
362    
363  void RegionChooser::draw_digit(int key) {  void RegionChooser::draw_digit(const Cairo::RefPtr<Cairo::Context>& cr,
364                                   int key) {
365      const int h = KEYBOARD_HEIGHT;      const int h = KEYBOARD_HEIGHT;
366      const int w = get_width() - 1;      const int w = get_width() - 1;
367      Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create(get_pango_context());      Glib::RefPtr<Pango::Layout> layout =
368            Pango::Layout::create(get_pango_context());
369      char buf[30];      char buf[30];
370      sprintf(buf, "<span size=\"8000\">%d</span>", key / 12 - 1);      sprintf(buf, "<span size=\"8000\">%d</span>", key / 12 - 1);
371      layout->set_markup(buf);      layout->set_markup(buf);
# Line 336  void RegionChooser::draw_digit(int key) Line 373  void RegionChooser::draw_digit(int key)
373      double text_w = double(rectangle.get_width()) / Pango::SCALE;      double text_w = double(rectangle.get_width()) / Pango::SCALE;
374      double text_h = double(rectangle.get_height()) / Pango::SCALE;      double text_h = double(rectangle.get_height()) / Pango::SCALE;
375      double x = w * (key + 0.75) / 128.0;      double x = w * (key + 0.75) / 128.0;
376      Cairo::RefPtr<Cairo::Context> cr = get_window()->create_cairo_context();      Gdk::Cairo::set_source_rgba(cr, black);
     Gdk::Cairo::set_source_color(cr, black);  
377      cr->move_to(int(x - text_w / 2 + 1), int(h1 + h - text_h + 0.5));      cr->move_to(int(x - text_w / 2 + 1), int(h1 + h - text_h + 0.5));
378  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 16) || GTKMM_MAJOR_VERSION < 2  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 16) || GTKMM_MAJOR_VERSION < 2
379      pango_cairo_show_layout(cr->cobj(), layout->gobj());      pango_cairo_show_layout(cr->cobj(), layout->gobj());
# Line 346  void RegionChooser::draw_digit(int key) Line 382  void RegionChooser::draw_digit(int key)
382  #endif  #endif
383  }  }
384    
385  void RegionChooser::draw_key(int key, const Gdk::Color& color)  void RegionChooser::draw_key(const Cairo::RefPtr<Cairo::Context>& cr,
386  {                               int key) {
387      const int h = KEYBOARD_HEIGHT;      const int h = KEYBOARD_HEIGHT;
388      const int w = get_width() - 1;      const int w = get_width() - 1;
389      const int bh = int(h * 0.55);      const int bh = int(h * 0.55);
390    
391      Cairo::RefPtr<Cairo::Context> cr = get_window()->create_cairo_context();      Gdk::Cairo::set_source_rgba(cr, activeKeyColor);
     Gdk::Cairo::set_source_color(cr, color);  
392    
393      int note = (key + 3) % 12;      int note = (key + 3) % 12;
394      int x = int(w * key / 128.0 + 0.5) + 1;      int x = key_to_x(key, w) + 1;
395      int x2 = int(w * (key + 1.5) / 128.0 + 0.5);      int x2 = key_to_x(key + 1.5, w);
396      int x3 = int(w * (key + 1) / 128.0 + 0.5);      int x3 = key_to_x(key + 1, w);
397      int x4 = int(w * (key - 0.5) / 128.0 + 0.5);      int x4 = key_to_x(key - 0.5, w);
398      int w1 = x3 - x;      int w1 = x3 - x;
399      switch (note) {      switch (note) {
400      case 0: case 5: case 10:      case 0: case 5: case 10:
# Line 379  void RegionChooser::draw_key(int key, co Line 414  void RegionChooser::draw_key(int key, co
414          cr->fill();          cr->fill();
415          cr->rectangle(x, h1 + bh + 1, x2 - x, h - bh - 2);          cr->rectangle(x, h1 + bh + 1, x2 - x, h - bh - 2);
416          cr->fill();          cr->fill();
         if (note == 3) draw_digit(key);  
417          break;          break;
418      default:      default:
419          cr->rectangle(x, h1 + 1, w1, bh - 1);          cr->rectangle(x, h1 + 1, w1, bh - 1);
420          cr->fill();          cr->fill();
421          break;          break;
422      }      }
423        Gdk::Cairo::set_source_rgba(cr, black);
424  }  }
425    
426  void RegionChooser::set_instrument(gig::Instrument* instrument)  void RegionChooser::set_instrument(gig::Instrument* instrument)
# Line 400  void RegionChooser::set_instrument(gig:: Line 435  void RegionChooser::set_instrument(gig::
435    
436  bool RegionChooser::on_button_release_event(GdkEventButton* event)  bool RegionChooser::on_button_release_event(GdkEventButton* event)
437  {  {
438      const int k = int(event->x / (get_width() - 1) * 128.0);      const int k = x_to_key(event->x, get_width() - 1);
439    
440      // handle-note off on virtual keyboard      // handle-note off on virtual keyboard
441      if (event->type == GDK_BUTTON_RELEASE) {      if (event->type == GDK_BUTTON_RELEASE) {
# Line 423  bool RegionChooser::on_button_release_ev Line 458  bool RegionChooser::on_button_release_ev
458      }      }
459    
460      if (resize.active) {      if (resize.active) {
461    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
462          get_window()->pointer_ungrab(event->time);          get_window()->pointer_ungrab(event->time);
463    #else
464            Glib::wrap(event->device, true)->ungrab(event->time);
465    #endif
466          resize.active = false;          resize.active = false;
467    
         if (resize.mode == resize.moving_high_limit) {  
             if (resize.region->KeyRange.high != resize.pos - 1) {  
                 instrument_struct_to_be_changed_signal.emit(instrument);  
                 resize.region->SetKeyRange(  
                     resize.region->KeyRange.low, // low  
                     resize.pos - 1 // high  
                 );  
                 regions.update(instrument);  
                 instrument_changed.emit();  
                 instrument_struct_changed_signal.emit(instrument);  
             }  
         } else if (resize.mode == resize.moving_low_limit) {  
             if (resize.region->KeyRange.low != resize.pos) {  
                 instrument_struct_to_be_changed_signal.emit(instrument);  
                 resize.region->SetKeyRange(  
                     resize.pos, // low  
                     resize.region->KeyRange.high // high  
                 );  
                 regions.update(instrument);  
                 instrument_changed.emit();  
                 instrument_struct_changed_signal.emit(instrument);  
             }  
         }  
   
468          if (!is_in_resize_zone(event->x, event->y) && cursor_is_resize) {          if (!is_in_resize_zone(event->x, event->y) && cursor_is_resize) {
469              get_window()->set_cursor();              get_window()->set_cursor();
470              cursor_is_resize = false;              cursor_is_resize = false;
471          }          }
472      } else if (move.active) {      } else if (move.active) {
473    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
474          get_window()->pointer_ungrab(event->time);          get_window()->pointer_ungrab(event->time);
475    #else
476            Glib::wrap(event->device, true)->ungrab(event->time);
477    #endif
478          move.active = false;          move.active = false;
479    
480          if (move.pos) {          if (is_in_resize_zone(event->x, event->y)) {
481    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
482                get_window()->set_cursor(Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW));
483    #else
484                get_window()->set_cursor(Gdk::Cursor::create(Gdk::SB_H_DOUBLE_ARROW));
485    #endif
486                cursor_is_resize = true;
487            }
488        }
489        return true;
490    }
491    
492    void RegionChooser::update_after_resize()
493    {
494        if (resize.mode == resize.moving_high_limit) {
495            if (resize.region->KeyRange.high != resize.pos - 1) {
496              instrument_struct_to_be_changed_signal.emit(instrument);              instrument_struct_to_be_changed_signal.emit(instrument);
497              region->SetKeyRange(              resize.region->SetKeyRange(resize.region->KeyRange.low,
498                  region->KeyRange.low  + move.pos,                                         resize.pos - 1);
                 region->KeyRange.high + move.pos  
             );  
499              regions.update(instrument);              regions.update(instrument);
500              instrument_changed.emit();              instrument_changed.emit();
501              instrument_struct_changed_signal.emit(instrument);              instrument_struct_changed_signal.emit(instrument);
502          }          }
503        } else if (resize.mode == resize.moving_low_limit) {
504          if (is_in_resize_zone(event->x, event->y)) {          if (resize.region->KeyRange.low != resize.pos) {
505              get_window()->set_cursor(Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW));              instrument_struct_to_be_changed_signal.emit(instrument);
506              cursor_is_resize = true;              resize.region->SetKeyRange(resize.pos,
507                                           resize.region->KeyRange.high);
508                regions.update(instrument);
509                instrument_changed.emit();
510                instrument_struct_changed_signal.emit(instrument);
511          }          }
512      }      }
513      return true;  }
514    
515    void RegionChooser::update_after_move(int pos)
516    {
517        instrument_struct_to_be_changed_signal.emit(instrument);
518        region->SetKeyRange(pos, pos + region->KeyRange.high -
519                            region->KeyRange.low);
520        regions.update(instrument);
521        instrument_changed.emit();
522        instrument_struct_changed_signal.emit(instrument);
523  }  }
524    
525  bool RegionChooser::on_button_press_event(GdkEventButton* event)  bool RegionChooser::on_button_press_event(GdkEventButton* event)
526  {  {
527      if (!instrument) return true;      if (!instrument) return true;
528    
529      const int k = int(event->x / (get_width() - 1) * 128.0);      const int w = get_width() - 1;
530        const int k = x_to_key(event->x, w);
531    
532      if (event->type == GDK_BUTTON_PRESS) {      if (event->type == GDK_BUTTON_PRESS) {
533          if (event->y >= REGION_BLOCK_HEIGHT) {          if (event->y >= REGION_BLOCK_HEIGHT) {
# Line 492  bool RegionChooser::on_button_press_even Line 538  bool RegionChooser::on_button_press_even
538          }          }
539      }      }
540    
541        // left mouse button double click
542        if (event->type == GDK_2BUTTON_PRESS && event->button == 1) {
543            if (event->y < REGION_BLOCK_HEIGHT) {
544                // show dimension manager dialog for this region
545                manage_dimensions();
546            }
547        }
548    
549      if (event->y >= REGION_BLOCK_HEIGHT) return true;      if (event->y >= REGION_BLOCK_HEIGHT) return true;
550      if (event->type == GDK_BUTTON_PRESS && event->button == 3) {      if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
551          gig::Region* r = get_region(k);          gig::Region* r = get_region(k);
# Line 507  bool RegionChooser::on_button_press_even Line 561  bool RegionChooser::on_button_press_even
561          }          }
562      } else {      } else {
563          if (is_in_resize_zone(event->x, event->y)) {          if (is_in_resize_zone(event->x, event->y)) {
564    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
565              get_window()->pointer_grab(false,              get_window()->pointer_grab(false,
566                                         Gdk::BUTTON_RELEASE_MASK |                                         Gdk::BUTTON_RELEASE_MASK |
567                                         Gdk::POINTER_MOTION_MASK |                                         Gdk::POINTER_MOTION_MASK |
568                                         Gdk::POINTER_MOTION_HINT_MASK,                                         Gdk::POINTER_MOTION_HINT_MASK,
569                                         Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW), event->time);                                         Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW),
570                                           event->time);
571    #else
572                Glib::wrap(event->device, true)->grab(get_window(),
573                                                      Gdk::OWNERSHIP_NONE,
574                                                      false,
575                                                      Gdk::BUTTON_RELEASE_MASK |
576                                                      Gdk::POINTER_MOTION_MASK |
577                                                      Gdk::POINTER_MOTION_HINT_MASK,
578                                                      Gdk::Cursor::create(Gdk::SB_H_DOUBLE_ARROW),
579                                                      event->time);
580    #endif
581              resize.active = true;              resize.active = true;
582          } else {          } else {
583              gig::Region* r = get_region(k);              gig::Region* r = get_region(k);
# Line 521  bool RegionChooser::on_button_press_even Line 587  bool RegionChooser::on_button_press_even
587                  region_selected();                  region_selected();
588                  dimensionManager.set_region(region);                  dimensionManager.set_region(region);
589    
590    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
591                  get_window()->pointer_grab(false,                  get_window()->pointer_grab(false,
592                                             Gdk::BUTTON_RELEASE_MASK |                                             Gdk::BUTTON_RELEASE_MASK |
593                                             Gdk::POINTER_MOTION_MASK |                                             Gdk::POINTER_MOTION_MASK |
594                                             Gdk::POINTER_MOTION_HINT_MASK,                                             Gdk::POINTER_MOTION_HINT_MASK,
595                                             Gdk::Cursor(Gdk::FLEUR), event->time);                                             Gdk::Cursor(Gdk::FLEUR),
596                                               event->time);
597    #else
598                    Glib::wrap(event->device, true)->grab(get_window(),
599                                                          Gdk::OWNERSHIP_NONE,
600                                                          false,
601                                                          Gdk::BUTTON_RELEASE_MASK |
602                                                          Gdk::POINTER_MOTION_MASK |
603                                                          Gdk::POINTER_MOTION_HINT_MASK,
604                                                          Gdk::Cursor::create(Gdk::FLEUR),
605                                                          event->time);
606    #endif
607                  move.active = true;                  move.active = true;
608                  move.from_x = event->x;                  move.offset = event->x - key_to_x(region->KeyRange.low, w);
                 move.pos = 0;  
609              }              }
610          }          }
611      }      }
# Line 537  bool RegionChooser::on_button_press_even Line 614  bool RegionChooser::on_button_press_even
614    
615  gig::Region* RegionChooser::get_region(int key)  gig::Region* RegionChooser::get_region(int key)
616  {  {
617      gig::Region* prev_region = 0;      for (gig::Region* r = regions.first() ; r ; r = regions.next()) {
     gig::Region* next_region;  
     for (gig::Region* r = regions.first() ; r ; r = next_region) {  
         next_region = regions.next();  
   
618          if (key < r->KeyRange.low) return 0;          if (key < r->KeyRange.low) return 0;
619          if (key <= r->KeyRange.high) {          if (key <= r->KeyRange.high) return r;
             move.touch_left = prev_region && prev_region->KeyRange.high + 1 == r->KeyRange.low;  
             move.touch_right = next_region && r->KeyRange.high + 1 == next_region->KeyRange.low;  
             return r;  
         }  
         prev_region = r;  
620      }      }
621      return 0;      return 0;
622  }  }
623    
624    void RegionChooser::set_region(gig::Region* region) {
625        this->region = region;
626        queue_draw();
627        region_selected();
628        dimensionManager.set_region(region);
629    }
630    
631  void RegionChooser::motion_resize_region(int x, int y)  void RegionChooser::motion_resize_region(int x, int y)
632  {  {
633      const int w = get_width() - 1;      const int w = get_width() - 1;
# Line 563  void RegionChooser::motion_resize_region Line 638  void RegionChooser::motion_resize_region
638      else if (k > resize.max) k = resize.max;      else if (k > resize.max) k = resize.max;
639    
640      if (k != resize.pos) {      if (k != resize.pos) {
         Cairo::RefPtr<Cairo::Context> cr = get_window()->create_cairo_context();  
         cr->set_line_width(1);  
   
641          if (resize.mode == resize.undecided) {          if (resize.mode == resize.undecided) {
642              if (k < resize.pos) {              if (k < resize.pos) {
643                  // edit high limit of prev_region                  // edit high limit of prev_region
# Line 578  void RegionChooser::motion_resize_region Line 650  void RegionChooser::motion_resize_region
650                  resize.mode = resize.moving_low_limit;                  resize.mode = resize.moving_low_limit;
651              }              }
652          }          }
653          const Gdk::Color white =          resize.pos = k;
             region == resize.region ? red : get_style()->get_white();  
         const Gdk::Color bg = get_style()->get_bg(Gtk::STATE_NORMAL);  
   
         int prevx = int(w * resize.pos / 128.0 + 0.5);  
         x = int(w * k / 128.0 + 0.5);  
654    
655            int x1, x2;
656          if (resize.mode == resize.moving_high_limit) {          if (resize.mode == resize.moving_high_limit) {
657              if (k > resize.pos) {              if (resize.region->KeyRange.high < resize.pos - 1) {
658                  Gdk::Cairo::set_source_color(cr, white);                  x1 = resize.region->KeyRange.high;
659                  cr->rectangle(prevx, 1, x - prevx, h1 - 2);                  x2 = resize.pos - 1;
                 cr->fill();  
   
                 Gdk::Cairo::set_source_color(cr, black);  
                 cr->move_to(prevx, 0.5);  
                 cr->line_to(x + 1, 0.5);  
                 cr->move_to(prevx, h1 - 0.5);  
                 cr->line_to(x + 1, h1 - 0.5);  
                 cr->stroke();  
660              } else {              } else {
661                  int xx = (resize.pos == resize.max &&                  x1 = resize.pos - 1;
662                            resize.max != 128) ? 1 : 0;                  x2 = resize.region->KeyRange.high;
                 Gdk::Cairo::set_source_color(cr, bg);  
                 cr->rectangle(x + 1, 0, prevx - x - xx, h1);  
                 cr->fill();  
663              }              }
664          } else {          } else {
665              if (k < resize.pos) {              if (resize.region->KeyRange.low < resize.pos) {
666                  Gdk::Cairo::set_source_color(cr, white);                  x1 = resize.region->KeyRange.low;
667                  cr->rectangle(x + 1, 1, prevx - x, h1 - 2);                  x2 = resize.pos;
                 cr->fill();  
   
                 Gdk::Cairo::set_source_color(cr, black);  
                 cr->move_to(x, 0.5);  
                 cr->line_to(prevx, 0.5);  
                 cr->move_to(x, h1 - 0.5);  
                 cr->line_to(prevx, h1 - 0.5);  
                 cr->stroke();  
668              } else {              } else {
669                  int xx = (resize.pos == resize.min &&                  x1 = resize.pos;
670                            resize.min != 0) ? 1 : 0;                  x2 = resize.region->KeyRange.low;
                 Gdk::Cairo::set_source_color(cr, bg);  
                 cr->rectangle(prevx + xx, 0, x - prevx - xx, h1);  
                 cr->fill();  
671              }              }
672          }          }
673          Gdk::Cairo::set_source_color(cr, black);          x1 = key_to_x(x1, w);
674          cr->move_to(x + 0.5, 1);          x2 = key_to_x(x2 + 1, w) + 1;
675          cr->line_to(x + 0.5, h1 - 1);          Gdk::Rectangle rect(x1, 0, x2 - x1, h1);
676          cr->stroke();  
677          resize.pos = k;          update_after_resize();
678    
679            get_window()->invalidate_rect(rect, false);
680      }      }
681  }  }
682    
683  void RegionChooser::motion_move_region(int x, int y)  void RegionChooser::motion_move_region(int x, int y)
684  {  {
685      const int w = get_width() - 1;      const int w = get_width() - 1;
     Cairo::RefPtr<Cairo::Context> cr = get_window()->create_cairo_context();  
     cr->set_line_width(1);  
686    
687      int k = int(double(x - move.from_x) / w * 128.0 + 0.5);      int l = int(double(x - move.offset) / w * 128.0 + 0.5);
688      if (k == move.pos) return;  
689      int new_k;      if (l == region->KeyRange.low) return;
690      bool new_touch_left;      int new_l;
691      bool new_touch_right;      int regionsize = region->KeyRange.high - region->KeyRange.low;
692      int a = 0;      int a = 0;
693      if (k > move.pos) {      if (l > region->KeyRange.low) {
694          for (gig::Region* r = regions.first() ; ; r = regions.next()) {          for (gig::Region* r = regions.first() ; ; r = regions.next()) {
695              if (r != region) {              if (r != region) {
696                  int b = r ? r->KeyRange.low : 128;                  int b = r ? r->KeyRange.low : 128;
697    
698                  // gap: from a to b (not inclusive b)                  // gap: from a to b (not inclusive b)
699    
700                  if (region->KeyRange.high + move.pos >= b) {                  if (region->KeyRange.high >= b) {
701                      // not found the current gap yet, just continue                      // not found the current gap yet, just continue
702                  } else {                  } else {
703    
704                      if (a > region->KeyRange.low + k) {                      if (a > l) {
705                          // this gap is too far to the right, break                          // this gap is too far to the right, break
706                          break;                          break;
707                      }                      }
708    
709                      int newhigh = std::min(region->KeyRange.high + k, b - 1);                      int newhigh = std::min(l + regionsize, b - 1);
710                      int newlo = newhigh - (region->KeyRange.high - region->KeyRange.low);                      int newlo = newhigh - regionsize;
711    
712                      if (newlo >= a) {                      if (newlo >= a) {
713                          // yes it fits - it's a candidate                          // yes it fits - it's a candidate
714                          new_k = newlo - region->KeyRange.low;                          new_l = newlo;
                         new_touch_left = a > 0 && a == newlo;  
                         new_touch_right = b < 128 && newhigh + 1 == b;  
715                      }                      }
716                  }                  }
717                  if (!r) break;                  if (!r) break;
# Line 681  void RegionChooser::motion_move_region(i Line 725  void RegionChooser::motion_move_region(i
725    
726                  // gap from a to b (not inclusive b)                  // gap from a to b (not inclusive b)
727    
728                  if (region->KeyRange.high + k >= b) {                  if (l + regionsize >= b) {
729                      // not found the current gap yet, just continue                      // not found the current gap yet, just continue
730                  } else {                  } else {
731    
732                      if (a > region->KeyRange.low + move.pos) {                      if (a > region->KeyRange.low) {
733                          // this gap is too far to the right, break                          // this gap is too far to the right, break
734                          break;                          break;
735                      }                      }
736    
737                      int newlo = std::max(region->KeyRange.low + k, a);                      int newlo = std::max(l, a);
738                      int newhigh = newlo + (region->KeyRange.high - region->KeyRange.low);                      int newhigh = newlo + regionsize;
739    
740                      if (newhigh < b) {                      if (newhigh < b) {
741                          // yes it fits - break as the first one is the best                          // yes it fits - break as the first one is the best
742                          new_k = newlo - region->KeyRange.low;                          new_l = newlo;
                         new_touch_left = a > 0 && a == newlo;  
                         new_touch_right = b < 128 && newhigh + 1 == b;  
743                          break;                          break;
744                      }                      }
745                  }                  }
# Line 706  void RegionChooser::motion_move_region(i Line 748  void RegionChooser::motion_move_region(i
748              }              }
749          }          }
750      }      }
751      k = new_k;      if (new_l == region->KeyRange.low) return;
     if (k == move.pos) return;  
752    
753      const Gdk::Color bg = get_style()->get_bg(Gtk::STATE_NORMAL);      int x1 = key_to_x(std::min(int(region->KeyRange.low), new_l), w);
754      int prevx = int(w * (move.pos + region->KeyRange.low) / 128.0 + 0.5);      int x2 = key_to_x(std::max(int(region->KeyRange.high),
755      x = int(w * (k + region->KeyRange.low) / 128.0 + 0.5);                                 new_l + regionsize) + 1, w) + 1;
     int prevx2 = int(w * (move.pos + region->KeyRange.high + 1) / 128.0 + 0.5);  
     int x2 = int(w * (k + region->KeyRange.high + 1) / 128.0 + 0.5);  
     const Gdk::Color black = get_style()->get_black();  
756    
757      if (!new_touch_left) {      Gdk::Rectangle rect(x1, 0, x2 - x1, h1);
758          Gdk::Cairo::set_source_color(cr, black);      update_after_move(new_l);
         cr->move_to(x + 0.5, 1);  
         cr->line_to(x + 0.5, h1 - 1);  
         cr->stroke();  
     }  
     if (!new_touch_right) {  
         Gdk::Cairo::set_source_color(cr, black);  
         cr->move_to(x2 + 0.5, 1);  
         cr->line_to(x2 + 0.5, h1 - 1);  
         cr->stroke();  
     }  
   
     if (k > move.pos) {  
         Gdk::Cairo::set_source_color(cr, bg);  
         cr->rectangle(prevx + (move.touch_left ? 1 : 0), 0,  
                       std::min(x, prevx2 + 1 - (move.touch_right ? 1 : 0)) -  
                       (prevx + (move.touch_left ? 1 : 0)), h1);  
         cr->fill();  
   
         Gdk::Cairo::set_source_color(cr, black);  
         cr->move_to(std::max(x, prevx2 + 1), 0.5);  
         cr->line_to(x2 + 1, 0.5);  
         cr->move_to(std::max(x, prevx2 + 1), h1 - 0.5);  
         cr->line_to(x2 + 1, h1 - 0.5);  
         cr->stroke();  
   
         Gdk::Cairo::set_source_color(cr, red);  
         cr->rectangle(std::max(x + 1, prevx2), 1,  
                       x2 - std::max(x + 1, prevx2), h1 - 2);  
         cr->fill();  
     } else {  
         Gdk::Cairo::set_source_color(cr, bg);  
         cr->rectangle(std::max(x2 + 1, prevx + (move.touch_left ? 1 : 0)), 0,  
                       prevx2 + 1 - (move.touch_right ? 1 : 0) -  
                       std::max(x2 + 1, prevx + (move.touch_left ? 1 : 0)), h1);  
         cr->fill();  
   
         Gdk::Cairo::set_source_color(cr, black);  
         cr->move_to(x, 0.5);  
         cr->line_to(std::min(x2, prevx - 1) + 1, 0.5);  
         cr->move_to(x, h1 - 0.5);  
         cr->line_to(std::min(x2, prevx - 1) + 1, h1 - 0.5);  
         cr->stroke();  
   
         Gdk::Cairo::set_source_color(cr, red);  
         cr->rectangle(x + 1, 1, std::min(x2 - 1, prevx) - x, h1 - 2);  
         cr->fill();  
     }  
759    
760      move.pos = k;      get_window()->invalidate_rect(rect, false);
     move.touch_left = new_touch_left;  
     move.touch_right = new_touch_right;  
761  }  }
762    
763    
# Line 785  bool RegionChooser::on_motion_notify_eve Line 774  bool RegionChooser::on_motion_notify_eve
774          event->y >= REGION_BLOCK_HEIGHT &&          event->y >= REGION_BLOCK_HEIGHT &&
775          event->y < REGION_BLOCK_HEIGHT + KEYBOARD_HEIGHT)          event->y < REGION_BLOCK_HEIGHT + KEYBOARD_HEIGHT)
776      {      {
777          const int k = int(event->x / (get_width() - 1) * 128.0);          const int k = x_to_key(event->x, get_width() - 1);
778          if (k != currentActiveKey) {          if (k != currentActiveKey) {
779              int velocity =              int velocity =
780                  (event->y >= REGION_BLOCK_HEIGHT + KEYBOARD_HEIGHT - 1) ? 127 :                  (event->y >= REGION_BLOCK_HEIGHT + KEYBOARD_HEIGHT - 1) ? 127 :
# Line 805  bool RegionChooser::on_motion_notify_eve Line 794  bool RegionChooser::on_motion_notify_eve
794      } else {      } else {
795          if (is_in_resize_zone(x, y)) {          if (is_in_resize_zone(x, y)) {
796              if (!cursor_is_resize) {              if (!cursor_is_resize) {
797    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
798                  window->set_cursor(Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW));                  window->set_cursor(Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW));
799    #else
800                    window->set_cursor(Gdk::Cursor::create(Gdk::SB_H_DOUBLE_ARROW));
801    #endif
802                  cursor_is_resize = true;                  cursor_is_resize = true;
803              }              }
804          } else if (cursor_is_resize) {          } else if (cursor_is_resize) {
# Line 826  bool RegionChooser::is_in_resize_zone(do Line 819  bool RegionChooser::is_in_resize_zone(do
819          for (gig::Region* r = regions.first(); r ; r = next_region) {          for (gig::Region* r = regions.first(); r ; r = next_region) {
820              next_region = regions.next();              next_region = regions.next();
821    
822              int lo = int(w * (r->KeyRange.low) / 128.0 + 0.5);              int lo = key_to_x(r->KeyRange.low, w);
823              if (x <= lo - 2) break;              if (x <= lo - 2) break;
824              if (x < lo + 2) {              if (x < lo + 2) {
825                  resize.region = r;                  resize.region = r;
# Line 849  bool RegionChooser::is_in_resize_zone(do Line 842  bool RegionChooser::is_in_resize_zone(do
842                  return resize.min != resize.max;                  return resize.min != resize.max;
843              }              }
844              if (!next_region || r->KeyRange.high + 1 != next_region->KeyRange.low) {              if (!next_region || r->KeyRange.high + 1 != next_region->KeyRange.low) {
845                  int hi = int(w * (r->KeyRange.high + 1) / 128.0 + 0.5);                  int hi = key_to_x(r->KeyRange.high + 1, w);
846                  if (x <= hi - 2) break;                  if (x <= hi - 2) break;
847                  if (x < hi + 2) {                  if (x < hi + 2) {
848                      // edit high limit                      // edit high limit
# Line 887  void RegionChooser::show_region_properti Line 880  void RegionChooser::show_region_properti
880      dialog.get_vbox()->pack_start(checkBoxKeygroup);      dialog.get_vbox()->pack_start(checkBoxKeygroup);
881      checkBoxKeygroup.show();      checkBoxKeygroup.show();
882      // add "Keygroup" spinbox      // add "Keygroup" spinbox
883      Gtk::Adjustment adjustment(1, 1, pow(2,32));  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
884        Gtk::Adjustment adjustment(1, 1, 999);
885      Gtk::SpinButton spinBox(adjustment);      Gtk::SpinButton spinBox(adjustment);
886    #else
887        Gtk::SpinButton spinBox(Gtk::Adjustment::create(1, 1, 999));
888    #endif
889      if (region->KeyGroup) spinBox.set_value(region->KeyGroup);      if (region->KeyGroup) spinBox.set_value(region->KeyGroup);
890      dialog.get_vbox()->pack_start(spinBox);      dialog.get_vbox()->pack_start(spinBox);
891      spinBox.show();      spinBox.show();
Legend:
Removed from v.2151  
changed lines
  Added in v.2695
  ViewVC Help
Powered by ViewVC