/[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 2245 by persson, Sun Mar 6 07:51:04 2011 UTC revision 2246 by persson, Fri Aug 19 10:55:41 2011 UTC
# Line 41  DimRegionChooser::DimRegionChooser() : Line 41  DimRegionChooser::DimRegionChooser() :
41                 Gdk::POINTER_MOTION_HINT_MASK);                 Gdk::POINTER_MOTION_HINT_MASK);
42    
43      for (int i = 0 ; i < 256 ; i++) dimvalue[i] = 0;      for (int i = 0 ; i < 256 ; i++) dimvalue[i] = 0;
44        labels_changed = true;
45  }  }
46    
47  DimRegionChooser::~DimRegionChooser()  DimRegionChooser::~DimRegionChooser()
# Line 50  DimRegionChooser::~DimRegionChooser() Line 51  DimRegionChooser::~DimRegionChooser()
51  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
52  bool DimRegionChooser::on_expose_event(GdkEventExpose* e)  bool DimRegionChooser::on_expose_event(GdkEventExpose* e)
53  {  {
54      return on_draw(get_window()->create_cairo_context());      double clipx1 = e->area.x;
55        double clipx2 = e->area.x + e->area.width;
56        double clipy1 = e->area.y;
57        double clipy2 = e->area.y + e->area.height;
58    
59        const Cairo::RefPtr<Cairo::Context>& cr =
60            get_window()->create_cairo_context();
61    #if 0
62  }  }
63  #endif  #endif
64    #else
65  bool DimRegionChooser::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)  bool DimRegionChooser::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
66  {  {
67        double clipx1, clipx2, clipy1, clipy2;
68        cr->get_clip_extents(clipx1, clipy1, clipx2, clipy2);
69    #endif
70    
71      if (!region) return true;      if (!region) return true;
72    
73      // This is where we draw on the window      // This is where we draw on the window
# Line 65  bool DimRegionChooser::on_draw(const Cai Line 77  bool DimRegionChooser::on_draw(const Cai
77      Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create(context);      Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create(context);
78      cr->set_line_width(1);      cr->set_line_width(1);
79    
     // draw labels on the left (reflecting the dimension type)  
80      int y = 0;      int y = 0;
81      double maxwidth = 0;      if (labels_changed || label_width - 10 > clipx1) {
82      for (int i = 0 ; i < region->Dimensions ; i++) {          // draw labels on the left (reflecting the dimension type)
83          int nbZones = region->pDimensionDefinitions[i].zones;          double maxwidth = 0;
84          if (nbZones) {          for (int i = 0 ; i < region->Dimensions ; i++) {
85              const char* dstr;              int nbZones = region->pDimensionDefinitions[i].zones;
86              char dstrbuf[10];              if (nbZones) {
87              switch (region->pDimensionDefinitions[i].dimension) {                  const char* dstr;
88              case gig::dimension_none: dstr=_("none"); break;                  char dstrbuf[10];
89              case gig::dimension_samplechannel: dstr=_("samplechannel"); break;                  switch (region->pDimensionDefinitions[i].dimension) {
90              case gig::dimension_layer: dstr=_("layer"); break;                  case gig::dimension_none: dstr=_("none"); break;
91              case gig::dimension_velocity: dstr=_("velocity"); break;                  case gig::dimension_samplechannel: dstr=_("samplechannel");
92              case gig::dimension_channelaftertouch: dstr=_("channelaftertouch"); break;                      break;
93              case gig::dimension_releasetrigger: dstr=_("releasetrigger"); break;                  case gig::dimension_layer: dstr=_("layer"); break;
94              case gig::dimension_keyboard: dstr=_("keyswitching"); break;                  case gig::dimension_velocity: dstr=_("velocity"); break;
95              case gig::dimension_roundrobin: dstr=_("roundrobin"); break;                  case gig::dimension_channelaftertouch:
96              case gig::dimension_random: dstr=_("random"); break;                      dstr=_("channelaftertouch"); break;
97              case gig::dimension_smartmidi: dstr=_("smartmidi"); break;                  case gig::dimension_releasetrigger:
98              case gig::dimension_roundrobinkeyboard: dstr=_("roundrobinkeyboard"); break;                      dstr=_("releasetrigger"); break;
99              case gig::dimension_modwheel: dstr=_("modwheel"); break;                  case gig::dimension_keyboard: dstr=_("keyswitching"); break;
100              case gig::dimension_breath: dstr=_("breath"); break;                  case gig::dimension_roundrobin: dstr=_("roundrobin"); break;
101              case gig::dimension_foot: dstr=_("foot"); break;                  case gig::dimension_random: dstr=_("random"); break;
102              case gig::dimension_portamentotime: dstr=_("portamentotime"); break;                  case gig::dimension_smartmidi: dstr=_("smartmidi"); break;
103              case gig::dimension_effect1: dstr=_("effect1"); break;                  case gig::dimension_roundrobinkeyboard:
104              case gig::dimension_effect2: dstr=_("effect2"); break;                      dstr=_("roundrobinkeyboard"); break;
105              case gig::dimension_genpurpose1: dstr=_("genpurpose1"); break;                  case gig::dimension_modwheel: dstr=_("modwheel"); break;
106              case gig::dimension_genpurpose2: dstr=_("genpurpose2"); break;                  case gig::dimension_breath: dstr=_("breath"); break;
107              case gig::dimension_genpurpose3: dstr=_("genpurpose3"); break;                  case gig::dimension_foot: dstr=_("foot"); break;
108              case gig::dimension_genpurpose4: dstr=_("genpurpose4"); break;                  case gig::dimension_portamentotime:
109              case gig::dimension_sustainpedal: dstr=_("sustainpedal"); break;                      dstr=_("portamentotime"); break;
110              case gig::dimension_portamento: dstr=_("portamento"); break;                  case gig::dimension_effect1: dstr=_("effect1"); break;
111              case gig::dimension_sostenutopedal: dstr=_("sostenutopedal"); break;                  case gig::dimension_effect2: dstr=_("effect2"); break;
112              case gig::dimension_softpedal: dstr=_("softpedal"); break;                  case gig::dimension_genpurpose1: dstr=_("genpurpose1"); break;
113              case gig::dimension_genpurpose5: dstr=_("genpurpose5"); break;                  case gig::dimension_genpurpose2: dstr=_("genpurpose2"); break;
114              case gig::dimension_genpurpose6: dstr=_("genpurpose6"); break;                  case gig::dimension_genpurpose3: dstr=_("genpurpose3"); break;
115              case gig::dimension_genpurpose7: dstr=_("genpurpose7"); break;                  case gig::dimension_genpurpose4: dstr=_("genpurpose4"); break;
116              case gig::dimension_genpurpose8: dstr=_("genpurpose8"); break;                  case gig::dimension_sustainpedal:
117              case gig::dimension_effect1depth: dstr=_("effect1depth"); break;                      dstr=_("sustainpedal"); break;
118              case gig::dimension_effect2depth: dstr=_("effect2depth"); break;                  case gig::dimension_portamento: dstr=_("portamento"); break;
119              case gig::dimension_effect3depth: dstr=_("effect3depth"); break;                  case gig::dimension_sostenutopedal:
120              case gig::dimension_effect4depth: dstr=_("effect4depth"); break;                      dstr=_("sostenutopedal"); break;
121              case gig::dimension_effect5depth: dstr=_("effect5depth"); break;                  case gig::dimension_softpedal: dstr=_("softpedal"); break;
122              default:                  case gig::dimension_genpurpose5: dstr=_("genpurpose5"); break;
123                  sprintf(dstrbuf, "%d",                  case gig::dimension_genpurpose6: dstr=_("genpurpose6"); break;
124                          region->pDimensionDefinitions[i].dimension);                  case gig::dimension_genpurpose7: dstr=_("genpurpose7"); break;
125                  dstr = dstrbuf;                  case gig::dimension_genpurpose8: dstr=_("genpurpose8"); break;
126                  break;                  case gig::dimension_effect1depth:
127              }                      dstr=_("effect1depth"); break;
128              layout->set_text(dstr);                  case gig::dimension_effect2depth:
129                        dstr=_("effect2depth"); break;
130              Pango::Rectangle rectangle = layout->get_logical_extents();                  case gig::dimension_effect3depth:
131              double text_w = double(rectangle.get_width()) / Pango::SCALE;                      dstr=_("effect3depth"); break;
132              if (text_w > maxwidth) maxwidth = text_w;                  case gig::dimension_effect4depth:
133              double text_h = double(rectangle.get_height()) / Pango::SCALE;                      dstr=_("effect4depth"); break;
134                    case gig::dimension_effect5depth:
135                        dstr=_("effect5depth"); break;
136                    default:
137                        sprintf(dstrbuf, "%d",
138                                region->pDimensionDefinitions[i].dimension);
139                        dstr = dstrbuf;
140                        break;
141                    }
142                    layout->set_text(dstr);
143    
144                    Pango::Rectangle rectangle = layout->get_logical_extents();
145                    double text_w = double(rectangle.get_width()) / Pango::SCALE;
146                    if (text_w > maxwidth) maxwidth = text_w;
147    
148                    if (y + h > clipy1 && y < clipy2 && text_w >= clipx1) {
149                        double text_h = double(rectangle.get_height()) /
150                            Pango::SCALE;
151  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
152              const Gdk::Color fg = get_style()->get_fg(get_state());                      const Gdk::Color fg = get_style()->get_fg(get_state());
153  #else  #else
154              const Gdk::RGBA fg = get_style_context()->get_color(get_state_flags());                      const Gdk::RGBA fg =
155                            get_style_context()->get_color(get_state_flags());
156  #endif  #endif
157              Gdk::Cairo::set_source_rgba(cr, fg);                      Gdk::Cairo::set_source_rgba(cr, fg);
158              cr->move_to(4, int(y + (h - text_h) / 2 + 0.5));                      cr->move_to(4, int(y + (h - text_h) / 2 + 0.5));
159  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 16) || GTKMM_MAJOR_VERSION < 2  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 16) || GTKMM_MAJOR_VERSION < 2
160              pango_cairo_show_layout(cr->cobj(), layout->gobj());                      pango_cairo_show_layout(cr->cobj(), layout->gobj());
161  #else  #else
162              layout->show_in_cairo_context(cr);                      layout->show_in_cairo_context(cr);
163  #endif  #endif
164                    }
165                }
166                y += h;
167          }          }
168          y += h;          label_width = int(maxwidth + 10);
169            labels_changed = false;
170      }      }
171        if (label_width >= clipx2) return true;
172    
173      // draw dimensions' zones areas      // draw dimensions' zones areas
174      y = 0;      y = 0;
175      int bitpos = 0;      int bitpos = 0;
     label_width = int(maxwidth + 10);  
