   
   private var _radius: CGFloat {
     get{
-      if(radius == 0.0 || radius > self.bounds.height / 2.0) {
+      if(self.radius == 0.0 || self.radius > self.bounds.height / 2.0) {
         return self.bounds.height / 2.0
       }
-      return radius
+      return self.radius
     }
   }
   
   /// The progress points's raduis
   @IBInspectable public var progressRadius: CGFloat = 0.0 {
     didSet {
-      maskLayer.cornerRadius = progressRadius
+      self._maskLayer.cornerRadius = self.progressRadius
       self._setNeedsRedraw()
     }
   }
   
   private var _progressRadius: CGFloat {
     get {
-      if(progressRadius == 0.0 || progressRadius > self.bounds.height / 2.0) {
+      if(self.progressRadius == 0.0 || self.progressRadius > self.bounds.height / 2.0) {
         return self.bounds.height / 2.0
       }
-      return progressRadius
+      return self.progressRadius
     }
   }
   

  
  private var _lineHeight: CGFloat {
    get {
      if(lineHeight == 0.0 || lineHeight > self.bounds.height) {
        return self.bounds.height * 0.4
      }
      return lineHeight
    }
  }
  

  override public func drawRect(rect: CGRect) {        
    super.drawRect(rect)
    
    self._centerPoints.removeAll()
    
    let largerRadius = fmax(self._radius, self._progressRadius)
    
    let distanceBetweenCircles = (self.bounds.width - (CGFloat(self.numberOfPoints) * 2 * largerRadius)) / CGFloat(self.numberOfPoints - 1)
    
    var xCursor: CGFloat = largerRadius
    
    for _ in 0...(self.numberOfPoints - 1) {
      self._centerPoints.append(CGPointMake(xCursor, bounds.height / 2))
      xCursor += 2 * largerRadius + distanceBetweenCircles
    }
    
    if(self._needsRedraw) {
      
      let bgPath = self._shapePath(self._centerPoints, aRadius: self._radius, aLineHeight: self._lineHeight)
      self._backgroundLayer.path = bgPath.CGPath
      self._backgroundLayer.fillColor = self.backgroundShapeColor.CGColor
      
      let progressPath = self._shapePath(self._centerPoints, aRadius: self._progressRadius, aLineHeight: self._progressLineHeight)
      self._progressLayer.path = progressPath.CGPath
      self._progressLayer.fillColor = self.selectedBackgoundColor.CGColor
      
      if(self.displayStepText) {
        self._renderTextIndexes()
      }
      
      self._needsRedraw = true
    }
    
    let progressCenterPoints = Array<CGPoint>(self._centerPoints[0..<(self.currentIndex+1)])
    
    if let currentProgressCenterPoint = progressCenterPoints.last {
      
      let maskPath = self._maskPath(currentProgressCenterPoint)
      self._maskLayer.path = maskPath.CGPath
      
      CATransaction.begin()
      let progressAnimation = CABasicAnimation(keyPath: "path")
      progressAnimation.duration = self.stepAnimationDuration * CFTimeInterval(abs(self.currentIndex - self._previousIndex))
      progressAnimation.toValue = maskPath
      progressAnimation.removedOnCompletion = false
      progressAnimation.timingFunction = CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseInEaseOut)
      
      
      CATransaction.setCompletionBlock { () -> Void in
        if(self._animationRendering) {
          if let delegate = self.delegate {
            delegate.progressBar?(self, didSelectItemAtIndex: self.currentIndex)
          }
          self._animationRendering = false
        }
      }
      
      self._maskLayer.addAnimation(progressAnimation, forKey: "progressAnimation")
      CATransaction.commit()
    }
    self._previousIndex = self.currentIndex
  }
  
  /**
