comparison layer/TimeValueLayer.cpp @ 1266:a34a2a25907c

Untabify

     else return "";
 }
 
 int
 TimeValueLayer::getPropertyRangeAndValue(const PropertyName &name,
-					 int *min, int *max, int *deflt) const
+                                         int *min, int *max, int *deflt) const
 {
     int val = 0;
 
     if (name == "Colour" && m_plotStyle == PlotSegmentation) {
             

         if (deflt) *deflt = 0;
         
         val = m_colourMap;
 
     } else if (name == "Plot Type") {
-	
-	if (min) *min = 0;
-	if (max) *max = 6;
+        
+        if (min) *min = 0;
+        if (max) *max = 6;
         if (deflt) *deflt = int(PlotConnectedPoints);
-	
-	val = int(m_plotStyle);
+        
+        val = int(m_plotStyle);
 
     } else if (name == "Vertical Scale") {
-	
-	if (min) *min = 0;
-	if (max) *max = 3;
+        
+        if (min) *min = 0;
+        if (max) *max = 3;
         if (deflt) *deflt = int(AutoAlignScale);
-	
-	val = int(m_verticalScale);
+        
+        val = int(m_verticalScale);
 
     } else if (name == "Scale Units") {
 
         if (deflt) *deflt = 0;
         if (m_model) {

         if (max) *max = 0;
         if (deflt) *deflt = 0;
         val = (m_derivative ? 1.0 : 0.0);
 
     } else {
-	
-	val = SingleColourLayer::getPropertyRangeAndValue(name, min, max, deflt);
+        
+        val = SingleColourLayer::getPropertyRangeAndValue(name, min, max, deflt);
     }
 
     return val;
 }
 
 QString
 TimeValueLayer::getPropertyValueLabel(const PropertyName &name,
-				    int value) const
+                                    int value) const
 {
     if (name == "Colour" && m_plotStyle == PlotSegmentation) {
         return ColourMapper::getColourMapName(value);
     } else if (name == "Plot Type") {
-	switch (value) {
-	default:
-	case 0: return tr("Points");
-	case 1: return tr("Stems");
-	case 2: return tr("Connected Points");
-	case 3: return tr("Lines");
-	case 4: return tr("Curve");
-	case 5: return tr("Segmentation");
-	case 6: return tr("Discrete Curves");
-	}
+        switch (value) {
+        default:
+        case 0: return tr("Points");
+        case 1: return tr("Stems");
+        case 2: return tr("Connected Points");
+        case 3: return tr("Lines");
+        case 4: return tr("Curve");
+        case 5: return tr("Segmentation");
+        case 6: return tr("Discrete Curves");
+        }
     } else if (name == "Vertical Scale") {
-	switch (value) {
-	default:
-	case 0: return tr("Auto-Align");
-	case 1: return tr("Linear");
-	case 2: return tr("Log");
-	case 3: return tr("+/-1");
-	}
+        switch (value) {
+        default:
+        case 0: return tr("Auto-Align");
+        case 1: return tr("Linear");
+        case 2: return tr("Log");
+        case 3: return tr("+/-1");
+        }
     }
     return SingleColourLayer::getPropertyValueLabel(name, value);
 }
 
 void
 TimeValueLayer::setProperty(const PropertyName &name, int value)
 {
     if (name == "Colour" && m_plotStyle == PlotSegmentation) {
         setFillColourMap(value);
     } else if (name == "Plot Type") {
-	setPlotStyle(PlotStyle(value));
+        setPlotStyle(PlotStyle(value));
     } else if (name == "Vertical Scale") {
-	setVerticalScale(VerticalScale(value));
+        setVerticalScale(VerticalScale(value));
     } else if (name == "Scale Units") {
         if (m_model) {
             m_model->setScaleUnits
                 (UnitDatabase::getInstance()->getUnitById(value));
             emit modelChanged();

 {
     // We don't illuminate sections in the line or curve modes, so
     // they're always scrollable
 
     if (m_plotStyle == PlotLines ||
-	m_plotStyle == PlotCurve ||
+        m_plotStyle == PlotCurve ||
         m_plotStyle == PlotDiscreteCurves) return true;
 
     QPoint discard;
     return !v->shouldIlluminateLocalFeatures(this, discard);
 }

     if (!m_model) return SparseTimeValueModel::PointList();
 
     sv_frame_t frame = v->getFrameForX(x);
 
     SparseTimeValueModel::PointList onPoints =
-	m_model->getPoints(frame);
+        m_model->getPoints(frame);
 
     if (!onPoints.empty()) {
-	return onPoints;
+        return onPoints;
     }
 
     SparseTimeValueModel::PointList prevPoints =
-	m_model->getPreviousPoints(frame);
+        m_model->getPreviousPoints(frame);
     SparseTimeValueModel::PointList nextPoints =
-	m_model->getNextPoints(frame);
+        m_model->getNextPoints(frame);
 
     SparseTimeValueModel::PointList usePoints = prevPoints;
 
     if (prevPoints.empty()) {
-	usePoints = nextPoints;
+        usePoints = nextPoints;
     } else if (nextPoints.empty()) {
         // stick with prevPoints
     } else if (prevPoints.begin()->frame < v->getStartFrame() &&
-	       !(nextPoints.begin()->frame > v->getEndFrame())) {
-	usePoints = nextPoints;
+               !(nextPoints.begin()->frame > v->getEndFrame())) {
+        usePoints = nextPoints;
     } else if (nextPoints.begin()->frame - frame <
-	       frame - prevPoints.begin()->frame) {
-	usePoints = nextPoints;
+               frame - prevPoints.begin()->frame) {
+        usePoints = nextPoints;
     }
 
     if (!usePoints.empty()) {
-	int fuzz = 2;
-	int px = v->getXForFrame(usePoints.begin()->frame);
-	if ((px > x && px - x > fuzz) ||
-	    (px < x && x - px > fuzz + 3)) {
-	    usePoints.clear();
-	}
+        int fuzz = 2;
+        int px = v->getXForFrame(usePoints.begin()->frame);
+        if ((px > x && px - x > fuzz) ||
+            (px < x && x - px > fuzz + 3)) {
+            usePoints.clear();
+        }
     }
 
     return usePoints;
 }
 

     if (!m_model || !m_model->getSampleRate()) return "";
 
     SparseTimeValueModel::PointList points = getLocalPoints(v, x);
 
     if (points.empty()) {
-	if (!m_model->isReady()) {
-	    return tr("In progress");
-	} else {
-	    return tr("No local points");
-	}
+        if (!m_model->isReady()) {
+            return tr("In progress");
+        } else {
+            return tr("No local points");
+        }
     }
 
     sv_frame_t useFrame = points.begin()->frame;
 
     RealTime rt = RealTime::frame2RealTime(useFrame, m_model->getSampleRate());

     }
     
     QString text;
 
     if (points.begin()->label == "") {
-	text = QString(tr("Time:\t%1\nValue:\t%2\nNo label"))
-	    .arg(rt.toText(true).c_str())
-	    .arg(valueText);
+        text = QString(tr("Time:\t%1\nValue:\t%2\nNo label"))
+            .arg(rt.toText(true).c_str())
+            .arg(valueText);
     } else {
-	text = QString(tr("Time:\t%1\nValue:\t%2\nLabel:\t%4"))
-	    .arg(rt.toText(true).c_str())
-	    .arg(valueText)
-	    .arg(points.begin()->label);
+        text = QString(tr("Time:\t%1\nValue:\t%2\nLabel:\t%4"))
+            .arg(rt.toText(true).c_str())
+            .arg(valueText)
+            .arg(points.begin()->label);
     }
 
     pos = QPoint(v->getXForFrame(useFrame),
-		 getYForValue(v, points.begin()->value));
+                 getYForValue(v, points.begin()->value));
     return text;
 }
 
 bool
 TimeValueLayer::snapToFeatureFrame(LayerGeometryProvider *v, sv_frame_t &frame,
-				   int &resolution,
-				   SnapType snap) const
+                                   int &resolution,
+                                   SnapType snap) const
 {
     if (!m_model) {
-	return Layer::snapToFeatureFrame(v, frame, resolution, snap);
+        return Layer::snapToFeatureFrame(v, frame, resolution, snap);
     }
 
     resolution = m_model->getResolution();
     SparseTimeValueModel::PointList points;
 
     if (snap == SnapNeighbouring) {
-	
-	points = getLocalPoints(v, v->getXForFrame(frame));
-	if (points.empty()) return false;
-	frame = points.begin()->frame;
-	return true;
+        
+        points = getLocalPoints(v, v->getXForFrame(frame));
+        if (points.empty()) return false;
+        frame = points.begin()->frame;
+        return true;
     }    
 
     points = m_model->getPoints(frame, frame);
     sv_frame_t snapped = frame;
     bool found = false;
 
     for (SparseTimeValueModel::PointList::const_iterator i = points.begin();
-	 i != points.end(); ++i) {
-
-	if (snap == SnapRight) {
-
-	    if (i->frame > frame) {
-		snapped = i->frame;
-		found = true;
-		break;
-	    }
-
-	} else if (snap == SnapLeft) {
-
-	    if (i->frame <= frame) {
-		snapped = i->frame;
-		found = true; // don't break, as the next may be better
-	    } else {
-		break;
-	    }
-
-	} else { // nearest
-
-	    SparseTimeValueModel::PointList::const_iterator j = i;
-	    ++j;
-
-	    if (j == points.end()) {
-
-		snapped = i->frame;
-		found = true;
-		break;
-
-	    } else if (j->frame >= frame) {
-
-		if (j->frame - frame < frame - i->frame) {
-		    snapped = j->frame;
-		} else {
-		    snapped = i->frame;
-		}
-		found = true;
-		break;
-	    }
-	}
+         i != points.end(); ++i) {
+
+        if (snap == SnapRight) {
+
+            if (i->frame > frame) {
+                snapped = i->frame;
+                found = true;
+                break;
+            }
+
+        } else if (snap == SnapLeft) {
+
+            if (i->frame <= frame) {
+                snapped = i->frame;
+                found = true; // don't break, as the next may be better
+            } else {
+                break;
+            }
+
+        } else { // nearest
+
+            SparseTimeValueModel::PointList::const_iterator j = i;
+            ++j;
+
+            if (j == points.end()) {
+
+                snapped = i->frame;
+                found = true;
+                break;
+
+            } else if (j->frame >= frame) {
+
+                if (j->frame - frame < frame - i->frame) {
+                    snapped = j->frame;
+                } else {
+                    snapped = i->frame;
+                }
+                found = true;
+                break;
+            }
+        }
     }
 
     frame = snapped;
     return found;
 }

 TimeValueLayer::snapToSimilarFeature(LayerGeometryProvider *v, sv_frame_t &frame,
                                      int &resolution,
                                      SnapType snap) const
 {
     if (!m_model) {
-	return Layer::snapToSimilarFeature(v, frame, resolution, snap);
+        return Layer::snapToSimilarFeature(v, frame, resolution, snap);
     }
 
     resolution = m_model->getResolution();
 
     const SparseTimeValueModel::PointList &points = m_model->getPoints();

                 i = points.begin();
                 distant = true;
             }
         }
 
