comparison layer/Layer.h @ 1266:a34a2a25907c

Untabify

  * Model.  Layers are expected to be able to draw themselves onto a
  * View, and may also be editable.
  */
 
 class Layer : public PropertyContainer,
-	      public XmlExportable
+              public XmlExportable
 {
     Q_OBJECT
 
 public:
     Layer();
     virtual ~Layer();
 
     virtual const Model *getModel() const = 0;
     Model *getModel() {
-	return const_cast<Model *>(const_cast<const Layer *>(this)->getModel());
+        return const_cast<Model *>(const_cast<const Layer *>(this)->getModel());
     }
     
     /**
      * Return a zoom constraint object defining the supported zoom
      * levels for this layer.  If this returns zero, the layer will

      * so may ignore this.
      */
     virtual void setSynchronousPainting(bool /* synchronous */) { }
 
     enum VerticalPosition {
-	PositionTop, PositionMiddle, PositionBottom
+        PositionTop, PositionMiddle, PositionBottom
     };
     virtual VerticalPosition getPreferredTimeRulerPosition() const {
-	return PositionMiddle;
+        return PositionMiddle;
     }
     virtual VerticalPosition getPreferredFrameCountPosition() const {
-	return PositionBottom;
+        return PositionBottom;
     }
     virtual bool hasLightBackground() const {
         return true;
     }
 
     virtual QString getPropertyContainerIconName() const;
 
     virtual QString getPropertyContainerName() const {
         if (m_presentationName != "") return m_presentationName;
-	else return objectName();
+        else return objectName();
     }
 
     virtual void setPresentationName(QString name);
 
     virtual QString getLayerPresentationName() const;

 
     virtual bool nearestMeasurementRectChanged(LayerGeometryProvider *, QPoint prev,
                                                QPoint now) const;
 
     virtual QString getFeatureDescription(LayerGeometryProvider *, QPoint &) const {
-	return "";
+        return "";
     }
 
     virtual QString getLabelPreceding(sv_frame_t /* frame */) const {
         return "";
     }
 
     enum SnapType {
-	SnapLeft,
-	SnapRight,
-	SnapNearest,
-	SnapNeighbouring
+        SnapLeft,
+        SnapRight,
+        SnapNearest,
+        SnapNeighbouring
     };
 
     /**
      * Adjust the given frame to snap to the nearest feature, if
      * possible.

      * accordingly.  Return false if no suitable feature was available
      * (and leave frame unmodified).  If returning true, also return
      * the resolution of the model in this layer in sample frames.
      */
     virtual bool snapToFeatureFrame(LayerGeometryProvider * /* v */,
-				    sv_frame_t & /* frame */,
-				    int &resolution,
-				    SnapType /* snap */) const {
-	resolution = 1;
-	return false;
+                                    sv_frame_t & /* frame */,
+                                    int &resolution,
+                                    SnapType /* snap */) const {
+        resolution = 1;
+        return false;
     }
 
     /**
      * Adjust the given frame to snap to the next feature that has
      * "effectively" the same value as the feature prior to the given

      */
     virtual bool snapToSimilarFeature(LayerGeometryProvider * /* v */,
                                       sv_frame_t & /* source frame */,
                                       int &resolution,
                                       SnapType /* snap */) const {
-	resolution = 1;
-	return false;
+        resolution = 1;
+        return false;
     }
 
     // Draw, erase, and edit modes:
     //
     // Layer needs to get actual mouse events, I guess.  Draw mode is