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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1533 - (hide annotations) (download)
Sat Dec 1 10:21:07 2007 UTC (12 years, 7 months ago) by persson
File size: 25166 byte(s)
* parameter edits can now be applied to multiple regions and dimension
  regions simultaneously - three checkboxes were added that select
  if changes apply to all regions and/or all dimension regions

1 schoenebeck 1225 /*
2     * Copyright (C) 2006, 2007 Andreas Persson
3     *
4     * This program is free software; you can redistribute it and/or
5     * modify it under the terms of the GNU General Public License as
6     * published by the Free Software Foundation; either version 2, or (at
7     * your option) any later version.
8     *
9     * This program is distributed in the hope that it will be useful, but
10     * WITHOUT ANY WARRANTY; without even the implied warranty of
11     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12     * General Public License for more details.
13     *
14     * You should have received a copy of the GNU General Public License
15     * along with program; see the file COPYING. If not, write to the Free
16     * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
17     * 02110-1301 USA.
18     */
19    
20     #include "regionchooser.h"
21     #include <gdkmm/cursor.h>
22     #include <gtkmm/stock.h>
23     #include <gtkmm/spinbutton.h>
24     #include <gtkmm/dialog.h>
25     #include <math.h>
26    
27 schoenebeck 1396 #include "global.h"
28 schoenebeck 1225
29     RegionChooser::RegionChooser()
30     {
31     Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();
32    
33     red = Gdk::Color("#8070ff");
34 persson 1262 grey1 = Gdk::Color("#b0b0b0");
35 schoenebeck 1225
36     colormap->alloc_color(red);
37     colormap->alloc_color(grey1);
38     instrument = 0;
39     region = 0;
40     resize.active = false;
41 persson 1303 move.active = false;
42 schoenebeck 1225 cursor_is_resize = false;
43     h1 = 20;
44     width = 800;
45    
46     actionGroup = Gtk::ActionGroup::create();
47     actionGroup->add(Gtk::Action::create("Properties",
48     Gtk::Stock::PROPERTIES),
49     sigc::mem_fun(*this,
50     &RegionChooser::show_region_properties));
51     actionGroup->add(Gtk::Action::create("Remove", Gtk::Stock::REMOVE),
52     sigc::mem_fun(*this, &RegionChooser::delete_region));
53     actionGroup->add(Gtk::Action::create("Add", Gtk::Stock::ADD),
54     sigc::mem_fun(*this, &RegionChooser::add_region));
55     actionGroup->add(Gtk::Action::create("Dimensions", _("Dimensions...")),
56     sigc::mem_fun(*this, &RegionChooser::manage_dimensions));
57    
58     uiManager = Gtk::UIManager::create();
59     uiManager->insert_action_group(actionGroup);
60     Glib::ustring ui_info =
61     "<ui>"
62     " <popup name='PopupMenuInsideRegion'>"
63     " <menuitem action='Properties'/>"
64     " <menuitem action='Dimensions'/>"
65     " <menuitem action='Remove'/>"
66     " </popup>"
67     " <popup name='PopupMenuOutsideRegion'>"
68     " <menuitem action='Add'/>"
69     " </popup>"
70     "</ui>";
71     uiManager->add_ui_from_string(ui_info);
72    
73     popup_menu_inside_region = dynamic_cast<Gtk::Menu*>(
74     uiManager->get_widget("/PopupMenuInsideRegion"));
75     popup_menu_outside_region = dynamic_cast<Gtk::Menu*>(
76     uiManager->get_widget("/PopupMenuOutsideRegion"));
77    
78     add_events(Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK |
79     Gdk::POINTER_MOTION_MASK | Gdk::POINTER_MOTION_HINT_MASK);
80    
81 schoenebeck 1322 dimensionManager.region_to_be_changed_signal.connect(
82     region_to_be_changed_signal.make_slot()
83 schoenebeck 1225 );
84 schoenebeck 1322 dimensionManager.region_changed_signal.connect(
85     region_changed_signal.make_slot()
86     );
87     dimensionManager.region_changed_signal.connect(
88     sigc::hide(
89     sigc::mem_fun(*this, &RegionChooser::on_dimension_manager_changed)
90     )
91     );
92 schoenebeck 1225 }
93    
94     RegionChooser::~RegionChooser()
95     {
96     }
97    
98     void RegionChooser::on_realize()
99     {
100     // We need to call the base on_realize()
101     Gtk::DrawingArea::on_realize();
102    
103     // Now we can allocate any additional resources we need
104     Glib::RefPtr<Gdk::Window> window = get_window();
105     gc = Gdk::GC::create(window);
106     window->clear();
107     }
108    
109     bool RegionChooser::on_expose_event(GdkEventExpose* event)
110     {
111     Glib::RefPtr<Gdk::Window> window = get_window();
112     window->clear();
113     const int h = 40;
114     const int w = width - 1;
115     const int bh = int(h * 0.55);
116    
117     Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();
118     Glib::RefPtr<const Gdk::GC> white = get_style()->get_white_gc();
119    
120 persson 1262 Glib::RefPtr<Pango::Context> context = get_pango_context();
121     Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create(context);
122    
123 schoenebeck 1225 window->draw_rectangle(black, false, 0, h1, w, h - 1);
124 persson 1262 gc->set_foreground(grey1);
125     int x1 = int(w * 20.5 / 128.0 + 0.5);
126     int x2 = int(w * 109.5 / 128.0 + 0.5);
127     window->draw_rectangle(gc, true, 1, h1 + 1,
128     x1 - 1, h - 2);
129     window->draw_rectangle(white, true, x1 + 1, h1 + 1, x2 - x1 - 1, h - 2);
130     window->draw_rectangle(gc, true, x2 + 1, h1 + 1,
131     w - x2 - 1, h - 2);
132     int octave = -1;
133 schoenebeck 1225 for (int i = 0 ; i < 128 ; i++) {
134     int note = (i + 3) % 12;
135     int x = int(w * i / 128.0 + 0.5);
136    
137     if (note == 1 || note == 4 || note == 6 || note == 9 || note == 11) {
138     int x2 = int(w * (i + 0.5) / 128.0 + 0.5);
139     window->draw_line(black, x2, h1 + bh, x2, h1 + h);
140    
141     int x3 = int(w * (i + 1) / 128.0 + 0.5);
142     window->draw_rectangle(black, true, x, h1 + 1, x3 - x + 1, bh);
143     } else if (note == 3 || note == 8) {
144     window->draw_line(black, x, h1 + 1, x, h1 + h);
145     }
146 persson 1262 if (note == 3) {
147     char buf[30];
148 schoenebeck 1411 sprintf(buf, "<span size=\"8000\">%d</span>", octave);
149 persson 1262 layout->set_markup(buf);
150     Pango::Rectangle rectangle = layout->get_logical_extents();
151     double text_w = double(rectangle.get_width()) / Pango::SCALE;
152     double text_h = double(rectangle.get_height()) / Pango::SCALE;
153     double x2 = w * (i + 0.75) / 128.0;
154     window->draw_layout(black, int(x2 - text_w / 2 + 1),
155     int(h1 + h - text_h + 0.5), layout);
156     octave++;
157     }
158 schoenebeck 1225 }
159    
160     if (instrument) {
161     int i = 0;
162 persson 1262 gig::Region *next_region;
163 schoenebeck 1225 int x3 = -1;
164     for (gig::Region *r = instrument->GetFirstRegion() ;
165     r ;
166 persson 1262 r = next_region) {
167 schoenebeck 1225
168     if (x3 < 0) x3 = int(w * (r->KeyRange.low) / 128.0 + 0.5);
169 persson 1262 next_region = instrument->GetNextRegion();
170     if (!next_region || r->KeyRange.high + 1 != next_region->KeyRange.low) {
171 schoenebeck 1225 int x2 = int(w * (r->KeyRange.high + 1) / 128.0 + 0.5);
172     window->draw_line(black, x3, 0, x2, 0);
173     window->draw_line(black, x3, h1 - 1, x2, h1 - 1);
174     window->draw_line(black, x2, 1, x2, h1 - 2);
175     window->draw_rectangle(white, true, x3 + 1, 1, x2 - x3 - 1, h1 - 2);
176     x3 = -1;
177     }
178     i++;
179     }
180    
181     for (gig::Region *r = instrument->GetFirstRegion() ;
182     r ;
183     r = instrument->GetNextRegion()) {
184     int x = int(w * (r->KeyRange.low) / 128.0 + 0.5);
185     window->draw_line(black, x, 1, x, h1 - 2);
186     }
187    
188     if (region) {
189     int x1 = int(w * (region->KeyRange.low) / 128.0 + 0.5);
190     int x2 = int(w * (region->KeyRange.high + 1) / 128.0 + 0.5);
191     gc->set_foreground(red);
192     window->draw_rectangle(gc, true, x1 + 1, 1, x2 - x1 - 1, h1 - 2);
193     }
194     }
195     return true;
196     }
197    
198    
199     void RegionChooser::on_size_request(GtkRequisition* requisition)
200     {
201     *requisition = GtkRequisition();
202     requisition->height = 40 + 20;
203     requisition->width = 500;
204     }
205    
206    
207     // not used
208     void RegionChooser::draw_region(int from, int to, const Gdk::Color& color)
209     {
210     const int h = 40;
211     const int w = width;
212     const int bh = int(h * 0.55);
213    
214     Glib::RefPtr<Gdk::Window> window = get_window();
215     gc->set_foreground(color);
216    
217     for (int i = from ; i < to ; i++) {
218     int note = (i + 3) % 12;
219     int x = int(w * i / 128.0 + 0.5) + 1;
220     int x2 = int(w * (i + 1.5) / 128.0 + 0.5);
221     int x3 = int(w * (i + 1) / 128.0 + 0.5);
222     int x4 = int(w * (i - 0.5) / 128 + 0.5) + 1;
223     int w1 = x3 - x;
224     switch (note) {
225     case 0: case 5: case 10:
226     window->draw_rectangle(gc, true, x, h1 + 1, w1, bh);
227     window->draw_rectangle(gc, true, x4, h1 + bh + 1, x2 - x4, h - bh - 2);
228     break;
229     case 2: case 7:
230     window->draw_rectangle(gc, true, x, h1 + 1, w1, bh);
231     window->draw_rectangle(gc, true, x4, h1 + bh + 1, x3 - x4, h - bh - 2);
232     break;
233     case 3: case 8:
234     window->draw_rectangle(gc, true, x, h1 + 1, w1, bh);
235     window->draw_rectangle(gc, true, x, h1 + bh + 1, x2 - x, h - bh - 2);
236     break;
237     default:
238     window->draw_rectangle(gc, true, x, h1 + 1, w1, bh - 1);
239     break;
240     }
241     }
242     }
243    
244     void RegionChooser::set_instrument(gig::Instrument* instrument)
245     {
246     this->instrument = instrument;
247     region = instrument ? instrument->GetFirstRegion() : 0;
248     queue_draw();
249 persson 1261 region_selected();
250 schoenebeck 1225 }
251    
252     bool RegionChooser::on_button_release_event(GdkEventButton* event)
253     {
254     if (resize.active) {
255     get_window()->pointer_ungrab(event->time);
256     resize.active = false;
257    
258     if (resize.mode == resize.moving_high_limit) {
259 persson 1261 if (resize.region->KeyRange.high != resize.pos - 1) {
260 schoenebeck 1336 instrument_struct_to_be_changed_signal.emit(instrument);
261     resize.region->SetKeyRange(
262     resize.region->KeyRange.low, // low
263     resize.pos - 1 // high
264     );
265     instrument_changed.emit();
266     instrument_struct_changed_signal.emit(instrument);
267 persson 1261 }
268 schoenebeck 1225 } else if (resize.mode == resize.moving_low_limit) {
269 persson 1261 if (resize.region->KeyRange.low != resize.pos) {
270 schoenebeck 1336 instrument_struct_to_be_changed_signal.emit(instrument);
271     resize.region->SetKeyRange(
272     resize.pos, // low
273     resize.region->KeyRange.high // high
274     );
275     instrument_changed.emit();
276     instrument_struct_changed_signal.emit(instrument);
277 persson 1261 }
278 schoenebeck 1225 }
279    
280     if (!is_in_resize_zone(event->x, event->y) && cursor_is_resize) {
281     get_window()->set_cursor();
282     cursor_is_resize = false;
283     }
284 persson 1262 } else if (move.active) {
285     get_window()->pointer_ungrab(event->time);
286     move.active = false;
287    
288     if (move.pos) {
289 schoenebeck 1336 instrument_struct_to_be_changed_signal.emit(instrument);
290     region->SetKeyRange(
291     region->KeyRange.low + move.pos,
292     region->KeyRange.high + move.pos
293     );
294 persson 1533 instrument_changed.emit();
295 schoenebeck 1336 instrument_struct_changed_signal.emit(instrument);
296 persson 1262 }
297    
298     if (is_in_resize_zone(event->x, event->y)) {
299     get_window()->set_cursor(Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW));
300     cursor_is_resize = true;
301     }
302 schoenebeck 1225 }
303     return true;
304     }
305    
306     bool RegionChooser::on_button_press_event(GdkEventButton* event)
307     {
308     if (!instrument) return true;
309    
310     int k = int(event->x / (width - 1) * 128.0);
311    
312     if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
313     gig::Region* r = get_region(k);
314     if (r) {
315     region = r;
316     queue_draw();
317 persson 1261 region_selected();
318 schoenebeck 1225 popup_menu_inside_region->popup(event->button, event->time);
319     } else {
320     new_region_pos = k;
321     popup_menu_outside_region->popup(event->button, event->time);
322     }
323     } else {
324     if (is_in_resize_zone(event->x, event->y)) {
325     get_window()->pointer_grab(false,
326     Gdk::BUTTON_RELEASE_MASK |
327     Gdk::POINTER_MOTION_MASK |
328     Gdk::POINTER_MOTION_HINT_MASK,
329 persson 1262 Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW), event->time);
330 schoenebeck 1225 resize.active = true;
331     } else {
332     gig::Region* r = get_region(k);
333     if (r) {
334     region = r;
335     queue_draw();
336 persson 1261 region_selected();
337 persson 1262
338     get_window()->pointer_grab(false,
339     Gdk::BUTTON_RELEASE_MASK |
340     Gdk::POINTER_MOTION_MASK |
341     Gdk::POINTER_MOTION_HINT_MASK,
342     Gdk::Cursor(Gdk::FLEUR), event->time);
343     move.active = true;
344     move.from_x = event->x;
345     move.pos = 0;
346 schoenebeck 1225 }
347     }
348     }
349     return true;
350     }
351    
352     gig::Region* RegionChooser::get_region(int key)
353     {
354 persson 1262 gig::Region* prev_region = 0;
355     gig::Region* next_region;
356 schoenebeck 1225 for (gig::Region *r = instrument->GetFirstRegion() ; r ;
357 persson 1262 r = next_region) {
358     next_region = instrument->GetNextRegion();
359    
360 schoenebeck 1225 if (key < r->KeyRange.low) return 0;
361 persson 1262 if (key <= r->KeyRange.high) {
362     move.touch_left = prev_region && prev_region->KeyRange.high + 1 == r->KeyRange.low;
363     move.touch_right = next_region && r->KeyRange.high + 1 == next_region->KeyRange.low;
364     return r;
365     }
366     prev_region = r;
367 schoenebeck 1225 }
368     return 0;
369     }
370    
371 persson 1262 void RegionChooser::motion_resize_region(int x, int y)
372 schoenebeck 1225 {
373     const int w = width - 1;
374     Glib::RefPtr<Gdk::Window> window = get_window();
375    
376 persson 1262 int k = int(double(x) / w * 128.0 + 0.5);
377 schoenebeck 1225
378 persson 1262 if (k < resize.min) k = resize.min;
379     else if (k > resize.max) k = resize.max;
380    
381     if (k != resize.pos) {
382     if (resize.mode == resize.undecided) {
383     if (k < resize.pos) {
384     // edit high limit of prev_region
385     resize.max = resize.region->KeyRange.low;
386     resize.region = resize.prev_region;
387     resize.mode = resize.moving_high_limit;
388     } else {
389     // edit low limit of region
390     resize.min = resize.prev_region->KeyRange.high + 1;
391     resize.mode = resize.moving_low_limit;
392 schoenebeck 1225 }
393 persson 1262 }
394     Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();
395     Glib::RefPtr<const Gdk::GC> white = get_style()->get_white_gc();
396     if (region == resize.region) {
397     gc->set_foreground(red);
398     white = gc;
399     }
400     Glib::RefPtr<const Gdk::GC> bg = get_style()->get_bg_gc(Gtk::STATE_NORMAL);
401     int prevx = int(w * resize.pos / 128.0 + 0.5);
402     x = int(w * k / 128.0 + 0.5);
403    
404     if (resize.mode == resize.moving_high_limit) {
405     if (k > resize.pos) {
406     window->draw_rectangle(white, true, prevx, 1, x - prevx, h1 - 2);
407     window->draw_line(black, prevx, 0, x, 0);
408     window->draw_line(black, prevx, h1 - 1, x, h1 - 1);
409     } else {
410     int xx = ((resize.pos == resize.max && resize.max != 128) ? 1 : 0);
411     window->draw_rectangle(bg, true, x + 1, 0, prevx - x - xx, h1);
412 schoenebeck 1225 }
413 persson 1262 } else {
414     if (k < resize.pos) {
415     window->draw_rectangle(white, true, x + 1, 1, prevx - x, h1 - 2);
416     window->draw_line(black, x, 0, prevx, 0);
417     window->draw_line(black, x, h1 - 1, prevx, h1 - 1);
418     } else {
419     int xx = ((resize.pos == resize.min && resize.min != 0) ? 1 : 0);
420     window->draw_rectangle(bg, true, prevx + xx, 0, x - prevx - xx, h1);
421     }
422     }
423     window->draw_line(black, x, 1, x, h1 - 2);
424     resize.pos = k;
425     }
426     }
427 schoenebeck 1225
428 persson 1262 void RegionChooser::motion_move_region(int x, int y)
429     {
430     const int w = width - 1;
431     Glib::RefPtr<Gdk::Window> window = get_window();
432    
433     int k = int(double(x - move.from_x) / w * 128.0 + 0.5);
434     if (k == move.pos) return;
435     int new_k;
436     bool new_touch_left;
437     bool new_touch_right;
438     int a = 0;
439     if (k > move.pos) {
440     for (gig::Region* r = instrument->GetFirstRegion() ; ;
441     r = instrument->GetNextRegion()) {
442     if (r != region) {
443     int b = r ? r->KeyRange.low : 128;
444    
445     // gap: from a to b (not inclusive b)
446    
447     if (region->KeyRange.high + move.pos >= b) {
448     // not found the current gap yet, just continue
449 schoenebeck 1225 } else {
450 persson 1262
451     if (a > region->KeyRange.low + k) {
452     // this gap is too far to the right, break
453     break;
454     }
455    
456     int newhigh = std::min(region->KeyRange.high + k, b - 1);
457     int newlo = newhigh - (region->KeyRange.high - region->KeyRange.low);
458    
459     if (newlo >= a) {
460     // yes it fits - it's a candidate
461     new_k = newlo - region->KeyRange.low;
462     new_touch_left = a > 0 && a == newlo;
463     new_touch_right = b < 128 && newhigh + 1 == b;
464     }
465 schoenebeck 1225 }
466 persson 1262 if (!r) break;
467     a = r->KeyRange.high + 1;
468     }
469     }
470     } else {
471     for (gig::Region* r = instrument->GetFirstRegion() ; ;
472     r = instrument->GetNextRegion()) {
473     if (r != region) {
474     int b = r ? r->KeyRange.low : 128;
475    
476     // gap from a to b (not inclusive b)
477    
478     if (region->KeyRange.high + k >= b) {
479     // not found the current gap yet, just continue
480 schoenebeck 1225 } else {
481 persson 1262
482     if (a > region->KeyRange.low + move.pos) {
483     // this gap is too far to the right, break
484     break;
485     }
486    
487     int newlo = std::max(region->KeyRange.low + k, a);
488     int newhigh = newlo + (region->KeyRange.high - region->KeyRange.low);
489    
490     if (newhigh < b) {
491     // yes it fits - break as the first one is the best
492     new_k = newlo - region->KeyRange.low;
493     new_touch_left = a > 0 && a == newlo;
494     new_touch_right = b < 128 && newhigh + 1 == b;
495     break;
496     }
497 schoenebeck 1225 }
498 persson 1262 if (!r) break;
499     a = r->KeyRange.high + 1;
500 schoenebeck 1225 }
501     }
502 persson 1262 }
503     k = new_k;
504     if (k == move.pos) return;
505    
506     Glib::RefPtr<const Gdk::GC> bg = get_style()->get_bg_gc(Gtk::STATE_NORMAL);
507     int prevx = int(w * (move.pos + region->KeyRange.low) / 128.0 + 0.5);
508     x = int(w * (k + region->KeyRange.low) / 128.0 + 0.5);
509     int prevx2 = int(w * (move.pos + region->KeyRange.high + 1) / 128.0 + 0.5);
510     int x2 = int(w * (k + region->KeyRange.high + 1) / 128.0 + 0.5);
511     Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();
512     gc->set_foreground(red);
513    
514     if (!new_touch_left) window->draw_line(black, x, 1, x, h1 - 2);
515     if (!new_touch_right) window->draw_line(black, x2, 1, x2, h1 - 2);
516    
517     if (k > move.pos) {
518     window->draw_rectangle(bg, true, prevx + (move.touch_left ? 1 : 0), 0,
519     std::min(x, prevx2 + 1 - (move.touch_right ? 1 : 0)) -
520     (prevx + (move.touch_left ? 1 : 0)), h1);
521    
522     window->draw_line(black, std::max(x, prevx2 + 1), 0, x2, 0);
523     window->draw_line(black, std::max(x, prevx2 + 1), h1 - 1, x2, h1 - 1);
524     window->draw_rectangle(gc, true, std::max(x + 1, prevx2), 1,
525     x2 - std::max(x + 1, prevx2), h1 - 2);
526 schoenebeck 1225 } else {
527 persson 1262 window->draw_rectangle(bg, true, std::max(x2 + 1, prevx + (move.touch_left ? 1 : 0)), 0,
528     prevx2 + 1 - (move.touch_right ? 1 : 0) -
529     std::max(x2 + 1, prevx + (move.touch_left ? 1 : 0)), h1);
530    
531     window->draw_line(black, x, 0, std::min(x2, prevx - 1), 0);
532     window->draw_line(black, x, h1 - 1, std::min(x2, prevx - 1), h1 - 1);
533    
534     window->draw_rectangle(gc, true, x + 1, 1, std::min(x2 - 1, prevx) - x, h1 - 2);
535     }
536    
537     move.pos = k;
538     move.touch_left = new_touch_left;
539     move.touch_right = new_touch_right;
540     }
541    
542    
543     bool RegionChooser::on_motion_notify_event(GdkEventMotion* event)
544     {
545     Glib::RefPtr<Gdk::Window> window = get_window();
546     int x, y;
547     Gdk::ModifierType state = Gdk::ModifierType(0);
548     window->get_pointer(x, y, state);
549    
550     if (resize.active) {
551     motion_resize_region(x, y);
552     } else if (move.active) {
553     motion_move_region(x, y);
554     } else {
555 schoenebeck 1225 if (is_in_resize_zone(x, y)) {
556     if (!cursor_is_resize) {
557 persson 1262 window->set_cursor(Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW));
558 schoenebeck 1225 cursor_is_resize = true;
559     }
560     } else if (cursor_is_resize) {
561     window->set_cursor();
562     cursor_is_resize = false;
563     }
564     }
565    
566     return true;
567     }
568    
569     bool RegionChooser::is_in_resize_zone(double x, double y) {
570     const int w = width - 1;
571    
572     if (instrument && y >= 0 && y <= h1) {
573     gig::Region* prev_region = 0;
574     gig::Region* next_region;
575     for (gig::Region* r = instrument->GetFirstRegion() ; r ; r = next_region) {
576     next_region = instrument->GetNextRegion();
577    
578     int lo = int(w * (r->KeyRange.low) / 128.0 + 0.5);
579     if (x <= lo - 2) break;
580     if (x < lo + 2) {
581     resize.region = r;
582     resize.pos = r->KeyRange.low;
583     resize.max = r->KeyRange.high;
584    
585     if (prev_region && prev_region->KeyRange.high + 1 == r->KeyRange.low) {
586     // we don't know yet if it's the high limit of
587     // prev_region or the low limit of r that's going
588     // to be edited
589     resize.mode = resize.undecided;
590     resize.min = prev_region->KeyRange.low + 1;
591     resize.prev_region = prev_region;
592     return true;
593     }
594    
595     // edit low limit
596     resize.mode = resize.moving_low_limit;
597     resize.min = prev_region ? prev_region->KeyRange.high + 1 : 0;
598     return true;
599     }
600     if (!next_region || r->KeyRange.high + 1 != next_region->KeyRange.low) {
601     int hi = int(w * (r->KeyRange.high + 1) / 128.0 + 0.5);
602     if (x <= hi - 2) break;
603     if (x < hi + 2) {
604     // edit high limit
605     resize.region = r;
606     resize.pos = r->KeyRange.high + 1;
607     resize.mode = resize.moving_high_limit;
608     resize.min = r->KeyRange.low + 1;
609     resize.max = next_region ? next_region->KeyRange.low : 128;
610     return true;
611     }
612     }
613     prev_region = r;
614     }
615     }
616     return false;
617     }
618    
619 schoenebeck 1339 sigc::signal<void>& RegionChooser::signal_region_selected()
620 schoenebeck 1225 {
621 persson 1261 return region_selected;
622 schoenebeck 1225 }
623    
624 schoenebeck 1339 sigc::signal<void>& RegionChooser::signal_instrument_changed()
625 persson 1261 {
626     return instrument_changed;
627     }
628    
629 schoenebeck 1225 void RegionChooser::show_region_properties()
630     {
631     if (!region) return;
632     Gtk::Dialog dialog("Region Properties", true /*modal*/);
633     // add "Keygroup" checkbox
634     Gtk::CheckButton checkBoxKeygroup("Member of a Keygroup (Exclusive Group)");
635     checkBoxKeygroup.set_active(region->KeyGroup);
636     dialog.get_vbox()->pack_start(checkBoxKeygroup);
637     checkBoxKeygroup.show();
638     // add "Keygroup" spinbox
639     Gtk::Adjustment adjustment(1, 1, pow(2,32));
640     Gtk::SpinButton spinBox(adjustment);
641     if (region->KeyGroup) spinBox.set_value(region->KeyGroup);
642     dialog.get_vbox()->pack_start(spinBox);
643     spinBox.show();
644     // add OK and CANCEL buttons to the dialog
645     dialog.add_button(Gtk::Stock::OK, 0);
646     dialog.add_button(Gtk::Stock::CANCEL, 1);
647     dialog.show_all_children();
648     if (!dialog.run()) { // OK selected ...
649     region->KeyGroup =
650     (checkBoxKeygroup.get_active()) ? spinBox.get_value_as_int() : 0;
651     }
652     }
653    
654     void RegionChooser::add_region()
655     {
656 schoenebeck 1322 instrument_struct_to_be_changed_signal.emit(instrument);
657    
658 schoenebeck 1225 region = instrument->AddRegion();
659 schoenebeck 1336 region->SetKeyRange(new_region_pos, new_region_pos);
660 schoenebeck 1225
661 schoenebeck 1322 instrument_struct_changed_signal.emit(instrument);
662    
663 schoenebeck 1225 queue_draw();
664 persson 1261 region_selected();
665     instrument_changed();
666 schoenebeck 1225 }
667    
668     void RegionChooser::delete_region()
669     {
670 schoenebeck 1322 instrument_struct_to_be_changed_signal.emit(instrument);
671 schoenebeck 1225 instrument->DeleteRegion(region);
672 schoenebeck 1322 instrument_struct_changed_signal.emit(instrument);
673    
674 schoenebeck 1225 region = 0;
675     queue_draw();
676 persson 1261 region_selected();
677     instrument_changed();
678 schoenebeck 1225 }
679    
680     void RegionChooser::manage_dimensions()
681     {
682     gig::Region* region = get_region();
683     if (!region) return;
684     dimensionManager.show(region);
685     }
686    
687     void RegionChooser::on_dimension_manager_changed() {
688 persson 1261 region_selected();
689     instrument_changed();
690 schoenebeck 1225 }
691 schoenebeck 1322
692 schoenebeck 1339 sigc::signal<void, gig::Instrument*>& RegionChooser::signal_instrument_struct_to_be_changed() {
693 schoenebeck 1322 return instrument_struct_to_be_changed_signal;
694     }
695    
696 schoenebeck 1339 sigc::signal<void, gig::Instrument*>& RegionChooser::signal_instrument_struct_changed() {
697 schoenebeck 1322 return instrument_struct_changed_signal;
698     }
699    
700 schoenebeck 1339 sigc::signal<void, gig::Region*>& RegionChooser::signal_region_to_be_changed() {
701 schoenebeck 1322 return region_to_be_changed_signal;
702     }
703    
704 schoenebeck 1339 sigc::signal<void, gig::Region*>& RegionChooser::signal_region_changed_signal() {
705 schoenebeck 1322 return region_changed_signal;
706     }

  ViewVC Help
Powered by ViewVC