546 lines
22 KiB
Swift
546 lines
22 KiB
Swift
import CoreText
|
|
import UIKit
|
|
|
|
#if canImport(DTCoreText)
|
|
import DTCoreText
|
|
#endif
|
|
|
|
struct RDEPUBTextLayouter {
|
|
private let attributedString: NSAttributedString
|
|
private let pageSize: CGSize
|
|
private let framesetter: CTFramesetter
|
|
private let path: CGPath
|
|
private let config: RDEPUBTextLayoutConfig
|
|
|
|
init(attributedString: NSAttributedString, pageSize: CGSize, config: RDEPUBTextLayoutConfig = .default) {
|
|
self.attributedString = attributedString
|
|
self.pageSize = pageSize
|
|
self.config = config
|
|
self.framesetter = CTFramesetterCreateWithAttributedString(attributedString)
|
|
self.path = CGPath(rect: CGRect(origin: .zero, size: pageSize), transform: nil)
|
|
}
|
|
|
|
func layoutFrames(fragmentOffsets: [String: Int] = [:]) -> [RDEPUBTextLayoutFrame] {
|
|
guard attributedString.length > 0, pageSize.width > 0, pageSize.height > 0 else {
|
|
return []
|
|
}
|
|
|
|
#if canImport(DTCoreText)
|
|
return layoutFramesUsingDTCoreText(fragmentOffsets: fragmentOffsets)
|
|
#else
|
|
return layoutFramesUsingCoreText(fragmentOffsets: fragmentOffsets)
|
|
#endif
|
|
}
|
|
|
|
private func layoutFramesUsingCoreText(fragmentOffsets: [String: Int]) -> [RDEPUBTextLayoutFrame] {
|
|
guard attributedString.length > 0, pageSize.width > 0, pageSize.height > 0 else {
|
|
return []
|
|
}
|
|
|
|
var frames: [RDEPUBTextLayoutFrame] = []
|
|
var location = 0
|
|
|
|
while location < attributedString.length {
|
|
let frame = CTFramesetterCreateFrame(framesetter, CFRangeMake(location, 0), path, nil)
|
|
let visibleRange = CTFrameGetVisibleStringRange(frame)
|
|
guard visibleRange.length > 0 else {
|
|
break
|
|
}
|
|
|
|
let proposedRange = NSRange(location: location, length: visibleRange.length)
|
|
|
|
// Line-level avoidPageBreakInside (WXRead approach: scan CTFrame lines backward)
|
|
let lineAdjusted = trimmedRangeForAvoidPageBreakInside(from: frame, proposed: proposedRange)
|
|
|
|
let adjusted = adjustedRange(from: lineAdjusted, totalLength: attributedString.length)
|
|
let trailingFragmentID = nearestTrailingFragmentID(
|
|
endingAt: adjusted.range.location + adjusted.range.length,
|
|
fragmentOffsets: fragmentOffsets
|
|
)
|
|
frames.append(
|
|
RDEPUBTextLayoutFrame(
|
|
contentRange: adjusted.range,
|
|
breakReason: adjusted.breakReason,
|
|
blockRange: adjusted.blockRange,
|
|
attachmentRanges: adjusted.attachmentRanges,
|
|
attachmentKinds: adjusted.attachmentKinds,
|
|
blockKinds: adjusted.blockKinds,
|
|
semanticHints: adjusted.semanticHints,
|
|
attachmentPlacements: adjusted.attachmentPlacements,
|
|
trailingFragmentID: trailingFragmentID,
|
|
diagnostics: adjusted.diagnostics
|
|
)
|
|
)
|
|
|
|
let nextLocation = adjusted.range.location + adjusted.range.length
|
|
guard nextLocation > location else {
|
|
location += max(visibleRange.length, 1)
|
|
continue
|
|
}
|
|
location = nextLocation
|
|
}
|
|
|
|
return frames
|
|
}
|
|
|
|
#if canImport(DTCoreText)
|
|
private func layoutFramesUsingDTCoreText(fragmentOffsets: [String: Int]) -> [RDEPUBTextLayoutFrame] {
|
|
guard let layouter = DTCoreTextLayouter(attributedString: attributedString) else {
|
|
return layoutFramesUsingCoreText(fragmentOffsets: fragmentOffsets)
|
|
}
|
|
|
|
layouter.shouldCacheLayoutFrames = false
|
|
|
|
var frames: [RDEPUBTextLayoutFrame] = []
|
|
var location = 0
|
|
let pageRect = CGRect(origin: .zero, size: pageSize)
|
|
|
|
while location < attributedString.length {
|
|
guard let layoutFrame = layouter.layoutFrame(with: pageRect, range: NSRange(location: location, length: 0)) else {
|
|
break
|
|
}
|
|
|
|
let visibleRange = layoutFrame.visibleStringRange()
|
|
guard visibleRange.length > 0 else {
|
|
break
|
|
}
|
|
|
|
let proposedRange = NSRange(location: location, length: visibleRange.length)
|
|
let lineAdjusted = trimmedRangeForAvoidPageBreakInside(from: layoutFrame, proposed: proposedRange)
|
|
let adjusted = adjustedRange(from: lineAdjusted, totalLength: attributedString.length)
|
|
let trailingFragmentID = nearestTrailingFragmentID(
|
|
endingAt: adjusted.range.location + adjusted.range.length,
|
|
fragmentOffsets: fragmentOffsets
|
|
)
|
|
|
|
frames.append(
|
|
RDEPUBTextLayoutFrame(
|
|
contentRange: adjusted.range,
|
|
breakReason: adjusted.breakReason,
|
|
blockRange: adjusted.blockRange,
|
|
attachmentRanges: adjusted.attachmentRanges,
|
|
attachmentKinds: adjusted.attachmentKinds,
|
|
blockKinds: adjusted.blockKinds,
|
|
semanticHints: adjusted.semanticHints,
|
|
attachmentPlacements: adjusted.attachmentPlacements,
|
|
trailingFragmentID: trailingFragmentID,
|
|
diagnostics: adjusted.diagnostics
|
|
)
|
|
)
|
|
|
|
let nextLocation = adjusted.range.location + adjusted.range.length
|
|
guard nextLocation > location else {
|
|
location += max(visibleRange.length, 1)
|
|
continue
|
|
}
|
|
location = nextLocation
|
|
}
|
|
|
|
return frames
|
|
}
|
|
#endif
|
|
|
|
private func adjustedRange(
|
|
from proposedRange: NSRange,
|
|
totalLength: Int
|
|
) -> (
|
|
range: NSRange,
|
|
breakReason: RDEPUBTextPageBreakReason,
|
|
blockRange: NSRange?,
|
|
attachmentRanges: [NSRange],
|
|
attachmentKinds: [RDEPUBTextAttachmentKind],
|
|
blockKinds: [RDEPUBTextBlockKind],
|
|
semanticHints: [RDEPUBTextSemanticHint],
|
|
attachmentPlacements: [RDEPUBTextAttachmentPlacement],
|
|
diagnostics: [String]
|
|
) {
|
|
let pageEnd = proposedRange.location + proposedRange.length
|
|
let proposedBlockKinds = blockKinds(in: proposedRange)
|
|
let proposedSemanticHints = semanticHints(in: proposedRange)
|
|
let proposedAttachmentPlacements = attachmentPlacements(in: proposedRange)
|
|
guard pageEnd < totalLength else {
|
|
return (
|
|
range: proposedRange,
|
|
breakReason: .chapterEnd,
|
|
blockRange: blockRange(at: max(proposedRange.location, pageEnd - 1)),
|
|
attachmentRanges: attachmentRanges(in: proposedRange),
|
|
attachmentKinds: attachmentKinds(in: proposedRange),
|
|
blockKinds: proposedBlockKinds,
|
|
semanticHints: proposedSemanticHints,
|
|
attachmentPlacements: proposedAttachmentPlacements,
|
|
diagnostics: diagnostics(
|
|
reason: .chapterEnd,
|
|
range: proposedRange,
|
|
attachmentRanges: attachmentRanges(in: proposedRange),
|
|
blockRange: blockRange(at: max(proposedRange.location, pageEnd - 1)),
|
|
blockKinds: proposedBlockKinds,
|
|
semanticHints: proposedSemanticHints,
|
|
attachmentPlacements: proposedAttachmentPlacements
|
|
)
|
|
)
|
|
}
|
|
|
|
let minLength = max(Int(Double(proposedRange.length) * 0.55), 1)
|
|
let minimumEnd = proposedRange.location + minLength
|
|
|
|
let currentBlockRange = blockRange(at: max(proposedRange.location, pageEnd - 1))
|
|
let currentAttachmentRanges = attachmentRanges(in: proposedRange)
|
|
let currentAttachmentKinds = attachmentKinds(in: proposedRange)
|
|
let currentBlockKinds = proposedBlockKinds
|
|
let currentSemanticHints = proposedSemanticHints
|
|
let currentAttachmentPlacements = proposedAttachmentPlacements
|
|
|
|
if let semanticBoundary = preferredSemanticBoundary(
|
|
in: proposedRange,
|
|
minimumEnd: minimumEnd
|
|
) {
|
|
let adjustedRange = NSRange(location: proposedRange.location, length: semanticBoundary.location - proposedRange.location)
|
|
return (
|
|
range: adjustedRange,
|
|
breakReason: .semanticBoundary,
|
|
blockRange: currentBlockRange,
|
|
attachmentRanges: currentAttachmentRanges,
|
|
attachmentKinds: currentAttachmentKinds,
|
|
blockKinds: currentBlockKinds,
|
|
semanticHints: currentSemanticHints,
|
|
attachmentPlacements: currentAttachmentPlacements,
|
|
diagnostics: diagnostics(
|
|
reason: .semanticBoundary,
|
|
range: adjustedRange,
|
|
attachmentRanges: currentAttachmentRanges,
|
|
blockRange: currentBlockRange,
|
|
blockKinds: currentBlockKinds,
|
|
semanticHints: currentSemanticHints,
|
|
attachmentPlacements: currentAttachmentPlacements,
|
|
trigger: semanticBoundary.trigger
|
|
)
|
|
)
|
|
}
|
|
|
|
if let attachmentBoundary = preferredAttachmentBoundary(
|
|
in: proposedRange,
|
|
minimumEnd: minimumEnd
|
|
) {
|
|
let adjustedRange = NSRange(location: proposedRange.location, length: attachmentBoundary - proposedRange.location)
|
|
return (
|
|
range: adjustedRange,
|
|
breakReason: .attachmentBoundary,
|
|
blockRange: currentBlockRange,
|
|
attachmentRanges: currentAttachmentRanges,
|
|
attachmentKinds: currentAttachmentKinds,
|
|
blockKinds: currentBlockKinds,
|
|
semanticHints: currentSemanticHints,
|
|
attachmentPlacements: currentAttachmentPlacements,
|
|
diagnostics: diagnostics(
|
|
reason: .attachmentBoundary,
|
|
range: adjustedRange,
|
|
attachmentRanges: currentAttachmentRanges,
|
|
blockRange: currentBlockRange,
|
|
blockKinds: currentBlockKinds,
|
|
semanticHints: currentSemanticHints,
|
|
attachmentPlacements: currentAttachmentPlacements
|
|
)
|
|
)
|
|
}
|
|
|
|
return (
|
|
range: proposedRange,
|
|
breakReason: .frameLimit,
|
|
blockRange: currentBlockRange,
|
|
attachmentRanges: currentAttachmentRanges,
|
|
attachmentKinds: currentAttachmentKinds,
|
|
blockKinds: currentBlockKinds,
|
|
semanticHints: currentSemanticHints,
|
|
attachmentPlacements: currentAttachmentPlacements,
|
|
diagnostics: diagnostics(
|
|
reason: .frameLimit,
|
|
range: proposedRange,
|
|
attachmentRanges: currentAttachmentRanges,
|
|
blockRange: currentBlockRange,
|
|
blockKinds: currentBlockKinds,
|
|
semanticHints: currentSemanticHints,
|
|
attachmentPlacements: currentAttachmentPlacements
|
|
)
|
|
)
|
|
}
|
|
|
|
private func preferredSemanticBoundary(
|
|
in range: NSRange,
|
|
minimumEnd: Int
|
|
) -> (location: Int, trigger: String)? {
|
|
var boundary: (location: Int, trigger: String)?
|
|
attributedString.enumerateAttribute(.rdPageSemanticHints, in: range) { value, attributeRange, stop in
|
|
guard let rawValue = value as? String else { return }
|
|
let hints = rawValue
|
|
.split(separator: ",")
|
|
.compactMap { RDEPUBTextSemanticHint(rawValue: String($0)) }
|
|
guard !hints.isEmpty else { return }
|
|
|
|
if hints.contains(.pageBreakBefore),
|
|
attributeRange.location > range.location,
|
|
attributeRange.location >= minimumEnd {
|
|
boundary = (attributeRange.location, RDEPUBTextSemanticHint.pageBreakBefore.rawValue)
|
|
stop.pointee = true
|
|
return
|
|
}
|
|
|
|
let attributeEnd = attributeRange.location + attributeRange.length
|
|
if hints.contains(.pageBreakAfter),
|
|
attributeEnd > minimumEnd,
|
|
attributeEnd < range.location + range.length {
|
|
boundary = (attributeEnd, RDEPUBTextSemanticHint.pageBreakAfter.rawValue)
|
|
stop.pointee = true
|
|
return
|
|
}
|
|
}
|
|
return boundary
|
|
}
|
|
|
|
private func preferredAttachmentBoundary(in range: NSRange, minimumEnd: Int) -> Int? {
|
|
var boundary: Int?
|
|
attributedString.enumerateAttribute(.rdPageAttachmentKind, in: range) { value, attributeRange, stop in
|
|
guard value != nil else { return }
|
|
let paragraphRange = paragraphRange(containing: attributeRange.location)
|
|
if paragraphRange.location > range.location, paragraphRange.location >= minimumEnd {
|
|
boundary = paragraphRange.location
|
|
stop.pointee = true
|
|
}
|
|
}
|
|
return boundary
|
|
}
|
|
|
|
private func blockRange(at location: Int) -> NSRange? {
|
|
guard location >= 0, location < attributedString.length else { return nil }
|
|
let attributes = attributedString.attributes(at: location, effectiveRange: nil)
|
|
if let encodedRange = attributes[.rdPageBlockRange] as? String {
|
|
return NSRangeFromString(encodedRange)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private func paragraphRange(containing location: Int) -> NSRange {
|
|
let source = attributedString.string as NSString
|
|
guard source.length > 0 else { return NSRange(location: 0, length: 0) }
|
|
let safeLocation = min(max(location, 0), max(source.length - 1, 0))
|
|
return source.paragraphRange(for: NSRange(location: safeLocation, length: 0))
|
|
}
|
|
|
|
private func attachmentRanges(in range: NSRange) -> [NSRange] {
|
|
var results: [NSRange] = []
|
|
attributedString.enumerateAttribute(.rdPageAttachmentKind, in: range) { value, attributeRange, _ in
|
|
guard value != nil else { return }
|
|
results.append(attributeRange)
|
|
}
|
|
return results
|
|
}
|
|
|
|
private func attachmentKinds(in range: NSRange) -> [RDEPUBTextAttachmentKind] {
|
|
var kinds: [RDEPUBTextAttachmentKind] = []
|
|
attributedString.enumerateAttribute(.rdPageAttachmentKind, in: range) { value, _, _ in
|
|
guard let rawValue = value as? String,
|
|
let kind = RDEPUBTextAttachmentKind(rawValue: rawValue),
|
|
!kinds.contains(kind) else {
|
|
return
|
|
}
|
|
kinds.append(kind)
|
|
}
|
|
return kinds
|
|
}
|
|
|
|
private func blockKinds(in range: NSRange) -> [RDEPUBTextBlockKind] {
|
|
var kinds: [RDEPUBTextBlockKind] = []
|
|
attributedString.enumerateAttribute(.rdPageBlockKind, in: range) { value, _, _ in
|
|
guard let rawValue = value as? String,
|
|
let kind = RDEPUBTextBlockKind(rawValue: rawValue),
|
|
!kinds.contains(kind) else {
|
|
return
|
|
}
|
|
kinds.append(kind)
|
|
}
|
|
return kinds
|
|
}
|
|
|
|
private func semanticHints(in range: NSRange) -> [RDEPUBTextSemanticHint] {
|
|
var hints: [RDEPUBTextSemanticHint] = []
|
|
attributedString.enumerateAttribute(.rdPageSemanticHints, in: range) { value, _, _ in
|
|
guard let rawValue = value as? String else { return }
|
|
for hint in rawValue.split(separator: ",").compactMap({ RDEPUBTextSemanticHint(rawValue: String($0)) }) where !hints.contains(hint) {
|
|
hints.append(hint)
|
|
}
|
|
}
|
|
return hints
|
|
}
|
|
|
|
private func attachmentPlacements(in range: NSRange) -> [RDEPUBTextAttachmentPlacement] {
|
|
var placements: [RDEPUBTextAttachmentPlacement] = []
|
|
attributedString.enumerateAttribute(.rdPageAttachmentPlacement, in: range) { value, _, _ in
|
|
guard let rawValue = value as? String,
|
|
let placement = RDEPUBTextAttachmentPlacement(rawValue: rawValue),
|
|
!placements.contains(placement) else {
|
|
return
|
|
}
|
|
placements.append(placement)
|
|
}
|
|
return placements
|
|
}
|
|
|
|
private func nearestTrailingFragmentID(
|
|
endingAt location: Int,
|
|
fragmentOffsets: [String: Int]
|
|
) -> String? {
|
|
fragmentOffsets
|
|
.filter { $0.value <= location }
|
|
.max { lhs, rhs in lhs.value < rhs.value }?
|
|
.key
|
|
}
|
|
|
|
// MARK: - Line-level avoidPageBreakInside (WXRead approach)
|
|
|
|
/// Scans CTFrame lines backward from the last line, removing trailing lines
|
|
/// that fall inside an avoidPageBreakInside block. Mirrors WXRead's
|
|
/// WRCoreTextLayoutFrame.avoidPageBreakInsideByRemovingLastLinesIfNeeded.
|
|
private func trimmedRangeForAvoidPageBreakInside(
|
|
from frame: CTFrame,
|
|
proposed: NSRange
|
|
) -> NSRange {
|
|
guard config.avoidPageBreakInsideEnabled else { return proposed }
|
|
|
|
let lines = CTFrameGetLines(frame) as! [CTLine]
|
|
guard !lines.isEmpty else { return proposed }
|
|
|
|
var origins = [CGPoint](repeating: .zero, count: lines.count)
|
|
CTFrameGetLineOrigins(frame, CFRangeMake(0, 0), &origins)
|
|
|
|
// Scan backward: count consecutive trailing lines inside protected blocks
|
|
// kMaxLinesToRemove = 3 (same as WXRead)
|
|
let kMaxLinesToRemove = 3
|
|
var linesToRemove = 0
|
|
|
|
for i in stride(from: lines.count - 1, through: 0, by: -1) {
|
|
let lineRange = CTLineGetStringRange(lines[i])
|
|
let lineNSRange = NSRange(location: lineRange.location, length: lineRange.length)
|
|
|
|
if lineIsInAvoidPageBreakInsideBlock(lineNSRange) {
|
|
linesToRemove += 1
|
|
if linesToRemove >= kMaxLinesToRemove {
|
|
// Don't remove more than kMaxLinesToRemove; stop here
|
|
// (line at index i stays, so linesToRemove stays at kMaxLinesToRemove)
|
|
linesToRemove = kMaxLinesToRemove
|
|
break
|
|
}
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
|
|
guard linesToRemove > 0 else { return proposed }
|
|
|
|
let validLineCount = lines.count - linesToRemove
|
|
guard validLineCount > 0 else {
|
|
// All lines are in protected blocks; fall back to proposed
|
|
return proposed
|
|
}
|
|
|
|
let lastValidLine = lines[validLineCount - 1]
|
|
let lastLineRange = CTLineGetStringRange(lastValidLine)
|
|
let endLocation = lastLineRange.location + lastLineRange.length
|
|
let adjustedLength = endLocation - proposed.location
|
|
|
|
guard adjustedLength > 0 else { return proposed }
|
|
|
|
return NSRange(location: proposed.location, length: adjustedLength)
|
|
}
|
|
|
|
#if canImport(DTCoreText)
|
|
private func trimmedRangeForAvoidPageBreakInside(
|
|
from layoutFrame: DTCoreTextLayoutFrame,
|
|
proposed: NSRange
|
|
) -> NSRange {
|
|
guard config.avoidPageBreakInsideEnabled else { return proposed }
|
|
|
|
guard let lines = layoutFrame.lines as? [DTCoreTextLayoutLine], !lines.isEmpty else {
|
|
return proposed
|
|
}
|
|
|
|
let kMaxLinesToRemove = 3
|
|
var linesToRemove = 0
|
|
|
|
for line in lines.reversed() {
|
|
let lineRange = line.stringRange()
|
|
if lineIsInAvoidPageBreakInsideBlock(lineRange) {
|
|
linesToRemove += 1
|
|
if linesToRemove >= kMaxLinesToRemove {
|
|
linesToRemove = kMaxLinesToRemove
|
|
break
|
|
}
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
|
|
guard linesToRemove > 0 else { return proposed }
|
|
|
|
let validLineCount = lines.count - linesToRemove
|
|
guard validLineCount > 0 else { return proposed }
|
|
|
|
let lastValidLine = lines[validLineCount - 1]
|
|
let lastLineRange = lastValidLine.stringRange()
|
|
let endLocation = lastLineRange.location + lastLineRange.length
|
|
let adjustedLength = endLocation - proposed.location
|
|
|
|
guard adjustedLength > 0 else { return proposed }
|
|
|
|
return NSRange(location: proposed.location, length: adjustedLength)
|
|
}
|
|
#endif
|
|
|
|
/// Checks if a line's string range intersects with an avoidPageBreakInside block.
|
|
private func lineIsInAvoidPageBreakInsideBlock(_ lineRange: NSRange) -> Bool {
|
|
var found = false
|
|
let probeRange = NSRange(location: lineRange.location, length: max(lineRange.length, 1))
|
|
attributedString.enumerateAttribute(.rdPageSemanticHints, in: probeRange) { value, _, stop in
|
|
guard let rawValue = value as? String else { return }
|
|
let hints = rawValue
|
|
.split(separator: ",")
|
|
.compactMap { RDEPUBTextSemanticHint(rawValue: String($0)) }
|
|
if hints.contains(.avoidPageBreakInside) {
|
|
found = true
|
|
stop.pointee = true
|
|
}
|
|
}
|
|
return found
|
|
}
|
|
|
|
private func diagnostics(
|
|
reason: RDEPUBTextPageBreakReason,
|
|
range: NSRange,
|
|
attachmentRanges: [NSRange],
|
|
blockRange: NSRange?,
|
|
blockKinds: [RDEPUBTextBlockKind],
|
|
semanticHints: [RDEPUBTextSemanticHint],
|
|
attachmentPlacements: [RDEPUBTextAttachmentPlacement],
|
|
trigger: String? = nil
|
|
) -> [String] {
|
|
var items = ["page break: \(reason.rawValue)", "page range: \(NSStringFromRange(range))"]
|
|
if let blockRange {
|
|
items.append("block range: \(NSStringFromRange(blockRange))")
|
|
}
|
|
if !attachmentRanges.isEmpty {
|
|
items.append("attachment ranges: \(attachmentRanges.map(NSStringFromRange).joined(separator: ","))")
|
|
}
|
|
if !blockKinds.isEmpty {
|
|
items.append("block kinds: \(blockKinds.map(\.rawValue).joined(separator: ","))")
|
|
}
|
|
if !semanticHints.isEmpty {
|
|
items.append("semantic hints: \(semanticHints.map(\.rawValue).joined(separator: ","))")
|
|
}
|
|
if !attachmentPlacements.isEmpty {
|
|
items.append("attachment placements: \(attachmentPlacements.map(\.rawValue).joined(separator: ","))")
|
|
}
|
|
if let trigger, !trigger.isEmpty {
|
|
items.append("semantic trigger: \(trigger)")
|
|
}
|
|
return items
|
|
}
|
|
}
|