-	if (snap == SnapRight) {
-
-	    if (i->frame > matchframe &&
+        if (snap == SnapRight) {
+
+            if (i->frame > matchframe &&
                 fabs(i->value - matchvalue) < epsilon) {
-		snapped = i->frame;
-		found = true;
-		break;
-	    }
-
-	} else if (snap == SnapLeft) {
-
-	    if (i->frame < matchframe) {
+                snapped = i->frame;
+                found = true;
+                break;
+            }
+
+        } else if (snap == SnapLeft) {
+
+            if (i->frame < matchframe) {
                 if (fabs(i->value - matchvalue) < epsilon) {
                     snapped = i->frame;
                     found = true; // don't break, as the next may be better
                 }
-	    } else if (found || distant) {
-		break;
-	    }
-
-	} else { 
+            } else if (found || distant) {
+                break;
+            }
+
+        } else { 
             // no other snap types supported
-	}
+        }
 
         ++i;
     }
 
     frame = snapped;

     sv_frame_t frame0 = v->getFrameForX(x0);
     sv_frame_t frame1 = v->getFrameForX(x1);
     if (m_derivative) --frame0;
 
     SparseTimeValueModel::PointList points(m_model->getPoints
-					   (frame0, frame1));
+                                           (frame0, frame1));
     if (points.empty()) return;
 
     paint.setPen(getBaseQColor());
 
     QColor brushColour(getBaseQColor());
     brushColour.setAlpha(80);
     paint.setBrush(brushColour);
 
 #ifdef DEBUG_TIME_VALUE_LAYER
     cerr << "TimeValueLayer::paint: resolution is "