176      for (int i = 0 ; i < region->Dimensions ; i++) {      for (int i = 0 ; i < region->Dimensions ; i++) {
177          int nbZones = region->pDimensionDefinitions[i].zones;          int nbZones = region->pDimensionDefinitions[i].zones;
178          if (nbZones) {          if (nbZones) {
179              // draw focus rectangle around dimension's label and zones              if (y >= clipy2) break;
180              if (has_focus() && focus_line == i) {              if (y + h > clipy1) {
181                    // draw focus rectangle around dimension's label and zones
182                    if (has_focus() && focus_line == i) {
183  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
184                  Gdk::Rectangle farea(0, y, 150, 20);                      Gdk::Rectangle farea(0, y, 150, 20);
185                  get_style()->paint_focus(get_window(), get_state(), farea, *this, "",                      get_style()->paint_focus(get_window(), get_state(), farea,
186                                           0, y, label_width, 20);                                               *this, "",
187                                                 0, y, label_width, 20);
188  #else  #else
189                  get_style_context()->render_focus(cr, 0, y, label_width, 20);                      get_style_context()->render_focus(cr,
190                                                          0, y, label_width, 20);
191  #endif  #endif
192              }                  }
   
             // draw top and bottom lines of dimension's zones  
             Gdk::Cairo::set_source_rgba(cr, black);  
             cr->move_to(label_width, y + 0.5);  
             cr->line_to(w, y + 0.5);  
             cr->move_to(w, y + h - 0.5);  
             cr->line_to(label_width, y + h - 0.5);  
             cr->stroke();  
   
             // erase whole dimension's zones area  
             Gdk::Cairo::set_source_rgba(cr, white);  
             cr->rectangle(label_width + 1, y + 1, (w - label_width - 2), h - 2);  
             cr->fill();  
   
             int c = 0;  
             if (dimregno >= 0) {  
                 int mask = ~(((1 << region->pDimensionDefinitions[i].bits) - 1) << bitpos);  
                 c = dimregno & mask; // mask away this dimension  
             }  
             bool customsplits =  
                 ((region->pDimensionDefinitions[i].split_type == gig::split_type_normal &&  
                  region->pDimensionRegions[c]->DimensionUpperLimits[i]) ||  
                 (region->pDimensionDefinitions[i].dimension == gig::dimension_velocity &&  
                  region->pDimensionRegions[c]->VelocityUpperLimit));  
193    
194              // draw dimension's zone borders                  // draw top and bottom lines of dimension's zones
195              Gdk::Cairo::set_source_rgba(cr, black);                  Gdk::Cairo::set_source_rgba(cr, black);
196              if (customsplits) {                  cr->move_to(label_width, y + 0.5);
197                  cr->move_to(label_width + 0.5, y + 1);                  cr->line_to(w, y + 0.5);
198                  cr->line_to(label_width + 0.5, y + h - 1);                  cr->move_to(w, y + h - 0.5);
199                    cr->line_to(label_width, y + h - 0.5);
200                    cr->stroke();
201    
202                    // erase whole dimension's zones area
203                    Gdk::Cairo::set_source_rgba(cr, white);
204                    cr->rectangle(label_width + 1, y + 1,
205                                  (w - label_width - 2), h - 2);
206                    cr->fill();
207    
208                  for (int j = 0 ; j < nbZones ; j++) {                  int c = 0;
209                      gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];                  if (dimregno >= 0) {
210                      int upperLimit = d->DimensionUpperLimits[i];                      int mask =
211                      if (!upperLimit) upperLimit = d->VelocityUpperLimit;                          ~(((1 << region->pDimensionDefinitions[i].bits) - 1) <<
212                      int v = upperLimit + 1;                            bitpos);
213                      int x = int((w - label_width - 1) * v / 128.0 + 0.5);                      c = dimregno & mask; // mask away this dimension
214                      cr->move_to(label_width + x + 0.5, y + 1);                  }
215                      cr->line_to(label_width + x + 0.5, y + h - 1);                  bool customsplits =
216                  }                      ((region->pDimensionDefinitions[i].split_type ==
217              } else {                        gig::split_type_normal &&
218                  for (int j = 0 ; j <= nbZones ; j++) {                        region->pDimensionRegions[c]->DimensionUpperLimits[i]) ||
219                      int x = int((w - label_width - 1) * j / double(nbZones) + 0.5);                       (region->pDimensionDefinitions[i].dimension ==
220                      cr->move_to(label_width + x + 0.5, y + 1);                        gig::dimension_velocity &&
221                      cr->line_to(label_width + x + 0.5, y + h - 1);                        region->pDimensionRegions[c]->VelocityUpperLimit));
                 }  
             }  
             cr->stroke();  
222    
223              // draw fill for currently selected zone                  // draw dimension's zone borders
224              if (dimregno >= 0) {                  Gdk::Cairo::set_source_rgba(cr, black);
                 Gdk::Cairo::set_source_rgba(cr, red);  
                 int dr = (dimregno >> bitpos) & ((1 << region->pDimensionDefinitions[i].bits) - 1);  
225                  if (customsplits) {                  if (customsplits) {
226                      int x1 = 0;                      cr->move_to(label_width + 0.5, y + 1);
227                        cr->line_to(label_width + 0.5, y + h - 1);
228    
229                      for (int j = 0 ; j < nbZones ; j++) {                      for (int j = 0 ; j < nbZones ; j++) {
230                          gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];                          gig::DimensionRegion* d =
231                                region->pDimensionRegions[c + (j << bitpos)];
232                          int upperLimit = d->DimensionUpperLimits[i];                          int upperLimit = d->DimensionUpperLimits[i];
233                          if (!upperLimit) upperLimit = d->VelocityUpperLimit;                          if (!upperLimit) upperLimit = d->VelocityUpperLimit;
234                          int v = upperLimit + 1;                          int v = upperLimit + 1;
235                          int x2 = int((w - label_width - 1) * v / 128.0 + 0.5);                          int x = int((w - label_width - 1) * v / 128.0 + 0.5) +
236                          if (j == dr && x1 < x2) {                              label_width;
237                            if (x >= clipx2) break;
238                            if (x < clipx1) continue;
239                            cr->move_to(x + 0.5, y + 1);
240                            cr->line_to(x + 0.5, y + h - 1);
241                        }
242                    } else {
243                        for (int j = 0 ; j <= nbZones ; j++) {
244                            int x = int((w - label_width - 1) * j /
245                                        double(nbZones) + 0.5) + label_width;
246                            if (x >= clipx2) break;
247                            if (x < clipx1) continue;
248                            cr->move_to(x + 0.5, y + 1);
249                            cr->line_to(x + 0.5, y + h - 1);
250                        }
251                    }
252                    cr->stroke();
253    
254                    // draw fill for currently selected zone
255                    if (dimregno >= 0) {
256                        Gdk::Cairo::set_source_rgba(cr, red);
257                        int dr = (dimregno >> bitpos) &
258                            ((1 << region->pDimensionDefinitions[i].bits) - 1);
259                        if (customsplits) {
260                            int x1 = label_width;
261                            for (int j = 0 ; j < nbZones && x1 + 1 < clipx2 ; j++) {
262                                gig::DimensionRegion* d =
263                                    region->pDimensionRegions[c + (j << bitpos)];
264                                int upperLimit = d->DimensionUpperLimits[i];
265                                if (!upperLimit) {
266                                    upperLimit = d->VelocityUpperLimit;
267                                }
268                                int v = upperLimit + 1;
269                                int x2 = int((w - label_width - 1) * v / 128.0 +
270                                             0.5) + label_width;
271                                if (j == dr && x1 < x2) {
272                                    cr->rectangle(x1 + 1, y + 1,
273                                                  (x2 - x1) - 1, h - 2);
274                                    cr->fill();
275                                    break;
276                                }
277                                x1 = x2;
278                            }
279                        } else {
280                            if (dr < nbZones) {
281                                int x1 = int((w - label_width - 1) * dr /
282                                             double(nbZones) + 0.5);
283                                int x2 = int((w - label_width - 1) * (dr + 1) /
284                                             double(nbZones) + 0.5);
285                              cr->rectangle(label_width + x1 + 1, y + 1,                              cr->rectangle(label_width + x1 + 1, y + 1,
286                                            (x2 - x1) - 1, h - 2);                                            (x2 - x1) - 1, h - 2);
287                              cr->fill();                              cr->fill();
                             break;  
288                          }                          }
                         x1 = x2;  
                     }  
                 } else {  
                     if (dr < nbZones) {  
                         int x1 = int((w - label_width - 1) * dr / double(nbZones) + 0.5);  
                         int x2 = int((w - label_width - 1) * (dr + 1) / double(nbZones) + 0.5);  
                         cr->rectangle(label_width + x1 + 1, y + 1,  
                                       (x2 - x1) - 1, h - 2);  
                         cr->fill();  
289                      }                      }
290                  }                  }
291              }              }
# Line 264  void DimRegionChooser::set_region(gig::R Line 321  void DimRegionChooser::set_region(gig::R
321      dimregion_selected();      dimregion_selected();
322      set_size_request(800, region ? nbDimensions * 20 : 0);      set_size_request(800, region ? nbDimensions * 20 : 0);
323    
324        labels_changed = true;
325      queue_resize();      queue_resize();
326  }  }
327    
# Line 290  void DimRegionChooser::get_dimregions(co Line 348  void DimRegionChooser::get_dimregions(co
348      if (stereo_bit) dimregs.insert(region->pDimensionRegions[dimregno | stereo_bit]);      if (stereo_bit) dimregs.insert(region->pDimensionRegions[dimregno | stereo_bit]);
349  }  }
350    
351    void DimRegionChooser::update_after_resize()
 bool DimRegionChooser::on_button_release_event(GdkEventButton* event)  
