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

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

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

revision 1225 by schoenebeck, Sun Jun 10 10:56:11 2007 UTC revision 2169 by persson, Sun Mar 6 07:51:04 2011 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (C) 2006, 2007 Andreas Persson   * Copyright (C) 2006-2011 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 "dimregionchooser.h"  #include "dimregionchooser.h"
21    #include <cairomm/context.h>
22  #include <gdkmm/cursor.h>  #include <gdkmm/cursor.h>
23    #include <gdkmm/general.h>
24    
25  DimRegionChooser::DimRegionChooser()  #include "global.h"
26    
27    DimRegionChooser::DimRegionChooser() :
28        red("#8070ff"),
29        black("black"),
30        white("white")
31  {  {
     // get_window() would return 0 because the Gdk::Window has not yet been realized  
     // So we can only allocate the colors here - the rest will happen in on_realize().  
     Glib::RefPtr<Gdk::Colormap> colormap = get_default_colormap();  
   
     black = Gdk::Color("black");  
     white = Gdk::Color("white");  
     red = Gdk::Color("#8070ff");  
     blue = Gdk::Color("blue");  
     green = Gdk::Color("green");  
   
     colormap->alloc_color(black);  
     colormap->alloc_color(white);  
     colormap->alloc_color(red);  
     colormap->alloc_color(blue);  
     colormap->alloc_color(green);  
32      instrument = 0;      instrument = 0;
33      region = 0;      region = 0;
34      dimregno = -1;      dimregno = -1;
# Line 44  DimRegionChooser::DimRegionChooser() Line 36  DimRegionChooser::DimRegionChooser()
36      resize.active = false;      resize.active = false;
37      cursor_is_resize = false;      cursor_is_resize = false;
38      h = 20;      h = 20;
39      w = 800;      set_can_focus();
     set_flags(Gtk::CAN_FOCUS);  
40      add_events(Gdk::BUTTON_PRESS_MASK | Gdk::POINTER_MOTION_MASK |      add_events(Gdk::BUTTON_PRESS_MASK | Gdk::POINTER_MOTION_MASK |
41                 Gdk::POINTER_MOTION_HINT_MASK);                 Gdk::POINTER_MOTION_HINT_MASK);
42    
43      for (int i = 0 ; i < 256 ; i++) {      for (int i = 0 ; i < 256 ; i++) dimvalue[i] = 0;
         dimvalue_from[i] = 0;  
         dimvalue_to[i] = 1;  
     }  
44  }  }
45    
46  DimRegionChooser::~DimRegionChooser()  DimRegionChooser::~DimRegionChooser()
47  {  {
48  }  }
49    
50  void DimRegionChooser::on_realize()  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
51    bool DimRegionChooser::on_expose_event(GdkEventExpose* e)
52  {  {
53      // We need to call the base on_realize()      return on_draw(get_window()->create_cairo_context());
     Gtk::DrawingArea::on_realize();  
   
     // Now we can allocate any additional resources we need  
     Glib::RefPtr<Gdk::Window> window = get_window();  
     gc = Gdk::GC::create(window);  
54  }  }
55    #endif
56    
57  bool DimRegionChooser::on_expose_event(GdkEventExpose* event)  bool DimRegionChooser::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
58  {  {
59      if (!region) return true;      if (!region) return true;
60    
61      // This is where we draw on the window      // This is where we draw on the window
62      Glib::RefPtr<Gdk::Window> window = get_window();      int w = get_width();
63      Glib::RefPtr<Pango::Context> context = get_pango_context();      Glib::RefPtr<Pango::Context> context = get_pango_context();
64    
65      Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create(context);      Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create(context);
66        cr->set_line_width(1);
     window->clear();  
67    
68      // draw labels on the left (reflecting the dimension type)      // draw labels on the left (reflecting the dimension type)
69      int y = 0;      int y = 0;
# Line 90  bool DimRegionChooser::on_expose_event(G Line 74  bool DimRegionChooser::on_expose_event(G
74              const char* dstr;              const char* dstr;
75              char dstrbuf[10];              char dstrbuf[10];
76              switch (region->pDimensionDefinitions[i].dimension) {              switch (region->pDimensionDefinitions[i].dimension) {
77              case gig::dimension_none: dstr="none"; break;              case gig::dimension_none: dstr=_("none"); break;
78              case gig::dimension_samplechannel: dstr="samplechannel"; break;              case gig::dimension_samplechannel: dstr=_("samplechannel"); break;
79              case gig::dimension_layer: dstr="layer"; break;              case gig::dimension_layer: dstr=_("layer"); break;
80              case gig::dimension_velocity: dstr="velocity"; break;              case gig::dimension_velocity: dstr=_("velocity"); break;
81              case gig::dimension_channelaftertouch: dstr="channelaftertouch"; break;              case gig::dimension_channelaftertouch: dstr=_("channelaftertouch"); break;
82              case gig::dimension_releasetrigger: dstr="releasetrigger"; break;              case gig::dimension_releasetrigger: dstr=_("releasetrigger"); break;
83              case gig::dimension_keyboard: dstr="keyboard"; break;              case gig::dimension_keyboard: dstr=_("keyswitching"); break;
84              case gig::dimension_roundrobin: dstr="roundrobin"; break;              case gig::dimension_roundrobin: dstr=_("roundrobin"); break;
85              case gig::dimension_random: dstr="random"; break;              case gig::dimension_random: dstr=_("random"); break;
86              case gig::dimension_smartmidi: dstr="smartmidi"; break;              case gig::dimension_smartmidi: dstr=_("smartmidi"); break;
87              case gig::dimension_roundrobinkeyboard: dstr="roundrobinkeyboard"; break;              case gig::dimension_roundrobinkeyboard: dstr=_("roundrobinkeyboard"); break;
88              case gig::dimension_modwheel: dstr="modwheel"; break;              case gig::dimension_modwheel: dstr=_("modwheel"); break;
89              case gig::dimension_breath: dstr="breath"; break;              case gig::dimension_breath: dstr=_("breath"); break;
90              case gig::dimension_foot: dstr="foot"; break;              case gig::dimension_foot: dstr=_("foot"); break;
91              case gig::dimension_portamentotime: dstr="portamentotime"; break;              case gig::dimension_portamentotime: dstr=_("portamentotime"); break;
92              case gig::dimension_effect1: dstr="effect1"; break;              case gig::dimension_effect1: dstr=_("effect1"); break;
93              case gig::dimension_effect2: dstr="effect2"; break;              case gig::dimension_effect2: dstr=_("effect2"); break;
94              case gig::dimension_genpurpose1: dstr="genpurpose1"; break;              case gig::dimension_genpurpose1: dstr=_("genpurpose1"); break;
95              case gig::dimension_genpurpose2: dstr="genpurpose2"; break;              case gig::dimension_genpurpose2: dstr=_("genpurpose2"); break;
96              case gig::dimension_genpurpose3: dstr="genpurpose3"; break;              case gig::dimension_genpurpose3: dstr=_("genpurpose3"); break;
97              case gig::dimension_genpurpose4: dstr="genpurpose4"; break;              case gig::dimension_genpurpose4: dstr=_("genpurpose4"); break;
98              case gig::dimension_sustainpedal: dstr="sustainpedal"; break;              case gig::dimension_sustainpedal: dstr=_("sustainpedal"); break;
99              case gig::dimension_portamento: dstr="portamento"; break;              case gig::dimension_portamento: dstr=_("portamento"); break;
100              case gig::dimension_sostenutopedal: dstr="sostenutopedal"; break;              case gig::dimension_sostenutopedal: dstr=_("sostenutopedal"); break;
101              case gig::dimension_softpedal: dstr="softpedal"; break;              case gig::dimension_softpedal: dstr=_("softpedal"); break;
102              case gig::dimension_genpurpose5: dstr="genpurpose5"; break;              case gig::dimension_genpurpose5: dstr=_("genpurpose5"); break;
103              case gig::dimension_genpurpose6: dstr="genpurpose6"; break;              case gig::dimension_genpurpose6: dstr=_("genpurpose6"); break;
104              case gig::dimension_genpurpose7: dstr="genpurpose7"; break;              case gig::dimension_genpurpose7: dstr=_("genpurpose7"); break;
105              case gig::dimension_genpurpose8: dstr="genpurpose8"; break;              case gig::dimension_genpurpose8: dstr=_("genpurpose8"); break;
106              case gig::dimension_effect1depth: dstr="effect1depth"; break;              case gig::dimension_effect1depth: dstr=_("effect1depth"); break;
107              case gig::dimension_effect2depth: dstr="effect2depth"; break;              case gig::dimension_effect2depth: dstr=_("effect2depth"); break;
108              case gig::dimension_effect3depth: dstr="effect3depth"; break;              case gig::dimension_effect3depth: dstr=_("effect3depth"); break;
109              case gig::dimension_effect4depth: dstr="effect4depth"; break;              case gig::dimension_effect4depth: dstr=_("effect4depth"); break;
110              case gig::dimension_effect5depth: dstr="effect5depth"; break;              case gig::dimension_effect5depth: dstr=_("effect5depth"); break;
111              default:              default:
112                  sprintf(dstrbuf, "%d",                  sprintf(dstrbuf, "%d",
113                          region->pDimensionDefinitions[i].dimension);                          region->pDimensionDefinitions[i].dimension);
# Line 136  bool DimRegionChooser::on_expose_event(G Line 120  bool DimRegionChooser::on_expose_event(G
120              double text_w = double(rectangle.get_width()) / Pango::SCALE;              double text_w = double(rectangle.get_width()) / Pango::SCALE;
121              if (text_w > maxwidth) maxwidth = text_w;              if (text_w > maxwidth) maxwidth = text_w;
122              double text_h = double(rectangle.get_height()) / Pango::SCALE;              double text_h = double(rectangle.get_height()) / Pango::SCALE;
123              Glib::RefPtr<const Gdk::GC> fg = get_style()->get_fg_gc(get_state());  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
124              window->draw_layout(fg, 4, int(y + (h - text_h) / 2 + 0.5), layout);              const Gdk::Color fg = get_style()->get_fg(get_state());
125    #else
126                const Gdk::RGBA fg = get_style_context()->get_color(get_state_flags());
127    #endif
128                Gdk::Cairo::set_source_rgba(cr, fg);
129                cr->move_to(4, int(y + (h - text_h) / 2 + 0.5));
130    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 16) || GTKMM_MAJOR_VERSION < 2
131                pango_cairo_show_layout(cr->cobj(), layout->gobj());
132    #else
133                layout->show_in_cairo_context(cr);
134    #endif
135          }          }
136          y += h;          y += h;
137      }      }
# Line 152  bool DimRegionChooser::on_expose_event(G Line 145  bool DimRegionChooser::on_expose_event(G
145          if (nbZones) {          if (nbZones) {
146              // draw focus rectangle around dimension's label and zones              // draw focus rectangle around dimension's label and zones
147              if (has_focus() && focus_line == i) {              if (has_focus() && focus_line == i) {
148    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
149                  Gdk::Rectangle farea(0, y, 150, 20);                  Gdk::Rectangle farea(0, y, 150, 20);
150                  get_style()->paint_focus(window, get_state(), farea, *this, "",                  get_style()->paint_focus(get_window(), get_state(), farea, *this, "",
151                                           0, y, label_width, 20);                                           0, y, label_width, 20);
152    #else
153                    get_style_context()->render_focus(cr, 0, y, label_width, 20);
154    #endif
155              }              }
156    
             Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();  
157              // draw top and bottom lines of dimension's zones              // draw top and bottom lines of dimension's zones
158              window->draw_line(black, label_width, y, w - 1, y);              Gdk::Cairo::set_source_rgba(cr, black);
159              window->draw_line(black, w - 1, y + h - 1, label_width, y + h - 1);              cr->move_to(label_width, y + 0.5);
160                cr->line_to(w, y + 0.5);
161                cr->move_to(w, y + h - 0.5);
162                cr->line_to(label_width, y + h - 0.5);
163                cr->stroke();
164    
165              // erase whole dimension's zones area              // erase whole dimension's zones area
166              window->draw_rectangle(get_style()->get_white_gc(), true,              Gdk::Cairo::set_source_rgba(cr, white);
167                                     label_width + 1, y + 1, (w - label_width - 2), h - 2);              cr->rectangle(label_width + 1, y + 1, (w - label_width - 2), h - 2);
168                cr->fill();
169    
170              int c = 0;              int c = 0;
171              if (dimregno >= 0) {              if (dimregno >= 0) {
# Line 177  bool DimRegionChooser::on_expose_event(G Line 179  bool DimRegionChooser::on_expose_event(G
179                   region->pDimensionRegions[c]->VelocityUpperLimit));                   region->pDimensionRegions[c]->VelocityUpperLimit));
180    
181              // draw dimension's zone borders              // draw dimension's zone borders
182                Gdk::Cairo::set_source_rgba(cr, black);
183              if (customsplits) {              if (customsplits) {
184                  window->draw_line(black, label_width, y + 1, label_width, y + h - 2);                  cr->move_to(label_width + 0.5, y + 1);
185                    cr->line_to(label_width + 0.5, y + h - 1);
186    
187                  for (int j = 0 ; j < nbZones ; j++) {                  for (int j = 0 ; j < nbZones ; j++) {
188                      gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];                      gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
189                      int upperLimit = d->DimensionUpperLimits[i];                      int upperLimit = d->DimensionUpperLimits[i];
190                      if (!upperLimit) upperLimit = d->VelocityUpperLimit;                      if (!upperLimit) upperLimit = d->VelocityUpperLimit;
191                      int v = upperLimit + 1;                      int v = upperLimit + 1;
192                      int x = int((w - label_width - 1) * v / 128.0 + 0.5);                      int x = int((w - label_width - 1) * v / 128.0 + 0.5);
193                      window->draw_line(black, label_width + x, y + 1, label_width + x, y + h - 2);                      cr->move_to(label_width + x + 0.5, y + 1);
194                        cr->line_to(label_width + x + 0.5, y + h - 1);
195                  }                  }
196              } else {              } else {
197                  for (int j = 0 ; j <= nbZones ; j++) {                  for (int j = 0 ; j <= nbZones ; j++) {
198                      int x = int((w - label_width - 1) * j / double(nbZones) + 0.5);                      int x = int((w - label_width - 1) * j / double(nbZones) + 0.5);
199                      window->draw_line(black, label_width + x, y + 1, label_width + x, y + h - 2);                      cr->move_to(label_width + x + 0.5, y + 1);
200                        cr->line_to(label_width + x + 0.5, y + h - 1);
201                  }                  }
202              }              }
203                cr->stroke();
204    
205              // draw fill for currently selected zone              // draw fill for currently selected zone
206              if (dimregno >= 0) {              if (dimregno >= 0) {
207                  gc->set_foreground(red);                  Gdk::Cairo::set_source_rgba(cr, red);
208                  int dr = (dimregno >> bitpos) & ((1 << region->pDimensionDefinitions[i].bits) - 1);                  int dr = (dimregno >> bitpos) & ((1 << region->pDimensionDefinitions[i].bits) - 1);
209                  if (customsplits) {                  if (customsplits) {
210                      int x1 = 0;                      int x1 = 0;
# Line 207  bool DimRegionChooser::on_expose_event(G Line 215  bool DimRegionChooser::on_expose_event(G
215                          int v = upperLimit + 1;                          int v = upperLimit + 1;
216                          int x2 = int((w - label_width - 1) * v / 128.0 + 0.5);                          int x2 = int((w - label_width - 1) * v / 128.0 + 0.5);
217                          if (j == dr && x1 < x2) {                          if (j == dr && x1 < x2) {
218                              window->draw_rectangle(gc, true, label_width + x1 + 1, y + 1,                              cr->rectangle(label_width + x1 + 1, y + 1,
219                                                     (x2 - x1) - 1, h - 2);                                            (x2 - x1) - 1, h - 2);
220                                cr->fill();
221                              break;                              break;
222                          }                          }
223                          x1 = x2;                          x1 = x2;
# Line 217  bool DimRegionChooser::on_expose_event(G Line 226  bool DimRegionChooser::on_expose_event(G
226                      if (dr < nbZones) {                      if (dr < nbZones) {
227                          int x1 = int((w - label_width - 1) * dr / double(nbZones) + 0.5);                          int x1 = int((w - label_width - 1) * dr / double(nbZones) + 0.5);
228                          int x2 = int((w - label_width - 1) * (dr + 1) / double(nbZones) + 0.5);                          int x2 = int((w - label_width - 1) * (dr + 1) / double(nbZones) + 0.5);
229                          window->draw_rectangle(gc, true, label_width + x1 + 1, y + 1,                          cr->rectangle(label_width + x1 + 1, y + 1,
230                                                 (x2 - x1) - 1, h - 2);                                        (x2 - x1) - 1, h - 2);
231                            cr->fill();
232                      }                      }
233                  }                  }
234              }              }
# Line 231  bool DimRegionChooser::on_expose_event(G Line 241  bool DimRegionChooser::on_expose_event(G
241      return true;      return true;
242  }  }
243    
 void DimRegionChooser::on_size_request(GtkRequisition* requisition)  
 {  
     printf("DimRegionChooser::on_size_request\n");  
     *requisition = GtkRequisition();  
     requisition->height = region ? nbDimensions * 20 : 0;  
     requisition->width = 800;  
 }  
   