-	      << m_model->getResolution() << " frames" << endl;
+              << m_model->getResolution() << " frames" << endl;
 #endif
 
     double min = m_model->getValueMinimum();
     double max = m_model->getValueMaximum();
     if (max == min) max = min + 1.0;
 
     int origin = int(nearbyint(v->getPaintHeight() -
-			       (-min * v->getPaintHeight()) / (max - min)));
+                               (-min * v->getPaintHeight()) / (max - min)));
 
     QPoint localPos;
     sv_frame_t illuminateFrame = -1;
 
     if (v->shouldIlluminateLocalFeatures(this, localPos)) {
-	SparseTimeValueModel::PointList localPoints =
-	    getLocalPoints(v, localPos.x());
+        SparseTimeValueModel::PointList localPoints =
+            getLocalPoints(v, localPos.x());
 #ifdef DEBUG_TIME_VALUE_LAYER
         cerr << "TimeValueLayer: " << localPoints.size() << " local points" << endl;
 #endif
-	if (!localPoints.empty()) illuminateFrame = localPoints.begin()->frame;
+        if (!localPoints.empty()) illuminateFrame = localPoints.begin()->frame;
     }
 
     int w =
-	v->getXForFrame(frame0 + m_model->getResolution()) -
-	v->getXForFrame(frame0);
+        v->getXForFrame(frame0 + m_model->getResolution()) -
+        v->getXForFrame(frame0);
 
     if (m_plotStyle == PlotStems) {
         if (w < 2) w = 2;
     } else {
         if (w < 1) w = 1;

     }
     
     sv_frame_t prevFrame = 0;
 
     for (SparseTimeValueModel::PointList::const_iterator i = points.begin();
-	 i != points.end(); ++i) {
+         i != points.end(); ++i) {
 
         if (m_derivative && i == points.begin()) continue;
 
-	const SparseTimeValueModel::Point &p(*i);
+        const SparseTimeValueModel::Point &p(*i);
 
         double value = p.value;
         if (m_derivative) {
             SparseTimeValueModel::PointList::const_iterator j = i;
             --j;
             value -= j->value;
         }
 
-	int x = v->getXForFrame(p.frame);
-	int y = getYForValue(v, value);
+        int x = v->getXForFrame(p.frame);
+        int y = getYForValue(v, value);
 
         bool gap = false;
         if (m_plotStyle == PlotDiscreteCurves) { 
             if (value == 0.0) {
                 // Treat zeros as gaps

             if (textY < paint.fontMetrics().ascent() + 1) {
                 textY = paint.fontMetrics().ascent() + 1;
             }
         }
 
-	bool haveNext = false;
+        bool haveNext = false;
         double nvalue = 0.f;
         sv_frame_t nf = v->getModelsEndFrame();
-	int nx = v->getXForFrame(nf);
-	int ny = y;
-
-	SparseTimeValueModel::PointList::const_iterator j = i;
-	++j;
-
-	if (j != points.end()) {
-	    const SparseTimeValueModel::Point &q(*j);
+        int nx = v->getXForFrame(nf);
+        int ny = y;
+
+        SparseTimeValueModel::PointList::const_iterator j = i;
+        ++j;
+
+        if (j != points.end()) {
+            const SparseTimeValueModel::Point &q(*j);
             nvalue = q.value;
             if (m_derivative) nvalue -= p.value;
             nf = q.frame;
-	    nx = v->getXForFrame(nf);
-	    ny = getYForValue(v, nvalue);
-	    haveNext = true;
+            nx = v->getXForFrame(nf);
+            ny = getYForValue(v, nvalue);
+            haveNext = true;
         }
 
 //        cout << "frame = " << p.frame << ", x = " << x << ", haveNext = " << haveNext 
 //                  << ", nx = " << nx << endl;
 

             pen = QPen(getBaseQColor(), 3);
             brush = QBrush(Qt::NoBrush);
         } else if (m_plotStyle == PlotSegmentation) {
             pen = QPen(getForegroundQColor(v));
             brush = QBrush(getColourForValue(v, value));
-	} else if (m_plotStyle == PlotLines ||
-		   m_plotStyle == PlotCurve) {
+        } else if (m_plotStyle == PlotLines ||
+                   m_plotStyle == PlotCurve) {
             brush = QBrush(Qt::NoBrush);
-	}
+        }
         
         paint.setPen(PaintAssistant::scalePen(pen));
         paint.setBrush(brush);
         
-	if (m_plotStyle == PlotStems) {
-	    if (y < origin - 1) {
-		paint.drawLine(x + w/2, y + 1, x + w/2, origin);
-	    } else if (y > origin + 1) {
-		paint.drawLine(x + w/2, origin, x + w/2, y - 1);
-	    }
-	}
+        if (m_plotStyle == PlotStems) {
+            if (y < origin - 1) {
+                paint.drawLine(x + w/2, y + 1, x + w/2, origin);
+            } else if (y > origin + 1) {
+                paint.drawLine(x + w/2, origin, x + w/2, y - 1);
+            }
+        }
 
         bool illuminate = false;
 
-	if (illuminateFrame == p.frame) {
-
-	    // not equipped to illuminate the right section in line
-	    // or curve mode
-
-	    if (m_plotStyle != PlotCurve &&
+        if (illuminateFrame == p.frame) {
+
+            // not equipped to illuminate the right section in line
+            // or curve mode
+
+            if (m_plotStyle != PlotCurve &&
                 m_plotStyle != PlotDiscreteCurves &&
-		m_plotStyle != PlotLines) {
+                m_plotStyle != PlotLines) {
                 illuminate = true;
             }
         }
 
-	if (m_plotStyle != PlotLines &&
-	    m_plotStyle != PlotCurve &&
+        if (m_plotStyle != PlotLines &&
+            m_plotStyle != PlotCurve &&
             m_plotStyle != PlotDiscreteCurves &&
-	    m_plotStyle != PlotSegmentation) {
+            m_plotStyle != PlotSegmentation) {
             if (illuminate) {
                 paint.save();
-		paint.setPen(PaintAssistant::scalePen(getForegroundQColor(v)));
+                paint.setPen(PaintAssistant::scalePen(getForegroundQColor(v)));
                 paint.setBrush(getForegroundQColor(v));
             }
             if (m_plotStyle != PlotStems ||
                 w > 1) {
                 paint.drawRect(x, y - 1, w, 2);
             }
             if (illuminate) {
                 paint.restore();
             }
-	}
-
-	if (m_plotStyle == PlotConnectedPoints ||
-	    m_plotStyle == PlotLines ||
+        }
+
+        if (m_plotStyle == PlotConnectedPoints ||
+            m_plotStyle == PlotLines ||
             m_plotStyle == PlotDiscreteCurves ||
-	    m_plotStyle == PlotCurve) {
-
-	    if (haveNext) {
-
-		if (m_plotStyle == PlotConnectedPoints) {
-		    
+            m_plotStyle == PlotCurve) {
+
+            if (haveNext) {
+
+                if (m_plotStyle == PlotConnectedPoints) {
+                    
                     paint.save();
-		    paint.setPen(PaintAssistant::scalePen(brushColour));
-		    paint.drawLine(x + w, y, nx, ny);
+                    paint.setPen(PaintAssistant::scalePen(brushColour));
+                    paint.drawLine(x + w, y, nx, ny);
                     paint.restore();
 
-		} else if (m_plotStyle == PlotLines) {
+                } else if (m_plotStyle == PlotLines) {
                     
                     if (pointCount == 0) {
                         path.moveTo(x + w/2, y);
                     }
 
-//		    paint.drawLine(x + w/2, y, nx + w/2, ny);
+//                    paint.drawLine(x + w/2, y, nx + w/2, ny);
                     path.lineTo(nx + w/2, ny);
 
-		} else {
-
-		    double x0 = x + double(w)/2;
-		    double x1 = nx + double(w)/2;
-		    
-		    double y0 = y;
-		    double y1 = ny;
+                } else {
+
+                    double x0 = x + double(w)/2;
+                    double x1 = nx + double(w)/2;
+                    
+                    double y0 = y;
+                    double y1 = ny;
 
                     if (m_plotStyle == PlotDiscreteCurves) {
                         bool nextGap =
                             (nvalue == 0.0) ||
                             (nf - p.frame >= m_model->getResolution() * 2);

                             x1 = x0;
                             y1 = y0;
                         }
                     }
 
-		    if (pointCount == 0 || gap) {
-			path.moveTo((x0 + x1) / 2, (y0 + y1) / 2);
-		    }
-
-		    if (nx - x > 5) {
-			path.cubicTo(x0, y0,
-				     x0, y0,
-				     (x0 + x1) / 2, (y0 + y1) / 2);
-
-			// // or
-			// path.quadTo(x0, y0, (x0 + x1) / 2, (y0 + y1) / 2);
-
-		    } else {
+                    if (pointCount == 0 || gap) {
+                        path.moveTo((x0 + x1) / 2, (y0 + y1) / 2);
+                    }
+
+                    if (nx - x > 5) {
+                        path.cubicTo(x0, y0,
+                                     x0, y0,
+                                     (x0 + x1) / 2, (y0 + y1) / 2);
+
+                        // // or
+                        // path.quadTo(x0, y0, (x0 + x1) / 2, (y0 + y1) / 2);
+
+                    } else {
                         path.lineTo(x0, y0);
-			path.lineTo((x0 + x1) / 2, (y0 + y1) / 2);
-		    }
-		}
-	    }
-	}
-
-	if (m_plotStyle == PlotSegmentation) {
+                        path.lineTo((x0 + x1) / 2, (y0 + y1) / 2);
+                    }
+                }
+            }
+        }
+
+        if (m_plotStyle == PlotSegmentation) {
 
 #ifdef DEBUG_TIME_VALUE_LAYER
             cerr << "drawing rect" << endl;
 #endif
-	    
-	    if (nx <= x) continue;
+            
+            if (nx <= x) continue;
 
             paint.setPen(PaintAssistant::scalePen(QPen(getForegroundQColor(v), 2)));
 
             if (!illuminate) {
                 if (!m_drawSegmentDivisions ||
                     nx < x + 5 ||
                     x >= v->getPaintWidth() - 1) {
                     paint.setPen(Qt::NoPen);
                 }
-	    }
-
-	    paint.drawRect(x, -1, nx - x, v->getPaintHeight() + 1);
-	}
+            }
+
+            paint.drawRect(x, -1, nx - x, v->getPaintHeight() + 1);
+        }
 
         if (v->shouldShowFeatureLabels()) {
 
             QString label = p.label;
             bool italic = false;

         ++pointCount;
     }
 
     if (m_plotStyle == PlotDiscreteCurves) {
         paint.setRenderHint(QPainter::Antialiasing, true);
-	paint.drawPath(path);
+        paint.drawPath(path);
     } else if ((m_plotStyle == PlotCurve || m_plotStyle == PlotLines)
                && !path.isEmpty()) {
-	paint.setRenderHint(QPainter::Antialiasing, pointCount <= v->getPaintWidth());
-	paint.drawPath(path);
+        paint.setRenderHint(QPainter::Antialiasing, pointCount <= v->getPaintWidth());
+        paint.drawPath(path);
     }
 
     paint.restore();
 
     // looks like save/restore doesn't deal with this:

 
     m_originalPoint = m_editingPoint;
 
     if (m_editingCommand) finish(m_editingCommand);
     m_editingCommand = new SparseTimeValueModel::EditCommand(m_model,
-							     tr("Draw Point"));
+                                                             tr("Draw Point"));
     if (!havePoint) {
         m_editingCommand->addPoint(m_editingPoint);
     }
 
     m_editing = true;

     if (points.empty()) return;
 
     m_editingPoint = *points.begin();
 
     if (m_editingCommand) {
-	finish(m_editingCommand);
-	m_editingCommand = 0;
+        finish(m_editingCommand);
+        m_editingCommand = 0;
     }
 
     m_editing = true;
 }
 

 
     m_editingPoint = *points.begin();
     m_originalPoint = m_editingPoint;
 
     if (m_editingCommand) {
-	finish(m_editingCommand);
-	m_editingCommand = 0;
+        finish(m_editingCommand);
+        m_editingCommand = 0;
     }
 
     m_editing = true;
 }
 

     frame = frame / m_model->getResolution() * m_model->getResolution();
 
     double value = getValueForY(v, e->y());
 
     if (!m_editingCommand) {
-	m_editingCommand = new SparseTimeValueModel::EditCommand(m_model,
-								 tr("Drag Point"));
+        m_editingCommand = new SparseTimeValueModel::EditCommand(m_model,
+                                                                 tr("Drag Point"));
     }
 
     m_editingCommand->deletePoint(m_editingPoint);
     m_editingPoint.frame = frame;
     m_editingPoint.value = float(value);

 #endif
     if (!m_model || !m_editing) return;
 
     if (m_editingCommand) {
 
-	QString newName = m_editingCommand->getName();
-
-	if (m_editingPoint.frame != m_originalPoint.frame) {
-	    if (m_editingPoint.value != m_originalPoint.value) {
-		newName = tr("Edit Point");
-	    } else {
-		newName = tr("Relocate Point");
-	    }
-	} else {
-	    newName = tr("Change Point Value");
-	}
-
-	m_editingCommand->setName(newName);
-	finish(m_editingCommand);
+        QString newName = m_editingCommand->getName();
+
+        if (m_editingPoint.frame != m_originalPoint.frame) {
+            if (m_editingPoint.value != m_originalPoint.value) {
+                newName = tr("Edit Point");
+            } else {
+                newName = tr("Relocate Point");
+            }
+        } else {
+            newName = tr("Change Point Value");
+        }
+
+        m_editingCommand->setName(newName);
+        finish(m_editingCommand);
     }
 
     m_editingCommand = 0;
     m_editing = false;
 }

 TimeValueLayer::moveSelection(Selection s, sv_frame_t newStartFrame)
 {
     if (!m_model) return;
 
     SparseTimeValueModel::EditCommand *command =
-	new SparseTimeValueModel::EditCommand(m_model,
-					      tr("Drag Selection"));
+        new SparseTimeValueModel::EditCommand(m_model,
+                                              tr("Drag Selection"));
 
     SparseTimeValueModel::PointList points =
-	m_model->getPoints(s.getStartFrame(), s.getEndFrame());
+        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
 
     for (SparseTimeValueModel::PointList::iterator i = points.begin();
-	 i != points.end(); ++i) {
-
-	if (s.contains(i->frame)) {
-	    SparseTimeValueModel::Point newPoint(*i);
-	    newPoint.frame = i->frame + newStartFrame - s.getStartFrame();
-	    command->deletePoint(*i);
-	    command->addPoint(newPoint);
-	}
+         i != points.end(); ++i) {
+
+        if (s.contains(i->frame)) {
+            SparseTimeValueModel::Point newPoint(*i);
+            newPoint.frame = i->frame + newStartFrame - s.getStartFrame();
+            command->deletePoint(*i);
+            command->addPoint(newPoint);
+        }
     }
 
     finish(command);
 }
 

 TimeValueLayer::resizeSelection(Selection s, Selection newSize)
 {
     if (!m_model) return;
 
     SparseTimeValueModel::EditCommand *command =
-	new SparseTimeValueModel::EditCommand(m_model,
-					      tr("Resize Selection"));
+        new SparseTimeValueModel::EditCommand(m_model,
+                                              tr("Resize Selection"));
 
     SparseTimeValueModel::PointList points =
-	m_model->getPoints(s.getStartFrame(), s.getEndFrame());
+        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
 
     double ratio =
-	double(newSize.getEndFrame() - newSize.getStartFrame()) /
-	double(s.getEndFrame() - s.getStartFrame());
+        double(newSize.getEndFrame() - newSize.getStartFrame()) /
+        double(s.getEndFrame() - s.getStartFrame());
 
     for (SparseTimeValueModel::PointList::iterator i = points.begin();
-	 i != points.end(); ++i) {
-
-	if (s.contains(i->frame)) {
-
-	    double target = double(i->frame);
-	    target = double(newSize.getStartFrame()) +
-		target - double(s.getStartFrame()) * ratio;
-
-	    SparseTimeValueModel::Point newPoint(*i);
-	    newPoint.frame = lrint(target);
-	    command->deletePoint(*i);
-	    command->addPoint(newPoint);
-	}
+         i != points.end(); ++i) {
+
+        if (s.contains(i->frame)) {
+
+            double target = double(i->frame);
+            target = double(newSize.getStartFrame()) +
+                target - double(s.getStartFrame()) * ratio;
+
+            SparseTimeValueModel::Point newPoint(*i);
+            newPoint.frame = lrint(target);
+            command->deletePoint(*i);
+            command->addPoint(newPoint);
+        }
     }
 
     finish(command);
 }
 

 TimeValueLayer::deleteSelection(Selection s)
 {
     if (!m_model) return;
 
     SparseTimeValueModel::EditCommand *command =
-	new SparseTimeValueModel::EditCommand(m_model,
-					      tr("Delete Selected Points"));
+        new SparseTimeValueModel::EditCommand(m_model,
+                                              tr("Delete Selected Points"));
 
     SparseTimeValueModel::PointList points =
-	m_model->getPoints(s.getStartFrame(), s.getEndFrame());
+        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
 
     for (SparseTimeValueModel::PointList::iterator i = points.begin();
-	 i != points.end(); ++i) {
+         i != points.end(); ++i) {
 
         if (s.contains(i->frame)) {
             command->deletePoint(*i);
         }
     }

 TimeValueLayer::copy(LayerGeometryProvider *v, Selection s, Clipboard &to)
 {
     if (!m_model) return;
 
     SparseTimeValueModel::PointList points =
-	m_model->getPoints(s.getStartFrame(), s.getEndFrame());
+        m_model->getPoints(s.getStartFrame(), s.getEndFrame());
 
     for (SparseTimeValueModel::PointList::iterator i = points.begin();
-	 i != points.end(); ++i) {
-	if (s.contains(i->frame)) {
+         i != points.end(); ++i) {
+        if (s.contains(i->frame)) {
             Clipboard::Point point(i->frame, i->value, i->label);
             point.setReferenceFrame(alignToReference(v, i->frame));
             to.addPoint(point);
         }
     }

             realign = true;
         }
     }
 
     SparseTimeValueModel::EditCommand *command =
-	new SparseTimeValueModel::EditCommand(m_model, tr("Paste"));
+        new SparseTimeValueModel::EditCommand(m_model, tr("Paste"));
 
     enum ValueAvailability {
         UnknownAvailability,
         NoValues,
         SomeValues,

 
     int cmap = attributes.value("colourMap").toInt(&ok);
     if (ok) setFillColourMap(cmap);
 
     PlotStyle style = (PlotStyle)
-	attributes.value("plotStyle").toInt(&ok);
+        attributes.value("plotStyle").toInt(&ok);
     if (ok) setPlotStyle(style);
 
     VerticalScale scale = (VerticalScale)
-	attributes.value("verticalScale").toInt(&ok);
+        attributes.value("verticalScale").toInt(&ok);
     if (ok) setVerticalScale(scale);
 
     bool draw = (attributes.value("drawDivisions").trimmed() == "true");
     setDrawSegmentDivisions(draw);