/[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 1411 by schoenebeck, Fri Oct 12 17:46:29 2007 UTC revision 2663 by schoenebeck, Wed Jul 2 23:53:21 2014 UTC
# Line 1  Line 1 
1  /*  /*
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 18  Line 18 
18   */   */
19    
20  #include "regionchooser.h"  #include "regionchooser.h"
21    
22    #include <algorithm>
23    
24    #include <cairomm/context.h>
25    #include <gdkmm/general.h>
26  #include <gdkmm/cursor.h>  #include <gdkmm/cursor.h>
27  #include <gtkmm/stock.h>  #include <gtkmm/stock.h>
28  #include <gtkmm/spinbutton.h>  #include <gtkmm/spinbutton.h>
29  #include <gtkmm/dialog.h>  #include <gtkmm/dialog.h>
 #include <math.h>  
30    
31  #include "global.h"  #include "global.h"
32    
33  RegionChooser::RegionChooser()  #define REGION_BLOCK_HEIGHT             30
34  {  #define KEYBOARD_HEIGHT                 40
35      Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();  
36    void SortedRegions::update(gig::Instrument* instrument) {
37        // Usually, the regions in a gig file are ordered after their key
38        // range, but there are files where they are not. The
39        // RegionChooser code needs a sorted list of regions.
40        regions.clear();
41        if (instrument) {
42            for (gig::Region* r = instrument->GetFirstRegion() ;
43                 r ;
44                 r = instrument->GetNextRegion()) {
45                regions.push_back(r);
46            }
47            sort(regions.begin(), regions.end(), *this);
48        }
49    }
50    
51    gig::Region* SortedRegions::first() {
52        region_iterator = regions.begin();
53        return region_iterator == regions.end() ? 0 : *region_iterator;
54    }
55    
56    gig::Region* SortedRegions::next() {
57        region_iterator++;
58        return region_iterator == regions.end() ? 0 : *region_iterator;
59    }
60    
     red = Gdk::Color("#8070ff");  
     grey1 = Gdk::Color("#b0b0b0");  
61    
62      colormap->alloc_color(red);  
63      colormap->alloc_color(grey1);  RegionChooser::RegionChooser() :
64        activeKeyColor("red"),
65        red("#8070ff"),
66        grey1("grey69"),
67        white("white"),
68        black("black"),
69        m_VirtKeybModeChoice(_("Virtual Keyboard Mode")),
70        currentActiveKey(-1)
71    {
72        set_size_request(500, KEYBOARD_HEIGHT + REGION_BLOCK_HEIGHT);
73    
74      instrument = 0;      instrument = 0;
75      region = 0;      region = 0;
76      resize.active = false;      resize.active = false;
77      move.active = false;      move.active = false;
78      cursor_is_resize = false;      cursor_is_resize = false;
79      h1 = 20;      h1 = REGION_BLOCK_HEIGHT;
80      width = 800;  
81        // properties of the virtual keyboard
82        {
83            const char* choices[] = { _("normal"), _("chord"), 0 };
84            static const virt_keyboard_mode_t values[] = {
85                VIRT_KEYBOARD_MODE_NORMAL,
86                VIRT_KEYBOARD_MODE_CHORD
87            };
88            m_VirtKeybModeChoice.set_choices(choices, values);
89            m_VirtKeybModeChoice.set_value(VIRT_KEYBOARD_MODE_NORMAL);
90        }
91        m_VirtKeybVelocityLabelDescr.set_text(_("Note-On Velocity:"));
92        m_VirtKeybVelocityLabel.set_text("-");
93        m_VirtKeybOffVelocityLabelDescr.set_text(_("Note-Off Velocity:"));
94        m_VirtKeybOffVelocityLabel.set_text("-");
95        m_VirtKeybPropsBox.pack_start(m_VirtKeybModeChoice.label, Gtk::PACK_SHRINK);
96        m_VirtKeybPropsBox.pack_start(m_VirtKeybModeChoice.widget, Gtk::PACK_SHRINK);
97        m_VirtKeybPropsBox.pack_start(m_VirtKeybVelocityLabelDescr, Gtk::PACK_SHRINK);
98        m_VirtKeybPropsBox.pack_start(m_VirtKeybVelocityLabel, Gtk::PACK_SHRINK);
99        m_VirtKeybPropsBox.pack_start(m_VirtKeybOffVelocityLabelDescr, Gtk::PACK_SHRINK);
100        m_VirtKeybPropsBox.pack_start(m_VirtKeybOffVelocityLabel, Gtk::PACK_SHRINK);
101        m_VirtKeybPropsBox.set_spacing(10);
102        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 89  RegionChooser::RegionChooser() Line 148  RegionChooser::RegionChooser()
148              sigc::mem_fun(*this, &RegionChooser::on_dimension_manager_changed)              sigc::mem_fun(*this, &RegionChooser::on_dimension_manager_changed)
149          )          )
150      );      );
151        keyboard_key_hit_signal.connect(
152            sigc::mem_fun(*this, &RegionChooser::on_note_on_event)
153        );
154        keyboard_key_released_signal.connect(
155            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  void RegionChooser::on_realize()  void RegionChooser::invalidate_key(int key) {
165  {      const int h = KEYBOARD_HEIGHT;
166      // We need to call the base on_realize()      const int w = get_width() - 1;
167      Gtk::DrawingArea::on_realize();      int x1 = key_to_x(key - 0.5, w);
168        int x2 = key_to_x(key + 1.5, w);
169    
170      // Now we can allocate any additional resources we need      Gdk::Rectangle rect(x1 + 1, h1 + 1, x2 - x1 - 1, h - 2);
171      Glib::RefPtr<Gdk::Window> window = get_window();      get_window()->invalidate_rect(rect, false);
     gc = Gdk::GC::create(window);  
     window->clear();  
172  }  }
173    
174  bool RegionChooser::on_expose_event(GdkEventExpose* event)  void RegionChooser::on_note_on_event(int key, int velocity) {
175  {      key_pressed[key] = true;
176      Glib::RefPtr<Gdk::Window> window = get_window();      invalidate_key(key);
177      window->clear();      m_VirtKeybVelocityLabel.set_text(ToString(velocity));
178      const int h = 40;  }
     const int w = width - 1;  
     const int bh = int(h * 0.55);  
179    
180      Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();  void RegionChooser::on_note_off_event(int key, int velocity) {
181      Glib::RefPtr<const Gdk::GC> white = get_style()->get_white_gc();      key_pressed[key] = false;
182        invalidate_key(key);
183        m_VirtKeybOffVelocityLabel.set_text(ToString(velocity));
184    }
185    
     Glib::RefPtr<Pango::Context> context = get_pango_context();  
     Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create(context);  
186    
187      window->draw_rectangle(black, false, 0, h1, w, h - 1);  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
188      gc->set_foreground(grey1);  bool RegionChooser::on_expose_event(GdkEventExpose* e) {
189      int x1 = int(w * 20.5 / 128.0 + 0.5);      double clipx1 = e->area.x;
190      int x2 = int(w * 109.5 / 128.0 + 0.5);      double clipx2 = e->area.x + e->area.width;
191      window->draw_rectangle(gc, true, 1, h1 + 1,      double clipy1 = e->area.y;
192                             x1 - 1, h - 2);      double clipy2 = e->area.y + e->area.height;
     window->draw_rectangle(white, true, x1 + 1, h1 + 1, x2 - x1 - 1, h - 2);  
     window->draw_rectangle(gc, true, x2 + 1, h1 + 1,  
                            w - x2 - 1, h - 2);  
     int octave = -1;  
     for (int i = 0 ; i < 128 ; i++) {  
         int note = (i + 3) % 12;  
         int x = int(w * i / 128.0 + 0.5);  
193    
194          if (note == 1 || note == 4 || note == 6 || note == 9 || note == 11) {      const Cairo::RefPtr<Cairo::Context>& cr =
195              int x2 = int(w * (i + 0.5) / 128.0 + 0.5);          get_window()->create_cairo_context();
196              window->draw_line(black, x2, h1 + bh, x2, h1 + h);  #if 0
197    }
198              int x3 = int(w * (i + 1) / 128.0 + 0.5);  #endif
199              window->draw_rectangle(black, true, x, h1 + 1, x3 - x + 1, bh);  #else
200          } else if (note == 3 || note == 8) {  bool RegionChooser::on_draw(const Cairo::RefPtr<Cairo::Context>& cr) {
201              window->draw_line(black, x, h1 + 1, x, h1 + h);      double clipx1, clipx2, clipy1, clipy2;
202          }      cr->get_clip_extents(clipx1, clipy1, clipx2, clipy2);
203          if (note == 3) {  #endif
             char buf[30];  
             sprintf(buf, "<span size=\"8000\">%d</span>", octave);  
             layout->set_markup(buf);  
             Pango::Rectangle rectangle = layout->get_logical_extents();  
             double text_w = double(rectangle.get_width()) / Pango::SCALE;  
             double text_h = double(rectangle.get_height()) / Pango::SCALE;  
             double x2 = w * (i + 0.75) / 128.0;  
             window->draw_layout(black, int(x2 - text_w / 2 + 1),  
                                 int(h1 + h - text_h + 0.5), layout);  
             octave++;  
         }  
     }  
204    
205      if (instrument) {      cr->save();
206          int i = 0;      cr->set_line_width(1);
         gig::Region *next_region;  
         int x3 = -1;  
         for (gig::Region *r = instrument->GetFirstRegion() ;  
              r ;  
              r = next_region) {  
207    
208              if (x3 < 0) x3 = int(w * (r->KeyRange.low) / 128.0 + 0.5);  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
209              next_region = instrument->GetNextRegion();      const Gdk::Color bg = get_style()->get_bg(Gtk::STATE_NORMAL);
210              if (!next_region || r->KeyRange.high + 1 != next_region->KeyRange.low) {  #else
211                  int x2 = int(w * (r->KeyRange.high + 1) / 128.0 + 0.5);      const Gdk::RGBA bg = get_style_context()->get_background_color();
212                  window->draw_line(black, x3, 0, x2, 0);  #endif
213                  window->draw_line(black, x3, h1 - 1, x2, h1 - 1);      Gdk::Cairo::set_source_rgba(cr, bg);
214                  window->draw_line(black, x2, 1, x2, h1 - 2);      cr->paint();
                 window->draw_rectangle(white, true, x3 + 1, 1, x2 - x3 - 1, h1 - 2);  
                 x3 = -1;  
             }  
             i++;  
         }  
215    
216          for (gig::Region *r = instrument->GetFirstRegion() ;      if (clipy2 > h1) {
217               r ;          draw_keyboard(cr, clipx1, clipx2);
218               r = instrument->GetNextRegion()) {      }
             int x = int(w * (r->KeyRange.low) / 128.0 + 0.5);  
             window->draw_line(black, x, 1, x, h1 - 2);  
         }  
219    
220          if (region) {      if (clipy1 < h1 && instrument) {
221              int x1 = int(w * (region->KeyRange.low) / 128.0 + 0.5);          draw_regions(cr, clipx1, clipx2);
             int x2 = int(w * (region->KeyRange.high + 1) / 128.0 + 0.5);  
             gc->set_foreground(red);  
             window->draw_rectangle(gc, true, x1 + 1, 1, x2 - x1 - 1, h1 - 2);  
         }  
222      }      }
223    
224        cr->restore();
225    
226      return true;      return true;
227  }  }
228    
229    void RegionChooser::draw_keyboard(const Cairo::RefPtr<Cairo::Context>& cr,
230                                      int clip_low, int clip_high) {
231        const int h = KEYBOARD_HEIGHT;
232        const int w = get_width() - 1;
233        const int bh = int(h * 0.55);
234    
235  void RegionChooser::on_size_request(GtkRequisition* requisition)      Gdk::Cairo::set_source_rgba(cr, black);
236  {      cr->rectangle(0.5, h1 + 0.5, w, h - 1);
237      *requisition = GtkRequisition();      cr->stroke();
238      requisition->height = 40 + 20;  
239      requisition->width = 500;      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 (key_pressed[i]) draw_key(cr, i);
282    
283            if (note == 3) draw_digit(cr, i);
284        }
285  }  }
286    
287    
288  // not used  void RegionChooser::draw_regions(const Cairo::RefPtr<Cairo::Context>& cr,
289  void RegionChooser::draw_region(int from, int to, const Gdk::Color& color)                                   int clip_low, int clip_high) {
290  {      const int w = get_width() - 1;
291      const int h = 40;  
292      const int w = width;      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();
313    
314                    Gdk::Cairo::set_source_rgba(cr, region == r ? red : white);
315                    cr->rectangle(x3 + 1, 1, x2 - x3 - 1, h1 - 2);
316                    cr->fill();
317                    Gdk::Cairo::set_source_rgba(cr, black);
318                }
319                x3 = -1;
320            }
321        }
322    
323        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            cr->move_to(x + 0.5, 1);
330            cr->line_to(x + 0.5, h1 - 1);
331            cr->stroke();
332        }
333    
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) {
359        const int note = (key + 3) % 12;
360        return note == 1 || note == 4 || note == 6 || note == 9 || note == 11;
361    }
362    
363    void RegionChooser::draw_digit(const Cairo::RefPtr<Cairo::Context>& cr,
364                                   int key) {
365        const int h = KEYBOARD_HEIGHT;
366        const int w = get_width() - 1;
367        Glib::RefPtr<Pango::Layout> layout =
368            Pango::Layout::create(get_pango_context());
369        char buf[30];
370        sprintf(buf, "<span size=\"8000\">%d</span>", key / 12 - 1);
371        layout->set_markup(buf);
372        Pango::Rectangle rectangle = layout->get_logical_extents();
373        double text_w = double(rectangle.get_width()) / Pango::SCALE;
374        double text_h = double(rectangle.get_height()) / Pango::SCALE;
375        double x = w * (key + 0.75) / 128.0;
376        Gdk::Cairo::set_source_rgba(cr, black);
377        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
379        pango_cairo_show_layout(cr->cobj(), layout->gobj());
380    #else
381        layout->show_in_cairo_context(cr);
382    #endif
383    }
384    
385    void RegionChooser::draw_key(const Cairo::RefPtr<Cairo::Context>& cr,
386                                 int key) {
387        const int h = KEYBOARD_HEIGHT;
388        const int w = get_width() - 1;
389      const int bh = int(h * 0.55);      const int bh = int(h * 0.55);
390    
391      Glib::RefPtr<Gdk::Window> window = get_window();      Gdk::Cairo::set_source_rgba(cr, activeKeyColor);
     gc->set_foreground(color);  
392    
393      for (int i = from ; i < to ; i++) {      int note = (key + 3) % 12;
394          int note = (i + 3) % 12;      int x = key_to_x(key, w) + 1;
395          int x = int(w * i / 128.0 + 0.5) + 1;      int x2 = key_to_x(key + 1.5, w);
396          int x2 = int(w * (i + 1.5) / 128.0 + 0.5);      int x3 = key_to_x(key + 1, w);
397          int x3 = int(w * (i + 1) / 128.0 + 0.5);      int x4 = key_to_x(key - 0.5, w);
398          int x4 = int(w * (i - 0.5) / 128 + 0.5) + 1;      int w1 = x3 - x;
399          int w1 = x3 - x;      switch (note) {
400          switch (note) {      case 0: case 5: case 10:
401          case 0: case 5: case 10:          cr->rectangle(x, h1 + 1, w1, bh);
402              window->draw_rectangle(gc, true, x, h1 + 1, w1, bh);          cr->fill();
403              window->draw_rectangle(gc, true, x4, h1 + bh + 1, x2 - x4, h - bh - 2);          cr->rectangle(x4 + 1, h1 + bh + 1, x2 - x4 - 1, h - bh - 2);
404              break;          cr->fill();
405          case 2: case 7:          break;
406              window->draw_rectangle(gc, true, x, h1 + 1, w1, bh);      case 2: case 7:
407              window->draw_rectangle(gc, true, x4, h1 + bh + 1, x3 - x4, h - bh - 2);          cr->rectangle(x, h1 + 1, w1, bh);
408              break;          cr->fill();
409          case 3: case 8:          cr->rectangle(x4 + 1, h1 + bh + 1, x3 - x4 - 1, h - bh - 2);
410              window->draw_rectangle(gc, true, x, h1 + 1, w1, bh);          cr->fill();
411              window->draw_rectangle(gc, true, x, h1 + bh + 1, x2 - x, h - bh - 2);          break;
412              break;      case 3: case 8:
413          default:          cr->rectangle(x, h1 + 1, w1, bh);
414              window->draw_rectangle(gc, true, x, h1 + 1, w1, bh - 1);          cr->fill();
415              break;          cr->rectangle(x, h1 + bh + 1, x2 - x, h - bh - 2);
416          }          cr->fill();
417            break;
418        default:
419            cr->rectangle(x, h1 + 1, w1, bh - 1);
420            cr->fill();
421            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)
427  {  {
428      this->instrument = instrument;      this->instrument = instrument;
429      region = instrument ? instrument->GetFirstRegion() : 0;      regions.update(instrument);
430        region = regions.first();
431      queue_draw();      queue_draw();
432      region_selected();      region_selected();
433        dimensionManager.set_region(region);
434  }  }
435    
436  bool RegionChooser::on_button_release_event(GdkEventButton* event)  bool RegionChooser::on_button_release_event(GdkEventButton* event)
437  {  {
438        const int k = x_to_key(event->x, get_width() - 1);
439    
440        // handle-note off on virtual keyboard
441        if (event->type == GDK_BUTTON_RELEASE) {
442            int velocity = (event->y >= REGION_BLOCK_HEIGHT + KEYBOARD_HEIGHT - 1) ? 127 :
443                           int(float(event->y - REGION_BLOCK_HEIGHT) / float(KEYBOARD_HEIGHT) * 128.0f) + 1;
444            if (velocity <= 0) velocity = 1;
445            switch (m_VirtKeybModeChoice.get_value()) {
446                case VIRT_KEYBOARD_MODE_CHORD:
447                    if (event->y >= REGION_BLOCK_HEIGHT)
448                        keyboard_key_released_signal.emit(k, velocity);
449                    break;
450                case VIRT_KEYBOARD_MODE_NORMAL:
451                default:
452                    if (currentActiveKey >= 0 && currentActiveKey <= 127) {
453                        keyboard_key_released_signal.emit(currentActiveKey, velocity);
454                        currentActiveKey = -1;
455                    }
456                    break;
457            }
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  
                 );  
                 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  
                 );  
                 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    
         if (move.pos) {  
             instrument_struct_to_be_changed_signal.emit(instrument);  
             region->SetKeyRange(  
                 region->KeyRange.low  + move.pos,  
                 region->KeyRange.high + move.pos  
             );  
             instrument_struct_changed_signal.emit(instrument);  
         }  
   
480          if (is_in_resize_zone(event->x, event->y)) {          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));              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;              cursor_is_resize = true;
487          }          }
488      }      }
489      return true;      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);
497                resize.region->SetKeyRange(resize.region->KeyRange.low,
498                                           resize.pos - 1);
499                regions.update(instrument);
500                instrument_changed.emit();
501                instrument_struct_changed_signal.emit(instrument);
502            }
503        } else if (resize.mode == resize.moving_low_limit) {
504            if (resize.region->KeyRange.low != resize.pos) {
505                instrument_struct_to_be_changed_signal.emit(instrument);
506                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    }
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      int k = int(event->x / (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) {
533            if (event->y >= REGION_BLOCK_HEIGHT) {
534                int velocity = (event->y >= REGION_BLOCK_HEIGHT + KEYBOARD_HEIGHT - 1) ? 127 :
535                               int(float(event->y - REGION_BLOCK_HEIGHT) / float(KEYBOARD_HEIGHT) * 128.0f) + 1;
536                currentActiveKey = k;
537                keyboard_key_hit_signal.emit(k, velocity);
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;
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);
552          if (r) {          if (r) {
553              region = r;              region = r;
554              queue_draw();              queue_draw();
555              region_selected();              region_selected();
556                dimensionManager.set_region(region);
557              popup_menu_inside_region->popup(event->button, event->time);              popup_menu_inside_region->popup(event->button, event->time);
558          } else {          } else {
559              new_region_pos = k;              new_region_pos = k;
# Line 321  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 333  bool RegionChooser::on_button_press_even Line 585  bool RegionChooser::on_button_press_even
585                  region = r;                  region = r;
586                  queue_draw();                  queue_draw();
587                  region_selected();                  region_selected();
588                    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 350  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 = instrument->GetFirstRegion() ; r ;  
          r = next_region) {  
         next_region = instrument->GetNextRegion();  
   
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::motion_resize_region(int x, int y)  void RegionChooser::motion_resize_region(int x, int y)
625  {  {
626      const int w = width - 1;      const int w = get_width() - 1;
     Glib::RefPtr<Gdk::Window> window = get_window();  
627    
628      int k = int(double(x) / w * 128.0 + 0.5);      int k = int(double(x) / w * 128.0 + 0.5);
629    
# Line 390  void RegionChooser::motion_resize_region Line 643  void RegionChooser::motion_resize_region
643                  resize.mode = resize.moving_low_limit;                  resize.mode = resize.moving_low_limit;
644              }              }
645          }          }
646          Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();          resize.pos = k;
         Glib::RefPtr<const Gdk::GC> white = get_style()->get_white_gc();  
         if (region == resize.region) {  
             gc->set_foreground(red);  
             white = gc;  
         }  
         Glib::RefPtr<const Gdk::GC> bg = get_style()->get_bg_gc(Gtk::STATE_NORMAL);  
         int prevx = int(w * resize.pos / 128.0 + 0.5);  
         x = int(w * k / 128.0 + 0.5);  
647    
648            int x1, x2;
649          if (resize.mode == resize.moving_high_limit) {          if (resize.mode == resize.moving_high_limit) {
650              if (k > resize.pos) {              if (resize.region->KeyRange.high < resize.pos - 1) {
651                  window->draw_rectangle(white, true, prevx, 1, x - prevx, h1 - 2);                  x1 = resize.region->KeyRange.high;
652                  window->draw_line(black, prevx, 0, x, 0);                  x2 = resize.pos - 1;
                 window->draw_line(black, prevx, h1 - 1, x, h1 - 1);  
653              } else {              } else {
654                  int xx = ((resize.pos == resize.max && resize.max != 128) ? 1 : 0);                  x1 = resize.pos - 1;
655                  window->draw_rectangle(bg, true, x + 1, 0, prevx - x - xx, h1);                  x2 = resize.region->KeyRange.high;
656              }              }
657          } else {          } else {
658              if (k < resize.pos) {              if (resize.region->KeyRange.low < resize.pos) {
659                  window->draw_rectangle(white, true, x + 1, 1, prevx - x, h1 - 2);                  x1 = resize.region->KeyRange.low;
660                  window->draw_line(black, x, 0, prevx, 0);                  x2 = resize.pos;
                 window->draw_line(black, x, h1 - 1, prevx, h1 - 1);  
661              } else {              } else {
662                  int xx = ((resize.pos == resize.min && resize.min != 0) ? 1 : 0);                  x1 = resize.pos;
663                  window->draw_rectangle(bg, true, prevx + xx, 0, x - prevx - xx, h1);                  x2 = resize.region->KeyRange.low;
664              }              }
665          }          }
666          window->draw_line(black, x, 1, x, h1 - 2);          x1 = key_to_x(x1, w);
667          resize.pos = k;          x2 = key_to_x(x2 + 1, w) + 1;
668            Gdk::Rectangle rect(x1, 0, x2 - x1, h1);
669    
670            update_after_resize();
671    
672            get_window()->invalidate_rect(rect, false);
673      }      }
674  }  }
675    
676  void RegionChooser::motion_move_region(int x, int y)  void RegionChooser::motion_move_region(int x, int y)
677  {  {
678      const int w = width - 1;      const int w = get_width() - 1;
     Glib::RefPtr<Gdk::Window> window = get_window();  
679    
680      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);
681      if (k == move.pos) return;  
682      int new_k;      if (l == region->KeyRange.low) return;
683      bool new_touch_left;      int new_l;
684      bool new_touch_right;      int regionsize = region->KeyRange.high - region->KeyRange.low;
685      int a = 0;      int a = 0;
686      if (k > move.pos) {      if (l > region->KeyRange.low) {
687          for (gig::Region* r = instrument->GetFirstRegion() ; ;          for (gig::Region* r = regions.first() ; ; r = regions.next()) {
              r = instrument->GetNextRegion()) {  
688              if (r != region) {              if (r != region) {
689                  int b = r ? r->KeyRange.low : 128;                  int b = r ? r->KeyRange.low : 128;
690    
691                  // gap: from a to b (not inclusive b)                  // gap: from a to b (not inclusive b)
692    
693                  if (region->KeyRange.high + move.pos >= b) {                  if (region->KeyRange.high >= b) {
694                      // not found the current gap yet, just continue                      // not found the current gap yet, just continue
695                  } else {                  } else {
696    
697                      if (a > region->KeyRange.low + k) {                      if (a > l) {
698                          // this gap is too far to the right, break                          // this gap is too far to the right, break
699                          break;                          break;
700                      }                      }
701    
702                      int newhigh = std::min(region->KeyRange.high + k, b - 1);                      int newhigh = std::min(l + regionsize, b - 1);
703                      int newlo = newhigh - (region->KeyRange.high - region->KeyRange.low);                      int newlo = newhigh - regionsize;
704    
705                      if (newlo >= a) {                      if (newlo >= a) {
706                          // yes it fits - it's a candidate                          // yes it fits - it's a candidate
707                          new_k = newlo - region->KeyRange.low;                          new_l = newlo;
                         new_touch_left = a > 0 && a == newlo;  
                         new_touch_right = b < 128 && newhigh + 1 == b;  
708                      }                      }
709                  }                  }
710                  if (!r) break;                  if (!r) break;
# Line 467  void RegionChooser::motion_move_region(i Line 712  void RegionChooser::motion_move_region(i
712              }              }
713          }          }
714      } else {      } else {
715          for (gig::Region* r = instrument->GetFirstRegion() ; ;          for (gig::Region* r = regions.first() ; ; r = regions.next()) {
              r = instrument->GetNextRegion()) {  
716              if (r != region) {              if (r != region) {
717                  int b = r ? r->KeyRange.low : 128;                  int b = r ? r->KeyRange.low : 128;
718    
719                  // gap from a to b (not inclusive b)                  // gap from a to b (not inclusive b)
720    
721                  if (region->KeyRange.high + k >= b) {                  if (l + regionsize >= b) {
722                      // not found the current gap yet, just continue                      // not found the current gap yet, just continue
723                  } else {                  } else {
724    
725                      if (a > region->KeyRange.low + move.pos) {                      if (a > region->KeyRange.low) {
726                          // this gap is too far to the right, break                          // this gap is too far to the right, break
727                          break;                          break;
728                      }                      }
729    
730                      int newlo = std::max(region->KeyRange.low + k, a);                      int newlo = std::max(l, a);
731                      int newhigh = newlo + (region->KeyRange.high - region->KeyRange.low);                      int newhigh = newlo + regionsize;
732    
733                      if (newhigh < b) {                      if (newhigh < b) {
734                          // yes it fits - break as the first one is the best                          // yes it fits - break as the first one is the best
735                          new_k = newlo - region->KeyRange.low;                          new_l = newlo;
                         new_touch_left = a > 0 && a == newlo;  
                         new_touch_right = b < 128 && newhigh + 1 == b;  
736                          break;                          break;
737                      }                      }
738                  }                  }
# Line 499  void RegionChooser::motion_move_region(i Line 741  void RegionChooser::motion_move_region(i
741              }              }
742          }          }
743      }      }
744      k = new_k;      if (new_l == region->KeyRange.low) return;
     if (k == move.pos) return;  
   
     Glib::RefPtr<const Gdk::GC> bg = get_style()->get_bg_gc(Gtk::STATE_NORMAL);  
     int prevx = int(w * (move.pos + region->KeyRange.low) / 128.0 + 0.5);  
     x = int(w * (k + region->KeyRange.low) / 128.0 + 0.5);  
     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);  
     Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();  
     gc->set_foreground(red);  
   
     if (!new_touch_left) window->draw_line(black, x, 1, x, h1 - 2);  
     if (!new_touch_right) window->draw_line(black, x2, 1, x2, h1 - 2);  
   
     if (k > move.pos) {  
         window->draw_rectangle(bg, true, prevx + (move.touch_left ? 1 : 0), 0,  
                                std::min(x, prevx2 + 1 - (move.touch_right ? 1 : 0)) -  
                                (prevx + (move.touch_left ? 1 : 0)), h1);  
   
         window->draw_line(black, std::max(x, prevx2 + 1), 0, x2, 0);  
         window->draw_line(black, std::max(x, prevx2 + 1), h1 - 1, x2, h1 - 1);  
         window->draw_rectangle(gc, true, std::max(x + 1, prevx2), 1,  
                                x2 - std::max(x + 1, prevx2), h1 - 2);  
     } else {  
         window->draw_rectangle(bg, true, 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);  
745    
746          window->draw_line(black, x, 0, std::min(x2, prevx - 1), 0);      int x1 = key_to_x(std::min(int(region->KeyRange.low), new_l), w);
747          window->draw_line(black, x, h1 - 1, std::min(x2, prevx - 1), h1 - 1);      int x2 = key_to_x(std::max(int(region->KeyRange.high),
748                                   new_l + regionsize) + 1, w) + 1;
749    
750          window->draw_rectangle(gc, true, x + 1, 1, std::min(x2 - 1, prevx) - x, h1 - 2);      Gdk::Rectangle rect(x1, 0, x2 - x1, h1);
751      }      update_after_move(new_l);
752    
753      move.pos = k;      get_window()->invalidate_rect(rect, false);
     move.touch_left = new_touch_left;  
     move.touch_right = new_touch_right;  