352  {  {
353      if (resize.active) {      if (region->pDimensionDefinitions[resize.dimension].dimension == gig::dimension_velocity) {
 #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2  
         get_window()->pointer_ungrab(event->time);  
 #else  
         Glib::wrap(event->device, true)->ungrab(event->time);  
 #endif  
         resize.active = false;  
354    
355          if (region->pDimensionDefinitions[resize.dimension].dimension == gig::dimension_velocity) {          int bitpos = 0;
356            for (int j = 0 ; j < resize.dimension ; j++) {
357              int bitpos = 0;              bitpos += region->pDimensionDefinitions[j].bits;
358              for (int j = 0 ; j < resize.dimension ; j++) {          }
359                  bitpos += region->pDimensionDefinitions[j].bits;          int mask =
360                ~(((1 << region->pDimensionDefinitions[resize.dimension].bits) - 1) << bitpos);
361            int c = dimregno & mask; // mask away this dimension
362    
363            if (region->pDimensionRegions[c]->DimensionUpperLimits[resize.dimension] == 0) {
364                // the velocity dimension didn't previously have
365                // custom v3 splits, so we initialize all splits with
366                // default values
367                int nbZones = region->pDimensionDefinitions[resize.dimension].zones;
368                for (int j = 0 ; j < nbZones ; j++) {
369                    gig::DimensionRegion* d = region->pDimensionRegions[c + (j << bitpos)];
370                    d->DimensionUpperLimits[resize.dimension] = int(128.0 * (j + 1) / nbZones - 1);
371                }
372            }
373            if (region->pDimensionRegions[c]->VelocityUpperLimit == 0) {
374                // the velocity dimension didn't previously have
375                // custom v2 splits, so we initialize all splits with
376                // default values
377                int nbZones = region->pDimensionDefinitions[resize.dimension].zones;
378                for (int j = 0 ; j < nbZones ; j++) {
379                    gig::DimensionRegion* d = region->pDimensionRegions[c + (j << bitpos)];
380                    d->VelocityUpperLimit = int(128.0 * (j + 1) / nbZones - 1);
381              }              }
382              int mask =          }
                 ~(((1 << region->pDimensionDefinitions[resize.dimension].bits) - 1) << bitpos);  
             int c = dimregno & mask; // mask away this dimension  
383    
384              if (region->pDimensionRegions[c]->DimensionUpperLimits[resize.dimension] == 0) {          gig::DimensionRegion* d = region->pDimensionRegions[c + resize.offset];
385                  // the velocity dimension didn't previously have          // update both v2 and v3 values
386                  // custom v3 splits, so we initialize all splits with          d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;
387                  // default values          d->VelocityUpperLimit = resize.pos - 1;
388                  int nbZones = region->pDimensionDefinitions[resize.dimension].zones;  
389                  for (int j = 0 ; j < nbZones ; j++) {      } else {
390                      gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];          for (int i = 0 ; i < region->DimensionRegions ; ) {
391                      d->DimensionUpperLimits[resize.dimension] = int(128.0 * (j + 1) / nbZones - 1);  
392                if (region->pDimensionRegions[i]->DimensionUpperLimits[resize.dimension] == 0) {
393                    // the dimension didn't previously have custom
394                    // limits, so we have to set default limits for
395                    // all the dimension regions
396                    int bitpos = 0;
397                    for (int j = 0 ; j < resize.dimension ; j++) {
398                        bitpos += region->pDimensionDefinitions[j].bits;
399                  }                  }
             }  
             if (region->pDimensionRegions[c]->VelocityUpperLimit == 0) {  
                 // the velocity dimension didn't previously have  
                 // custom v2 splits, so we initialize all splits with  
                 // default values  
400                  int nbZones = region->pDimensionDefinitions[resize.dimension].zones;                  int nbZones = region->pDimensionDefinitions[resize.dimension].zones;
401    
402                  for (int j = 0 ; j < nbZones ; j++) {                  for (int j = 0 ; j < nbZones ; j++) {
403                      gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];                      gig::DimensionRegion* d = region->pDimensionRegions[i + (j << bitpos)];
404                      d->VelocityUpperLimit = int(128.0 * (j + 1) / nbZones - 1);                      d->DimensionUpperLimits[resize.dimension] = int(128.0 * (j + 1) / nbZones - 1);
405                  }                  }
406              }              }
407                gig::DimensionRegion* d = region->pDimensionRegions[i + resize.offset];
             gig::DimensionRegion *d = region->pDimensionRegions[c + resize.offset];  
             // update both v2 and v3 values  
408              d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;              d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;
             d->VelocityUpperLimit = resize.pos - 1;  
   
         } else {  
             for (int i = 0 ; i < region->DimensionRegions ; ) {  
   
                 if (region->pDimensionRegions[i]->DimensionUpperLimits[resize.dimension] == 0) {  
                     // the dimension didn't previously have custom  
                     // limits, so we have to set default limits for  
                     // all the dimension regions  
                     int bitpos = 0;  
                     for (int j = 0 ; j < resize.dimension ; j++) {  
                         bitpos += region->pDimensionDefinitions[j].bits;  
                     }  
                     int nbZones = region->pDimensionDefinitions[resize.dimension].zones;  
   
                     for (int j = 0 ; j < nbZones ; j++) {  
                         gig::DimensionRegion *d = region->pDimensionRegions[i + (j << bitpos)];  
                         d->DimensionUpperLimits[resize.dimension] = int(128.0 * (j + 1) / nbZones - 1);  
                     }  
                 }  
                 gig::DimensionRegion *d = region->pDimensionRegions[i + resize.offset];  
                 d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;  
409    
410                  int bitpos = 0;              int bitpos = 0;
411                  int j;              int j;
412                  for (j = 0 ; j < region->Dimensions ; j++) {              for (j = 0 ; j < region->Dimensions ; j++) {
413                      if (j != resize.dimension) {                  if (j != resize.dimension) {
414                          int maxzones = 1 << region->pDimensionDefinitions[j].bits;                      int maxzones = 1 << region->pDimensionDefinitions[j].bits;
415                          int dimj = (i >> bitpos) & (maxzones - 1);                      int dimj = (i >> bitpos) & (maxzones - 1);
416                          if (dimj + 1 < region->pDimensionDefinitions[j].zones) break;                      if (dimj + 1 < region->pDimensionDefinitions[j].zones) break;
                     }  
                     bitpos += region->pDimensionDefinitions[j].bits;  
417                  }                  }
418                  if (j == region->Dimensions) break;                  bitpos += region->pDimensionDefinitions[j].bits;
                 i = (i & ~((1 << bitpos) - 1)) + (1 << bitpos);  
419              }              }
420                if (j == region->Dimensions) break;
421                i = (i & ~((1 << bitpos) - 1)) + (1 << bitpos);
422          }          }
423        }
424    }
425    
426    bool DimRegionChooser::on_button_release_event(GdkEventButton* event)
427    {
428        if (resize.active) {
429    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
430            get_window()->pointer_ungrab(event->time);
431    #else
432            Glib::wrap(event->device, true)->ungrab(event->time);
433    #endif
434            resize.active = false;
435    
436          region_changed();          region_changed();
437    
438          if (!is_in_resize_zone(event->x, event->y) && cursor_is_resize) {          if (!is_in_resize_zone(event->x, event->y) && cursor_is_resize) {
# Line 438  bool DimRegionChooser::on_button_press_e Line 499  bool DimRegionChooser::on_button_press_e
499    
500                  if (region->pDimensionRegions[c]->DimensionUpperLimits[i]) {                  if (region->pDimensionRegions[c]->DimensionUpperLimits[i]) {
501                      for (z = 0 ; z < nbZones ; z++) {                      for (z = 0 ; z < nbZones ; z++) {
502                          gig::DimensionRegion *d = region->pDimensionRegions[c + (z << bitpos)];                          gig::DimensionRegion* d = region->pDimensionRegions[c + (z << bitpos)];
503                          if (val <= d->DimensionUpperLimits[i]) break;                          if (val <= d->DimensionUpperLimits[i]) break;
504                      }                      }
505                  } else {                  } else {
506                      for (z = 0 ; z < nbZones ; z++) {                      for (z = 0 ; z < nbZones ; z++) {
507                          gig::DimensionRegion *d = region->pDimensionRegions[c + (z << bitpos)];                          gig::DimensionRegion* d = region->pDimensionRegions[c + (z << bitpos)];
508                          if (val <= d->VelocityUpperLimit) break;                          if (val <= d->VelocityUpperLimit) break;
509                      }                      }
510                  }                  }
# Line 487  bool DimRegionChooser::on_motion_notify_ Line 548  bool DimRegionChooser::on_motion_notify_
548          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
549    
550          if (k != resize.pos) {          if (k != resize.pos) {
             Cairo::RefPtr<Cairo::Context> cr = get_window()->create_cairo_context();  
             cr->set_line_width(1);  
   
551              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;
552              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;
553              int y = resize.dimension * h;              int y = resize.dimension * h;
554                int x1, x2;
555              if (resize.selected == resize.none) {              if (k > resize.pos) {
556                  if (resize.pos != resize.min && resize.pos != resize.max) {                  x1 = prevx;
557                      Gdk::Cairo::set_source_rgba(cr, white);                  x2 = x;
                     cr->move_to(prevx + 0.5, y + 1);  
                     cr->line_to(prevx + 0.5, y + h - 1);  
                     cr->stroke();  
                 }  
558              } else {              } else {
559                  Gdk::RGBA left;                  x1 = x;
560                  Gdk::RGBA right;                  x2 = prevx;
                 if (resize.selected == resize.left) {  
                     left = red;  
                     right = white;  
                 } else {  
                     left = white;  
                     right = red;  
                 }  
   
                 if (k > resize.pos) {  
                     int xx = resize.pos == resize.min ? 1 : 0;  
                     Gdk::Cairo::set_source_rgba(cr, left);  
                     cr->rectangle(prevx + xx, y + 1, x - prevx - xx, h - 2);  
                 } else {  
                     int xx = resize.pos == resize.max ? 0 : 1;  
                     Gdk::Cairo::set_source_rgba(cr, right);  
                     cr->rectangle(x, y + 1, prevx - x + xx, h - 2);  
                 }  
                 cr->fill();  
561              }              }
562              Gdk::Cairo::set_source_rgba(cr, black);              Gdk::Rectangle rect(x1, y + 1, x2 - x1 + 1, h - 2);
             cr->move_to(x + 0.5, y + 1);  
             cr->line_to(x + 0.5, y + h - 1);  
             cr->stroke();  
563    
564              resize.pos = k;              resize.pos = k;
565                update_after_resize();
566                get_window()->invalidate_rect(rect, false);
567          }          }
568      } else {      } else {
569          if (is_in_resize_zone(x, y)) {          if (is_in_resize_zone(x, y)) {
# Line 578  bool DimRegionChooser::is_in_resize_zone Line 613  bool DimRegionChooser::is_in_resize_zone
613          if (region->pDimensionDefinitions[dim].split_type != gig::split_type_bit) {          if (region->pDimensionDefinitions[dim].split_type != gig::split_type_bit) {
614              int prev_limit = 0;              int prev_limit = 0;
615              for (int iZone = 0 ; iZone < nbZones - 1 ; iZone++) {              for (int iZone = 0 ; iZone < nbZones - 1 ; iZone++) {
616                  gig::DimensionRegion *d = region->pDimensionRegions[c + (iZone << bitpos)];                  gig::DimensionRegion* d = region->pDimensionRegions[c + (iZone << bitpos)];
617                  const int upperLimit =                  const int upperLimit =
618                      (customsplits) ?                      (customsplits) ?
619                          (d->DimensionUpperLimits[dim]) ?                          (d->DimensionUpperLimits[dim]) ?
# Line 599  bool DimRegionChooser::is_in_resize_zone Line 634  bool DimRegionChooser::is_in_resize_zone
634                          dr == iZone + 1 ? resize.right : resize.none;                          dr == iZone + 1 ? resize.right : resize.none;
635    
636                      iZone++;                      iZone++;
637                      gig::DimensionRegion *d = region->pDimensionRegions[c + (iZone << bitpos)];                      gig::DimensionRegion* d = region->pDimensionRegions[c + (iZone << bitpos)];
638    
639                      const int upperLimit =                      const int upperLimit =
640                          (customsplits) ?                          (customsplits) ?
Legend:
Removed from v.2245  
changed lines
  Added in v.2246
  ViewVC Help
Powered by ViewVC