     
     /**
         Do the calculations to figure out which spread we are currently looking at.
-        This will also update the visiblePageIndexes
+        This will also update the centeredSpreadPageIndexes
         This is called while the user scrolls
      */
-    private func _updateVisibleSpreadIndex() {
+    private func _updateCenteredSpreadIndex() {
         guard let config = spreadConfiguration else {
             return
         }
         
-        
-        var newVisibleSpreadIndex:Int?
+
+        var newCenteredSpreadIndex:Int?
         
         // to avoid skipping frames with rounding errors, expand by a few pxs
         let visibleRect = pageScrollView.bounds.insetBy(dx: -2, dy: -2)
         
         if spreadFrames.count == 0 {
-            newVisibleSpreadIndex = nil
+            newCenteredSpreadIndex = nil
         }
         else if visibleRect.contains(spreadFrames.first!) {
             // first page is visible - assume first
-            newVisibleSpreadIndex = 0
+            newCenteredSpreadIndex = 0
         }
         else if visibleRect.contains(spreadFrames.last!) {
             // last page is visible - assume last
-            newVisibleSpreadIndex = spreadFrames.count-1
+            newCenteredSpreadIndex = spreadFrames.count-1
         }
         else {
             let visibleMid = CGPoint(x:visibleRect.midX, y:visibleRect.midY)

                
                let spreadFrame = spreadFrames[spreadIndex]
                if spreadFrame.contains(visibleMid) {
                    newVisibleSpreadIndex = spreadIndex
                    break
                } else if (minIndex > maxIndex) {
                    break

    }
    
    /// Asks the datasource for which pageIndexes around the specified set we should pre-load.
    private func _pageIndexesToPreloadAround(pageIndexes:NSIndexSet)->NSIndexSet {
        guard let config = spreadConfiguration else {
            return NSIndexSet()
        }
        
        guard pageIndexes.count > 0 && config.pageCount > 0 else {
            return NSIndexSet()
        }
        
        // get all the page indexes we are going to config and position, based on delegate callbacks
        let requiredPageIndexes = NSMutableIndexSet(indexSet: pageIndexes)
        
        
        if let preloadIndexes = dataSourceOptional.preloadPageIndexesForVerso(self, visiblePageIndexes: pageIndexes) {
            requiredPageIndexes.addIndexes(preloadIndexes)
        } else {
            if pageIndexes.firstIndex > 0 {
                let beforeCount = dataSourceOptional.previousPageCountToPreloadForVerso(self, visiblePageIndexes: pageIndexes)
                let newFirstIndex = max(pageIndexes.firstIndex-beforeCount, 0)
                requiredPageIndexes.addIndexesInRange(NSMakeRange(newFirstIndex, pageIndexes.firstIndex - newFirstIndex ))
            }
            if pageIndexes.lastIndex < (config.pageCount-1) {
                let afterCount = dataSourceOptional.nextPageCountToPreloadForVerso(self, visiblePageIndexes: pageIndexes)
                let newLastIndex = min(pageIndexes.lastIndex+afterCount, config.pageCount-1)
                requiredPageIndexes.addIndexesInRange(NSMakeRange(pageIndexes.lastIndex+1, newLastIndex - pageIndexes.lastIndex))
            }
        }
        