244  void DimRegionChooser::set_region(gig::Region* region)  void DimRegionChooser::set_region(gig::Region* region)
245  {  {
246      this->region = region;      this->region = region;
# Line 250  void DimRegionChooser::set_region(gig::R Line 252  void DimRegionChooser::set_region(gig::R
252              if (region->pDimensionDefinitions[dim].bits == 0) continue;              if (region->pDimensionDefinitions[dim].bits == 0) continue;
253              nbDimensions++;              nbDimensions++;
254    
255              int from = dimvalue_from[region->pDimensionDefinitions[dim].dimension];              int z = std::min(dimvalue[region->pDimensionDefinitions[dim].dimension],
256              int to = dimvalue_to[region->pDimensionDefinitions[dim].dimension];                               region->pDimensionDefinitions[dim].zones - 1);
             int z;  
             switch (region->pDimensionDefinitions[dim].split_type) {  
             case gig::split_type_normal:  
                 z = int((to + from) / 2.0 / region->pDimensionDefinitions[dim].zone_size);  
                 break;  
             case gig::split_type_bit:  
                 z = std::min(from, region->pDimensionDefinitions[dim].zones - 1);  
                 break;  
             }  
             int mask =  
                 ~(((1 << region->pDimensionDefinitions[dim].bits) - 1) <<  
                   bitcount);  
             dimregno &= mask;  
257              dimregno |= (z << bitcount);              dimregno |= (z << bitcount);
258              bitcount += region->pDimensionDefinitions[dim].bits;              bitcount += region->pDimensionDefinitions[dim].bits;
259          }          }
# Line 272  void DimRegionChooser::set_region(gig::R Line 261  void DimRegionChooser::set_region(gig::R
261      } else {      } else {
262          dimreg = 0;          dimreg = 0;
263      }      }
264      sel_changed_signal.emit();      dimregion_selected();
265        set_size_request(800, region ? nbDimensions * 20 : 0);
266    
267      queue_resize();      queue_resize();
268  }  }
269    
270    
271    void DimRegionChooser::get_dimregions(const gig::Region* region, bool stereo,
272                                          std::set<gig::DimensionRegion*>& dimregs) const
273    {
274        int dimregno = 0;
275        int bitcount = 0;
276        int stereo_bit = 0;
277        for (int dim = 0 ; dim < region->Dimensions ; dim++) {
278            if (region->pDimensionDefinitions[dim].bits == 0) continue;
279            if (stereo &&
280                region->pDimensionDefinitions[dim].dimension == gig::dimension_samplechannel) {
281                stereo_bit = (1 << bitcount);
282            } else {
283                int z = std::min(dimvalue[region->pDimensionDefinitions[dim].dimension],
284                                 region->pDimensionDefinitions[dim].zones - 1);
285                dimregno |= (z << bitcount);
286            }
287            bitcount += region->pDimensionDefinitions[dim].bits;
288        }
289        dimregs.insert(region->pDimensionRegions[dimregno]);
290        if (stereo_bit) dimregs.insert(region->pDimensionRegions[dimregno | stereo_bit]);
291    }
292    
293    
294  bool DimRegionChooser::on_button_release_event(GdkEventButton* event)  bool DimRegionChooser::on_button_release_event(GdkEventButton* event)
295  {  {
296      if (resize.active) {      if (resize.active) {
297    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
298          get_window()->pointer_ungrab(event->time);          get_window()->pointer_ungrab(event->time);
299    #else
300            Glib::wrap(event->device, true)->ungrab(event->time);
301    #endif
302          resize.active = false;          resize.active = false;
303    
304          if (region->pDimensionDefinitions[resize.dimension].dimension == gig::dimension_velocity) {          if (region->pDimensionDefinitions[resize.dimension].dimension == gig::dimension_velocity) {
# Line 353  bool DimRegionChooser::on_button_release Line 372  bool DimRegionChooser::on_button_release
372                  i = (i & ~((1 << bitpos) - 1)) + (1 << bitpos);                  i = (i & ~((1 << bitpos) - 1)) + (1 << bitpos);
373              }              }
374          }          }
375            region_changed();
376    
377          if (!is_in_resize_zone(event->x, event->y) && cursor_is_resize) {          if (!is_in_resize_zone(event->x, event->y) && cursor_is_resize) {
378              get_window()->set_cursor();              get_window()->set_cursor();
# Line 364  bool DimRegionChooser::on_button_release Line 384  bool DimRegionChooser::on_button_release
384    
385  bool DimRegionChooser::on_button_press_event(GdkEventButton* event)  bool DimRegionChooser::on_button_press_event(GdkEventButton* event)
386  {  {
387        int w = get_width();
388      if (region && event->y < nbDimensions * h &&      if (region && event->y < nbDimensions * h &&
389          event->x >= label_width && event->x < w) {          event->x >= label_width && event->x < w) {
390    
391          if (is_in_resize_zone(event->x, event->y)) {          if (is_in_resize_zone(event->x, event->y)) {
392              Gdk::Cursor double_arrow(Gdk::SB_H_DOUBLE_ARROW);  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
393              get_window()->pointer_grab(false,              get_window()->pointer_grab(false,
394                                         Gdk::BUTTON_RELEASE_MASK |                                         Gdk::BUTTON_RELEASE_MASK |
395                                         Gdk::POINTER_MOTION_MASK |                                         Gdk::POINTER_MOTION_MASK |
396                                         Gdk::POINTER_MOTION_HINT_MASK,                                         Gdk::POINTER_MOTION_HINT_MASK,
397                                         double_arrow, event->time);                                         Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW),
398                                           event->time);
399    #else
400                Glib::wrap(event->device, true)->grab(get_window(),
401                                                      Gdk::OWNERSHIP_NONE,
402                                                      false,
403                                                      Gdk::BUTTON_RELEASE_MASK |
404                                                      Gdk::POINTER_MOTION_MASK |
405                                                      Gdk::POINTER_MOTION_HINT_MASK,
406                                                      Gdk::Cursor::create(Gdk::SB_H_DOUBLE_ARROW),
407                                                      event->time);
408    #endif
409              resize.active = true;              resize.active = true;
410          } else {          } else {
411              int ydim = int(event->y / h);              int ydim = int(event->y / h);
# Line 424  bool DimRegionChooser::on_button_press_e Line 456  bool DimRegionChooser::on_button_press_e
456                     region->pDimensionDefinitions[dim].split_type,                     region->pDimensionDefinitions[dim].split_type,
457                     region->pDimensionDefinitions[dim].zones,                     region->pDimensionDefinitions[dim].zones,
458                     region->pDimensionDefinitions[dim].zone_size);                     region->pDimensionDefinitions[dim].zone_size);
459  #if 0              dimvalue[region->pDimensionDefinitions[dim].dimension] = z;
             switch (region->pDimensionDefinitions[dim].split_type) {  
             case gig::split_type_normal:  
                 dimvalue_from[region->pDimensionDefinitions[dim].dimension] =  
                     int(z * region->pDimensionDefinitions[dim].zone_size);  
                 dimvalue_to[region->pDimensionDefinitions[dim].dimension] =  
                     int((z + 1) * region->pDimensionDefinitions[dim].zone_size) - 1;  
                 break;  
             case gig::split_type_bit:  
                 dimvalue_from[region->pDimensionDefinitions[dim].dimension] = z;  
                 dimvalue_to[region->pDimensionDefinitions[dim].dimension] = z + 1;  
                 break;  
             }  
 #endif  
460    
461              dimregno = c | (z << bitpos);              dimregno = c | (z << bitpos);
462    
# Line 445  bool DimRegionChooser::on_button_press_e Line 464  bool DimRegionChooser::on_button_press_e
464              if (has_focus()) queue_draw();              if (has_focus()) queue_draw();
465              else grab_focus();              else grab_focus();
466              dimreg = region->pDimensionRegions[dimregno];              dimreg = region->pDimensionRegions[dimregno];
467              sel_changed_signal.emit();              dimregion_selected();
468          }          }
469      }      }
470      return true;      return true;
# Line 459  bool DimRegionChooser::on_motion_notify_ Line 478  bool DimRegionChooser::on_motion_notify_
478      window->get_pointer(x, y, state);      window->get_pointer(x, y, state);
479    
480      if (resize.active) {      if (resize.active) {
481            int w = get_width();
482          int k = int((x - label_width) * 128.0 / (w - label_width - 1) + 0.5);          int k = int((x - label_width) * 128.0 / (w - label_width - 1) + 0.5);
483    
484          if (k < resize.min) k = resize.min;          if (k < resize.min) k = resize.min;
# Line 467  bool DimRegionChooser::on_motion_notify_ Line 487  bool DimRegionChooser::on_motion_notify_
487          if (k < 2) k = 2; // k is upper limit + 1, upper limit 0 is forbidden          if (k < 2) k = 2; // k is upper limit + 1, upper limit 0 is forbidden
488    
489          if (k != resize.pos) {          if (k != resize.pos) {
490              Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();              Cairo::RefPtr<Cairo::Context> cr = get_window()->create_cairo_context();
491              Glib::RefPtr<const Gdk::GC> white = get_style()->get_white_gc();              cr->set_line_width(1);
492    
493              int prevx = int((w - label_width - 1) * resize.pos / 128.0 + 0.5) + label_width;              int prevx = int((w - label_width - 1) * resize.pos / 128.0 + 0.5) + label_width;
494              int x = int((w - label_width - 1) * k / 128.0 + 0.5) + label_width;              int x = int((w - label_width - 1) * k / 128.0 + 0.5) + label_width;
# Line 476  bool DimRegionChooser::on_motion_notify_ Line 496  bool DimRegionChooser::on_motion_notify_
496    
497              if (resize.selected == resize.none) {              if (resize.selected == resize.none) {
498                  if (resize.pos != resize.min && resize.pos != resize.max) {                  if (resize.pos != resize.min && resize.pos != resize.max) {
499                      window->draw_line(white, prevx, y + 1, prevx, y + h - 2);                      Gdk::Cairo::set_source_rgba(cr, white);
500                        cr->move_to(prevx + 0.5, y + 1);
501                        cr->line_to(prevx + 0.5, y + h - 1);
502                        cr->stroke();
503                  }                  }
504              } else {              } else {
505                  gc->set_foreground(red);                  Gdk::RGBA left;
506                    Gdk::RGBA right;
                 Glib::RefPtr<const Gdk::GC> left;  
                 Glib::RefPtr<const Gdk::GC> right;  
507                  if (resize.selected == resize.left) {                  if (resize.selected == resize.left) {
508                      left = gc;                      left = red;
509                      right = white;                      right = white;
510                  } else {                  } else {
511                      left = white;                      left = white;
512                      right = gc;                      right = red;
513                  }                  }
514    
515                  if (k > resize.pos) {                  if (k > resize.pos) {
516                      int xx = resize.pos == resize.min ? 1 : 0;                      int xx = resize.pos == resize.min ? 1 : 0;
517                      window->draw_rectangle(left, true,                      Gdk::Cairo::set_source_rgba(cr, left);
518                                             prevx + xx, y + 1, x - prevx - xx, h - 2);                      cr->rectangle(prevx + xx, y + 1, x - prevx - xx, h - 2);
519                  } else {                  } else {
520                      int xx = resize.pos == resize.max ? 0 : 1;                      int xx = resize.pos == resize.max ? 0 : 1;
521                      window->draw_rectangle(right, true,                      Gdk::Cairo::set_source_rgba(cr, right);
522                                             x, y + 1, prevx - x + xx, h - 2);                      cr->rectangle(x, y + 1, prevx - x + xx, h - 2);
523                  }                  }
524                    cr->fill();
525              }              }
526              window->draw_line(black, x, y + 1, x, y + h - 2);              Gdk::Cairo::set_source_rgba(cr, black);
527                cr->move_to(x + 0.5, y + 1);
528                cr->line_to(x + 0.5, y + h - 1);
529                cr->stroke();
530    
531              resize.pos = k;              resize.pos = k;
532          }          }
533      } else {      } else {
534          if (is_in_resize_zone(x, y)) {          if (is_in_resize_zone(x, y)) {
535              if (!cursor_is_resize) {              if (!cursor_is_resize) {
536                  Gdk::Cursor double_arrow(Gdk::SB_H_DOUBLE_ARROW);  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
537                  window->set_cursor(double_arrow);                  window->set_cursor(Gdk::Cursor(Gdk::SB_H_DOUBLE_ARROW));
538    #else
539                    window->set_cursor(Gdk::Cursor::create(Gdk::SB_H_DOUBLE_ARROW));
540    #endif
541                  cursor_is_resize = true;                  cursor_is_resize = true;
542              }              }
543          } else if (cursor_is_resize) {          } else if (cursor_is_resize) {
# Line 521  bool DimRegionChooser::on_motion_notify_ Line 550  bool DimRegionChooser::on_motion_notify_
550    
551  bool DimRegionChooser::is_in_resize_zone(double x, double y)  bool DimRegionChooser::is_in_resize_zone(double x, double y)
552  {  {
553        int w = get_width();
554      if (region && y < nbDimensions * h && x >= label_width && x < w) {      if (region && y < nbDimensions * h && x >= label_width && x < w) {
555          int ydim = int(y / h);          int ydim = int(y / h);
556          int dim;          int dim;
# Line 588  bool DimRegionChooser::is_in_resize_zone Line 618  bool DimRegionChooser::is_in_resize_zone
618      return false;      return false;
619  }  }
620    
621  sigc::signal<void> DimRegionChooser::signal_sel_changed()  sigc::signal<void>& DimRegionChooser::signal_dimregion_selected()
622    {
623        return dimregion_selected;
624    }
625    
626    sigc::signal<void>& DimRegionChooser::signal_region_changed()
627  {  {
628      return sel_changed_signal;      return region_changed;
629  }  }
630    
631  bool DimRegionChooser::on_focus(Gtk::DirectionType direction)  bool DimRegionChooser::on_focus(Gtk::DirectionType direction)
Legend:
Removed from v.1225  
changed lines
  Added in v.2169
  ViewVC Help
Powered by ViewVC