Implement dynamic indent for lists.

Author: SergioEstevao

Aztec/Classes/Constants/Metrics.swift

@@ -8,8 +8,9 @@ public enum Metrics {
 
     public static var defaultIndentation = CGFloat(12)
     public static var maxIndentation = CGFloat(200)
-    public static var listTextIndentation = CGFloat(36)
-    public static var tabStepInterval = 8
+    public static var listTextIndentation = CGFloat(16)
+    public static var listTextCharIndentation = CGFloat(8)
+    public static var tabStepInterval = 4
     public static var tabStepCount = 12
     public static var paragraphSpacing = CGFloat(6)
 }

Aztec/Classes/TextKit/LayoutManager.swift

@@ -67,7 +67,7 @@ private extension LayoutManager {
 
             enumerateLineFragments(forGlyphRange: blockquoteGlyphRange) { (rect, usedRect, textContainer, glyphRange, stop) in
 
-                let startIndent = paragraphStyle.blockquoteIndent
+                let startIndent = paragraphStyle.indentToFirst(Blockquote.self) - Metrics.listTextIndentation
 
                 let lineRange = self.characterRange(forGlyphRange: glyphRange, actualGlyphRange: nil)
                 let lineCharacters = textStorage.attributedSubstring(from: lineRange).string
@@ -78,13 +78,12 @@ private extension LayoutManager {
 
                 let nestDepth = paragraphStyle.blockquoteNestDepth
                 for index in 0...nestDepth {
-                  let indent = startIndent + CGFloat(index) * Metrics.listTextIndentation
+                    let indent = paragraphStyle.indent(to: index, of: Blockquote.self) - Metrics.listTextIndentation
 
-                  let nestRect = self.blockquoteRect(origin: origin, lineRect: rect, blockquoteIndent: indent, lineEndsParagraph: lineEndsParagraph)
+                    let nestRect = self.blockquoteRect(origin: origin, lineRect: rect, blockquoteIndent: indent, lineEndsParagraph: lineEndsParagraph)
 
-                  self.drawBlockquoteBorder(in: nestRect.integral, with: context, at: index)
+                    self.drawBlockquoteBorder(in: nestRect.integral, with: context, at: index)
                 }
-                
 
             }
         }
@@ -100,7 +99,7 @@ private extension LayoutManager {
                 return
         }
 
-        let extraIndent = paragraphStyle.blockquoteIndent
+        let extraIndent = paragraphStyle.indentToLast(Blockquote.self)
         let extraRect = blockquoteRect(origin: origin, lineRect: extraLineFragmentRect, blockquoteIndent: extraIndent, lineEndsParagraph: false)
 
         drawBlockquoteBackground(in: extraRect.integral, with: context)
@@ -121,11 +120,7 @@ private extension LayoutManager {
     private func blockquoteRect(origin: CGPoint, lineRect: CGRect, blockquoteIndent: CGFloat, lineEndsParagraph: Bool) -> CGRect {
         var blockquoteRect = lineRect.offsetBy(dx: origin.x, dy: origin.y)
 
-        guard blockquoteIndent != 0 else {
-            return blockquoteRect
-        }
-
-        let paddingWidth = Metrics.listTextIndentation * 0.5 + blockquoteIndent
+        let paddingWidth = blockquoteIndent
         blockquoteRect.origin.x += paddingWidth
         blockquoteRect.size.width -= paddingWidth
 
@@ -284,16 +279,16 @@ private extension LayoutManager {
     ///     - location: Text Location that should get the marker rendered.
     ///
     private func drawItem(_ markerText: String, in rect: CGRect, styled paragraphAttributes: [NSAttributedString.Key: Any], at location: Int) {
-        guard let style = paragraphAttributes[.paragraphStyle] as? NSParagraphStyle else {
+        guard let style = paragraphAttributes[.paragraphStyle] as? ParagraphStyle else {
             return
         }
         let markerAttributes = markerAttributesBasedOnParagraph(attributes: paragraphAttributes)
         let markerAttributedText = NSAttributedString(string: markerText, attributes: markerAttributes)
 
         var yOffset = CGFloat(0)
         var xOffset = CGFloat(0)
-        let indentWidth = style.firstLineHeadIndent
-        let markerWidth = markerAttributedText.size().width
+        let indentWidth = style.indentToLast(TextList.self)
+        let markerWidth = markerAttributedText.size().width * 1.5
 
         if location > 0 {
             yOffset += style.paragraphSpacingBefore
@@ -315,10 +310,7 @@ private extension LayoutManager {
     ///
     private func markerAttributesBasedOnParagraph(attributes: [NSAttributedString.Key: Any]) -> [NSAttributedString.Key: Any] {
         var resultAttributes = attributes
-        var indent: CGFloat = 0
-        if let style = attributes[.paragraphStyle] as? ParagraphStyle {
-            indent = style.listIndent + Metrics.listTextIndentation - (Metrics.listTextIndentation / 4)
-        }
+        let indent: CGFloat = CGFloat(Metrics.tabStepInterval)
 
         resultAttributes[.paragraphStyle] = markerParagraphStyle(indent: indent)
         resultAttributes.removeValue(forKey: .underlineStyle)
@@ -336,10 +328,11 @@ private extension LayoutManager {
     /// Returns the Marker Paragraph Attributes
     ///
     private func markerParagraphStyle(indent: CGFloat) -> NSParagraphStyle {
-        let tabStop = NSTextTab(textAlignment: .right, location: indent, options: [:])
+
         let paragraphStyle = NSMutableParagraphStyle()
-        
-        paragraphStyle.tabStops = [tabStop]
+        paragraphStyle.alignment = .right
+        paragraphStyle.tailIndent = -indent
+        paragraphStyle.lineBreakMode = .byClipping
 
         return paragraphStyle
     }

Aztec/Classes/TextKit/ParagraphProperty/TextList.swift

@@ -16,8 +16,8 @@ open class TextList: ParagraphProperty {
 
         func markerText(forItemNumber number: Int) -> String {
             switch self {
-            case .ordered:      return "\t\(number).\t"
-            case .unordered:    return "\t\u{2022}"
+            case .ordered:      return "\(number)."
+            case .unordered:    return "\u{2022}"
             }
         }
     }

Aztec/Classes/TextKit/ParagraphStyle.swift

@@ -140,7 +140,7 @@ open class ParagraphStyle: NSMutableParagraphStyle, CustomReflectable {
 
     open override var headIndent: CGFloat {
         get {
-            let extra: CGFloat = (CGFloat(lists.count + blockquotes.count) * Metrics.listTextIndentation)
+            let extra: CGFloat = (CGFloat(blockquotes.count) * Metrics.listTextIndentation) + listIndent
 
             return baseHeadIndent + extra
         }
@@ -152,7 +152,8 @@ open class ParagraphStyle: NSMutableParagraphStyle, CustomReflectable {
 
     open override var firstLineHeadIndent: CGFloat {
         get {
-            let extra: CGFloat = (CGFloat(lists.count + blockquotes.count) * Metrics.listTextIndentation)
+
+            let extra: CGFloat = (CGFloat(blockquotes.count) * Metrics.listTextIndentation) + listIndent
 
             return baseFirstLineHeadIndent + extra
         }
@@ -175,57 +176,73 @@ open class ParagraphStyle: NSMutableParagraphStyle, CustomReflectable {
             super.tailIndent = newValue
         }
     }
-    
-    /// The level of indent to start the blockquote of the paragraph. Includes list indentation.
-    /// Handles whether blockquote is outside or insdie of a list.
-    public var blockquoteIndent: CGFloat {
-        let listAndBlockquotes = properties.filter({ property in
-            return property is Blockquote || property is TextList
-        })
-        if listAndBlockquotes.first is Blockquote {
+
+    /// Calculates the indentation of the paragraph up, for up to a certain depth of nesting of the type provided
+    /// - Parameters:
+    ///   - depth: the depth up to check
+    ///   - type: the type to check
+    public func indent<T : ParagraphProperty>(to depth: Int, of type: T.Type) -> CGFloat {
+        var position = -1
+        var currentDepth = -1
+        for property in properties {
+            position += 1
+            if property is T {
+                currentDepth += 1
+            }
+            if depth == currentDepth {
+                break
+            }
+        }
+        if position == -1 || currentDepth == -1 {
             return 0
         }
-        var depth = 0
-        for position in (0..<listAndBlockquotes.count).reversed() {
-            if listAndBlockquotes[position] is Blockquote {
-                depth = position
-                break
+        return indent(through: position)
+    }
+
+    /// Calculates the indentation of the paragraph up to the fist of property of the type
+    /// - Parameter type: the type to check
+    public func indentToFirst<T : ParagraphProperty>(_ type: T.Type) -> CGFloat {
+        let depth = properties.firstIndex(where: {$0 is T}) ?? 0
+        return indent(through: depth)
+    }
+
+    /// Calculates the indentation of the paragraph up the last property of the type specified
+    /// - Parameter type: the paragraph property type to check
+    public func indentToLast<T : ParagraphProperty>(_ type: T.Type) -> CGFloat {
+        let depth = properties.lastIndex(where: {$0 is T}) ?? 0
+        return indent(through: depth)
+    }
+
+    /// Calculates the level of indent up to a certain depth
+    private func indent(through depth: Int) -> CGFloat {
+        let totalIndent = properties.prefix(through: depth).reduce(CGFloat(0)) { (total, property)  in
+            if let list = property as? TextList {
+                return total + indent(for: list)
+            } else if property is Blockquote {
+                return total + Metrics.listTextIndentation
             }
+            return total
         }
-        return CGFloat(depth) * Metrics.listTextIndentation
+        return totalIndent
     }
 
     /// The level of depth for the nested blockquote of the paragraph. Excludes list indentation.
     ///
     public var blockquoteNestDepth: Int {
-        let listAndBlockquotes = properties.filter({ property in
-            return property is Blockquote
-        })
-        var depth = 0
-        for position in (0..<listAndBlockquotes.count).reversed() {
-            if listAndBlockquotes[position] is Blockquote {
-                depth = position
-                break
-            }
-        }
-        return depth
+        return max(0, blockquotes.count - 1)
     }
 
+    private func indent(for list: TextList) -> CGFloat {
+        let markerSize = CGFloat(list.style.markerText(forItemNumber: list.start ?? 1).count)
+        return Metrics.listTextIndentation + (markerSize * Metrics.listTextCharIndentation)
+    }
     /// The amount of indent for the list of the paragraph if any.
     ///
     public var listIndent: CGFloat {
-        let listAndBlockquotes = properties.filter({ property in
-            return property is Blockquote || property is TextList
-        })
-        var depth = 0
-        for position in (0..<listAndBlockquotes.count).reversed() {
-            if listAndBlockquotes[position] is TextList {
-                depth = position
-                break
-            }
+        let listIndent: CGFloat = lists.reduce(0) { (total, list) in
+            return total + indent(for: list)
         }
-
-        return CGFloat(depth) * Metrics.listTextIndentation
+        return listIndent
     }
 
     open var baseHeadIndent: CGFloat = 0