754  }  }
755    
756    
# Line 546  bool RegionChooser::on_motion_notify_eve Line 761  bool RegionChooser::on_motion_notify_eve
761      Gdk::ModifierType state = Gdk::ModifierType(0);      Gdk::ModifierType state = Gdk::ModifierType(0);
762      window->get_pointer(x, y, state);      window->get_pointer(x, y, state);
763    
764        // handle virtual MIDI keyboard
765        if (m_VirtKeybModeChoice.get_value() != VIRT_KEYBOARD_MODE_CHORD &&
766            currentActiveKey > 0 &&
767            event->y >= REGION_BLOCK_HEIGHT &&
768            event->y < REGION_BLOCK_HEIGHT + KEYBOARD_HEIGHT)
769        {
770            const int k = x_to_key(event->x, get_width() - 1);
771            if (k != currentActiveKey) {
772                int velocity =
773                    (event->y >= REGION_BLOCK_HEIGHT + KEYBOARD_HEIGHT - 1) ? 127 :
774                    int(float(event->y - REGION_BLOCK_HEIGHT) /
775                        float(KEYBOARD_HEIGHT) * 128.0f) + 1;
776                if (velocity <= 0) velocity = 1;
777                keyboard_key_released_signal.emit(currentActiveKey, velocity);
778                currentActiveKey = k;
779                keyboard_key_hit_signal.emit(k, velocity);
780            }
781        }
782    
783      if (resize.active) {      if (resize.active) {
784          motion_resize_region(x, y);          motion_resize_region(x, y);
785      } else if (move.active) {      } else if (move.active) {
# Line 553  bool RegionChooser::on_motion_notify_eve Line 787  bool RegionChooser::on_motion_notify_eve
787      } else {      } else {
788          if (is_in_resize_zone(x, y)) {          if (is_in_resize_zone(x, y)) {
789              if (!cursor_is_resize) {              if (!cursor_is_resize) {
790    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
791                  window->set_cursor(Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW));                  window->set_cursor(Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW));
792    #else
793                    window->set_cursor(Gdk::Cursor::create(Gdk::SB_H_DOUBLE_ARROW));
794    #endif
795                  cursor_is_resize = true;                  cursor_is_resize = true;
796              }              }
797          } else if (cursor_is_resize) {          } else if (cursor_is_resize) {
# Line 566  bool RegionChooser::on_motion_notify_eve Line 804  bool RegionChooser::on_motion_notify_eve
804  }  }
805    
806  bool RegionChooser::is_in_resize_zone(double x, double y) {  bool RegionChooser::is_in_resize_zone(double x, double y) {
807      const int w = width - 1;      const int w = get_width() - 1;
808    
809      if (instrument && y >= 0 && y <= h1) {      if (instrument && y >= 0 && y <= h1) {
810          gig::Region* prev_region = 0;          gig::Region* prev_region = 0;
811          gig::Region* next_region;          gig::Region* next_region;
812          for (gig::Region* r = instrument->GetFirstRegion() ; r ; r = next_region) {          for (gig::Region* r = regions.first(); r ; r = next_region) {
813              next_region = instrument->GetNextRegion();              next_region = regions.next();
814    
815              int lo = int(w * (r->KeyRange.low) / 128.0 + 0.5);              int lo = key_to_x(r->KeyRange.low, w);
816              if (x <= lo - 2) break;              if (x <= lo - 2) break;
817              if (x < lo + 2) {              if (x < lo + 2) {
818                  resize.region = r;                  resize.region = r;
# Line 588  bool RegionChooser::is_in_resize_zone(do Line 826  bool RegionChooser::is_in_resize_zone(do
826                      resize.mode = resize.undecided;                      resize.mode = resize.undecided;
827                      resize.min = prev_region->KeyRange.low + 1;                      resize.min = prev_region->KeyRange.low + 1;
828                      resize.prev_region = prev_region;                      resize.prev_region = prev_region;
829                      return true;                      return resize.min != resize.max;
830                  }                  }
831    
832                  // edit low limit                  // edit low limit
833                  resize.mode = resize.moving_low_limit;                  resize.mode = resize.moving_low_limit;
834                  resize.min = prev_region ? prev_region->KeyRange.high + 1 : 0;                  resize.min = prev_region ? prev_region->KeyRange.high + 1 : 0;
835                  return true;                  return resize.min != resize.max;
836              }              }
837              if (!next_region || r->KeyRange.high + 1 != next_region->KeyRange.low) {              if (!next_region || r->KeyRange.high + 1 != next_region->KeyRange.low) {
838                  int hi = int(w * (r->KeyRange.high + 1) / 128.0 + 0.5);                  int hi = key_to_x(r->KeyRange.high + 1, w);
839                  if (x <= hi - 2) break;                  if (x <= hi - 2) break;
840                  if (x < hi + 2) {                  if (x < hi + 2) {
841                      // edit high limit                      // edit high limit
# Line 606  bool RegionChooser::is_in_resize_zone(do Line 844  bool RegionChooser::is_in_resize_zone(do
844                      resize.mode = resize.moving_high_limit;                      resize.mode = resize.moving_high_limit;
845                      resize.min = r->KeyRange.low + 1;                      resize.min = r->KeyRange.low + 1;
846                      resize.max = next_region ? next_region->KeyRange.low : 128;                      resize.max = next_region ? next_region->KeyRange.low : 128;
847                      return true;                      return resize.min != resize.max;
848                  }                  }
849              }              }
850              prev_region = r;              prev_region = r;
# Line 628  sigc::signal<void>& RegionChooser::signa Line 866  sigc::signal<void>& RegionChooser::signa
866  void RegionChooser::show_region_properties()  void RegionChooser::show_region_properties()
867  {  {
868      if (!region) return;      if (!region) return;
869      Gtk::Dialog dialog("Region Properties", true /*modal*/);      Gtk::Dialog dialog(_("Region Properties"), true /*modal*/);
870      // add "Keygroup" checkbox      // add "Keygroup" checkbox
871      Gtk::CheckButton checkBoxKeygroup("Member of a Keygroup (Exclusive Group)");      Gtk::CheckButton checkBoxKeygroup(_("Member of a Keygroup (Exclusive Group)"));
872      checkBoxKeygroup.set_active(region->KeyGroup);      checkBoxKeygroup.set_active(region->KeyGroup);
873      dialog.get_vbox()->pack_start(checkBoxKeygroup);      dialog.get_vbox()->pack_start(checkBoxKeygroup);
874      checkBoxKeygroup.show();      checkBoxKeygroup.show();
875      // add "Keygroup" spinbox      // add "Keygroup" spinbox
876      Gtk::Adjustment adjustment(1, 1, pow(2,32));  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
877        Gtk::Adjustment adjustment(1, 1, 999);
878      Gtk::SpinButton spinBox(adjustment);      Gtk::SpinButton spinBox(adjustment);
879    #else
880        Gtk::SpinButton spinBox(Gtk::Adjustment::create(1, 1, 999));
881    #endif
882      if (region->KeyGroup) spinBox.set_value(region->KeyGroup);      if (region->KeyGroup) spinBox.set_value(region->KeyGroup);
883      dialog.get_vbox()->pack_start(spinBox);      dialog.get_vbox()->pack_start(spinBox);
884      spinBox.show();      spinBox.show();
# Line 658  void RegionChooser::add_region() Line 900  void RegionChooser::add_region()
900      region->SetKeyRange(new_region_pos, new_region_pos);      region->SetKeyRange(new_region_pos, new_region_pos);
901    
902      instrument_struct_changed_signal.emit(instrument);      instrument_struct_changed_signal.emit(instrument);
903        regions.update(instrument);
904    
905      queue_draw();      queue_draw();
906      region_selected();      region_selected();
907        dimensionManager.set_region(region);
908      instrument_changed();      instrument_changed();
909  }  }
910    
# Line 669  void RegionChooser::delete_region() Line 913  void RegionChooser::delete_region()
913      instrument_struct_to_be_changed_signal.emit(instrument);      instrument_struct_to_be_changed_signal.emit(instrument);
914      instrument->DeleteRegion(region);      instrument->DeleteRegion(region);
915      instrument_struct_changed_signal.emit(instrument);      instrument_struct_changed_signal.emit(instrument);
916        regions.update(instrument);
917    
918      region = 0;      region = 0;
919      queue_draw();      queue_draw();
920      region_selected();      region_selected();
921        dimensionManager.set_region(region);
922      instrument_changed();      instrument_changed();
923  }  }
924    
# Line 703  sigc::signal<void, gig::Region*>& Region Line 949  sigc::signal<void, gig::Region*>& Region
949  sigc::signal<void, gig::Region*>& RegionChooser::signal_region_changed_signal() {  sigc::signal<void, gig::Region*>& RegionChooser::signal_region_changed_signal() {
950      return region_changed_signal;      return region_changed_signal;
951  }  }
952    
953    sigc::signal<void, int/*key*/, int/*velocity*/>& RegionChooser::signal_keyboard_key_hit() {
954        return keyboard_key_hit_signal;
955    }
956    
957    sigc::signal<void, int/*key*/, int/*velocity*/>& RegionChooser::signal_keyboard_key_released() {
958        return keyboard_key_released_signal;
959    }
Legend:
Removed from v.1411  
changed lines
  Added in v.2663
  ViewVC Help
Powered by ViewVC