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

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

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

revision 1104 by persson, Sun Mar 18 17:15:00 2007 UTC revision 1197 by persson, Fri May 18 16:07:18 2007 UTC
# Line 282  bool DimRegionChooser::on_button_release Line 282  bool DimRegionChooser::on_button_release
282                  bitpos += region->pDimensionDefinitions[j].bits;                  bitpos += region->pDimensionDefinitions[j].bits;
283              }              }
284              int mask =              int mask =
285                       ~(((1 << region->pDimensionDefinitions[resize.dimension].bits) - 1) << bitpos);                  ~(((1 << region->pDimensionDefinitions[resize.dimension].bits) - 1) << bitpos);
286              int c = dimregno & mask; // mask away this dimension              int c = dimregno & mask; // mask away this dimension
287    
288              gig::DimensionRegion *d = region->pDimensionRegions[c + resize.offset];              if (region->pDimensionRegions[c]->DimensionUpperLimits[resize.dimension] == 0) {
289              if (d->DimensionUpperLimits[resize.dimension]) {                  // the velocity dimension didn't previously have
290                  d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;                  // custom v3 splits, so we initialize all splits with
291              } else {                  // default values
292                  d->VelocityUpperLimit = resize.pos - 1;                  int nbZones = region->pDimensionDefinitions[resize.dimension].zones;
293                    for (int j = 0 ; j < nbZones ; j++) {
294                        gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
295                        d->DimensionUpperLimits[resize.dimension] = int(128.0 * (j + 1) / nbZones - 1);
296                    }
297              }              }
298                if (region->pDimensionRegions[c]->VelocityUpperLimit == 0) {
299                    // the velocity dimension didn't previously have
300                    // custom v2 splits, so we initialize all splits with
301                    // default values
302                    int nbZones = region->pDimensionDefinitions[resize.dimension].zones;
303                    for (int j = 0 ; j < nbZones ; j++) {
304                        gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
305                        d->VelocityUpperLimit = int(128.0 * (j + 1) / nbZones - 1);
306                    }
307                }
308    
309                gig::DimensionRegion *d = region->pDimensionRegions[c + resize.offset];
310                // update both v2 and v3 values
311                d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;
312                d->VelocityUpperLimit = resize.pos - 1;
313    
314          } else {          } else {
315              for (int i = 0 ; i < region->DimensionRegions ; ) {              for (int i = 0 ; i < region->DimensionRegions ; ) {
316    
317                    if (region->pDimensionRegions[i]->DimensionUpperLimits[resize.dimension] == 0) {
318                        // the dimension didn't previously have custom
319                        // limits, so we have to set default limits for
320                        // all the dimension regions
321                        int bitpos = 0;
322                        for (int j = 0 ; j < resize.dimension ; j++) {
323                            bitpos += region->pDimensionDefinitions[j].bits;
324                        }
325                        int nbZones = region->pDimensionDefinitions[resize.dimension].zones;
326    
327                        for (int j = 0 ; j < nbZones ; j++) {
328                            gig::DimensionRegion *d = region->pDimensionRegions[i + (j << bitpos)];
329                            d->DimensionUpperLimits[resize.dimension] = int(128.0 * (j + 1) / nbZones - 1);
330                        }
331                    }
332                  gig::DimensionRegion *d = region->pDimensionRegions[i + resize.offset];                  gig::DimensionRegion *d = region->pDimensionRegions[i + resize.offset];
333                  d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;                  d->DimensionUpperLimits[resize.dimension] = resize.pos - 1;
334    
# Line 497  bool DimRegionChooser::is_in_resize_zone Line 531  bool DimRegionChooser::is_in_resize_zone
531              int mask = ~(((1 << region->pDimensionDefinitions[dim].bits) - 1) << bitpos);              int mask = ~(((1 << region->pDimensionDefinitions[dim].bits) - 1) << bitpos);
532              c = dimregno & mask; // mask away this dimension              c = dimregno & mask; // mask away this dimension
533          }          }
534          bool customsplits =          const bool customsplits =
535              ((region->pDimensionDefinitions[dim].split_type == gig::split_type_normal &&              ((region->pDimensionDefinitions[dim].split_type == gig::split_type_normal &&
536                region->pDimensionRegions[c]->DimensionUpperLimits[dim]) ||                region->pDimensionRegions[c]->DimensionUpperLimits[dim]) ||
537               (region->pDimensionDefinitions[dim].dimension == gig::dimension_velocity &&               (region->pDimensionDefinitions[dim].dimension == gig::dimension_velocity &&
538                region->pDimensionRegions[c]->VelocityUpperLimit));                region->pDimensionRegions[c]->VelocityUpperLimit));
539    
540          if (customsplits) {          // dimensions of split_type_bit cannot be resized
541            if (region->pDimensionDefinitions[dim].split_type != gig::split_type_bit) {
542              int prev_limit = 0;              int prev_limit = 0;
543              for (int j = 0 ; j < nbZones - 1 ; j++) {              for (int iZone = 0 ; iZone < nbZones - 1 ; iZone++) {
544                  gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];                  gig::DimensionRegion *d = region->pDimensionRegions[c + (iZone << bitpos)];
545                  int upperLimit = d->DimensionUpperLimits[dim];                  const int upperLimit =
546                  if (!upperLimit) upperLimit = d->VelocityUpperLimit;                      (customsplits) ?
547                            (d->DimensionUpperLimits[dim]) ?
548                                d->DimensionUpperLimits[dim] : d->VelocityUpperLimit
549                            : (iZone+1) * (int)region->pDimensionDefinitions[dim].zone_size - 1;
550                  int limit = upperLimit + 1;                  int limit = upperLimit + 1;
551                  int limitx = int((w - label_width - 1) * limit / 128.0 + 0.5) + label_width;                  int limitx = int((w - label_width - 1) * limit / 128.0 + 0.5) + label_width;
   
552                  if (x <= limitx - 2) break;                  if (x <= limitx - 2) break;
553                  if (x <= limitx + 2) {                  if (x <= limitx + 2) {
554                      resize.dimension = dim;                      resize.dimension = dim;
555                      resize.offset = j << bitpos;                      resize.offset = iZone << bitpos;
556                      resize.pos = limit;                      resize.pos = limit;
557                      resize.min = prev_limit;                      resize.min = prev_limit;
558    
559                      int dr = (dimregno >> bitpos) &                      int dr = (dimregno >> bitpos) &
560                          ((1 << region->pDimensionDefinitions[dim].bits) - 1);                          ((1 << region->pDimensionDefinitions[dim].bits) - 1);
561                      resize.selected = dr == j ? resize.left :                      resize.selected = dr == iZone ? resize.left :
562                          dr == j + 1 ? resize.right : resize.none;                          dr == iZone + 1 ? resize.right : resize.none;
563    
564                        iZone++;
565                        gig::DimensionRegion *d = region->pDimensionRegions[c + (iZone << bitpos)];
566    
567                        const int upperLimit =
568                            (customsplits) ?
569                                (d->DimensionUpperLimits[dim]) ?
570                                    d->DimensionUpperLimits[dim] : d->VelocityUpperLimit
571                                : (iZone+1) * (int)region->pDimensionDefinitions[dim].zone_size - 1;
572    
                     j++;  
                     gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];  
                     int upperLimit = d->DimensionUpperLimits[dim];  
                     if (!upperLimit) upperLimit = d->VelocityUpperLimit;  
573                      int limit = upperLimit + 1;                      int limit = upperLimit + 1;
574                      resize.max = limit;                      resize.max = limit;
575                      return true;                      return true;
Legend:
Removed from v.1104  
changed lines
  Added in v.1197
  ViewVC Help
Powered by ViewVC