   override public func drawRect(rect: CGRect) {        
     super.drawRect(rect)
     
-    self.centerPoints.removeAll()
-    
-    let largerRadius = fmax(_radius, _progressRadius)
-    
-    let distanceBetweenCircles = (self.bounds.width - (CGFloat(numberOfPoints) * 2 * largerRadius)) / CGFloat(numberOfPoints - 1)
+    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...(numberOfPoints - 1) {
-      self.centerPoints.append(CGPointMake(xCursor, bounds.height / 2))
+    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: _radius, aLineHeight: _lineHeight)
-      self.backgroundLayer.path = bgPath.CGPath
-      self.backgroundLayer.fillColor = self.backgroundShapeColor.CGColor
-      
-      let progressPath = self._shapePath(self.centerPoints, aRadius: _progressRadius, aLineHeight: _progressLineHeight)
-      self.progressLayer.path = progressPath.CGPath
-      self.progressLayer.fillColor = self.selectedBackgoundColor.CGColor
+      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._renderTextIndexes()
       }
       
       self._needsRedraw = true
     }
     
-    let progressCenterPoints = Array<CGPoint>(centerPoints[0..<(currentIndex+1)])
+    let progressCenterPoints = Array<CGPoint>(self._centerPoints[0..<(self.currentIndex+1)])
     
     if let currentProgressCenterPoint = progressCenterPoints.last {
       
       let maskPath = self._maskPath(currentProgressCenterPoint)
-      maskLayer.path = maskPath.CGPath
+      self._maskLayer.path = maskPath.CGPath
       
       CATransaction.begin()
       let progressAnimation = CABasicAnimation(keyPath: "path")
-      progressAnimation.duration = stepAnimationDuration * CFTimeInterval(abs(currentIndex - previousIndex))
+      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(self._animationRendering) {
           if let delegate = self.delegate {
             delegate.progressBar?(self, didSelectItemAtIndex: self.currentIndex)
           }
-          self.animationRendering = false
+          self._animationRendering = false
         }
       }
       
-      maskLayer.addAnimation(progressAnimation, forKey: "progressAnimation")
+      self._maskLayer.addAnimation(progressAnimation, forKey: "progressAnimation")
       CATransaction.commit()
     }
-    self.previousIndex = self.currentIndex
+    self._previousIndex = self.currentIndex
   }
   
   /**

  /**
   Render the text indexes
   */
  private func renderTextIndexes() {
    
    for i in 0...(numberOfPoints - 1) {
      let centerPoint = centerPoints[i]
      
      let textLayer = self._textLayer(atIndex: i)
      textLayer.contentsScale = UIScreen.mainScreen().scale

    self.addGestureRecognizer(tapGestureRecognizer)
    self.addGestureRecognizer(swipeGestureRecognizer)
    
    self.layer.addSublayer(self._backgroundLayer)
    self.layer.addSublayer(self._progressLayer)
    self._progressLayer.mask = self._maskLayer
    
    self.contentMode = UIViewContentMode.Redraw
  }
