     self.addGestureRecognizer(tapGestureRecognizer)
     self.addGestureRecognizer(swipeGestureRecognizer)
     
-    self.layer.addSublayer(self.backgroundLayer)
-    self.layer.addSublayer(self.progressLayer)
-    self.progressLayer.mask = self.maskLayer
+    self.layer.addSublayer(self._backgroundLayer)
+    self.layer.addSublayer(self._progressLayer)
+    self._progressLayer.mask = self._maskLayer
     
     self.contentMode = UIViewContentMode.Redraw
   }

  
  //MARK: - Private properties
  
  private var backgroundLayer = CAShapeLayer()
  
  private var progressLayer = CAShapeLayer()
  
  private var maskLayer = CAShapeLayer()
  
  private var centerPoints = [CGPoint]()
  
  private var _textLayers = [Int:CATextLayer]()
  
  private var previousIndex: Int = 0
  
  private var animationRendering = false
  
  private var _needsRedraw = true {
    didSet {

  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
  }
  
  /**
