 // MARK: Point <-> Location <-> SlotIndex Calculation
 private extension GridLayer {
     func _point(for location: GridLayer.Location) -> CGPoint {
-        return .zero
+        let x: CGFloat = self._horizontalOffset(forGridPosition: CGFloat(location.column))
+        let y: CGFloat = self._verticalOffset(forGridPosition: CGFloat(location.row))
+        return CGPoint(x: x, y: y)
+    }
+    
+    func _point(for slotIndex: UInt) -> CGPoint {
+        let xLocation: CGFloat = CGFloat(slotIndex % self.numOfColumns)
+        let yLocation: CGFloat = CGFloat(slotIndex / self.numOfColumns)
+        return self._point(for: (xLocation, yLocation))
     }
     
     func _location(nearestTo point: CGPoint) -> GridLayer.Location {
-        return (0, 0)
-    }
-    
-    func _point(for slotIndex: UInt) -> CGPoint {
-        return .zero
+        return (
+            self._locationOffset(
+                nearestToOffset: point.y,
+                minLocation: self._verticalOffset(forGridPosition: 0),
+                maxLocation: self._verticalOffset(forGridPosition: CGFloat(self._zeroedNumOfRows)),
+                stepUnit: self.rowHeight
+            ),
+            self._locationOffset(
+                nearestToOffset: point.x,
+                minLocation: self._horizontalOffset(forGridPosition: 0),
+                maxLocation: self._horizontalOffset(forGridPosition: CGFloat(self._zeroedNumOfColumns)),
+                stepUnit: self.columnWidth
+            )
+        )
     }
     
     // Helpers

// MARK: Interface
public extension GridLayer {
    // MARK: Location
    public typealias Location = (row: UInt, column: UInt)
    
    public enum Subdivision: CGFloat {
        case none = 1.0

    func _verticalOffset(forGridPosition gridPosition: CGFloat) -> CGFloat {
        return (self.gridInsetFactor + gridPosition) * self.rowHeight
    }
    
    // Private Helpers
    func _locationOffset(nearestToOffset offset: CGFloat, minLocation: CGFloat, maxLocation: CGFloat, stepUnit: CGFloat) -> CGFloat {
        if offset <= minLocation {
            return minLocation
        } else if offset >= maxLocation {
            return maxLocation
        } else {
            let stepSize: CGFloat = self.subdivision.rawValue * stepUnit
            return (round((offset - minLocation) / stepSize) * stepSize) + minLocation
        }
    }
}
