Sessions are now the unit of the product instead of an implicit capture run. - Nothing is deleted by default: the fixed 10-session cap is gone. An age limit (Never / 7 / 14 / 30 / 90 / 180 / 365 days) is chosen in Settings > Sessions and applied on launch, after archiving, and by "Clean up now". Sent PDFs are never touched. - Each session carries review details: lane, deployed version, commit, reviewer (pre-filled with the Mac user) and a free note. They persist in session.json and are inherited by the next session, so a review run is typed once. - PDF file names are Redline-<yyyyMMdd-HHmm>-<LANE>-<SHORTID>.pdf, and every page carries a two-line reference footer (tool, build time, session / lane, deployed build, commit, reviewer, note). The PDF document info carries the same values in Author and Keywords. - Verification: 159 tests, a headless panel self-test, and a LaunchServices-driven end-to-end run that types and clicks the real panel.
193 lines
8.0 KiB
Swift
193 lines
8.0 KiB
Swift
import AppKit
|
|
import CoreGraphics
|
|
import CoreText
|
|
import Foundation
|
|
|
|
public struct PageLayout: Sendable, Equatable {
|
|
public let isLandscape: Bool
|
|
public let pageRect: CGRect
|
|
public let headerRect: CGRect
|
|
public let imageBoxRect: CGRect
|
|
public let imageRect: CGRect
|
|
|
|
public let pageNumberText: String
|
|
public let pageNumberOrigin: CGPoint
|
|
public let timestampText: String
|
|
public let timestampOrigin: CGPoint
|
|
|
|
/// Reference block under the image (up to two lines): who, when, which lane,
|
|
/// which deployed build and commit. Empty when the caller passes no lines.
|
|
public let footerRect: CGRect
|
|
public let footerLines: [String]
|
|
public let footerOrigins: [CGPoint]
|
|
|
|
public let passLabelOrigin: CGPoint
|
|
public let failLabelOrigin: CGPoint
|
|
public let passTickBox: CGRect
|
|
public let failTickBox: CGRect
|
|
|
|
/// Constructed at access time so `PageLayout` stays Sendable under Swift 6
|
|
/// (`NSFont` is not Sendable). Same `NSFont.systemFont` values used for measurement.
|
|
public var pageNumberFont: NSFont { NSFont.systemFont(ofSize: 9, weight: .semibold) }
|
|
public var timestampFont: NSFont { NSFont.systemFont(ofSize: 9, weight: .regular) }
|
|
public var tickLabelFont: NSFont { NSFont.systemFont(ofSize: 8, weight: .semibold) }
|
|
public var footerFont: NSFont { NSFont.systemFont(ofSize: 7.5, weight: .regular) }
|
|
|
|
private static let marginAll: CGFloat = 18
|
|
private static let headerHeight: CGFloat = 26
|
|
private static let headerImageGap: CGFloat = 10
|
|
private static let footerLineHeight: CGFloat = 9.5
|
|
private static let footerImageGap: CGFloat = 7
|
|
private static let tickBoxSize: CGFloat = 13
|
|
private static let tickGroupGap: CGFloat = 8
|
|
private static let portraitPage = CGSize(width: 595, height: 842)
|
|
private static let landscapePage = CGSize(width: 842, height: 595)
|
|
|
|
/// `pageIndex` and `pageCount` are 1-based / total, over ACTUALLY-WRITTEN pages
|
|
/// (see SPEC decision D-D), not `capture.sequence` / `session.captures.count`.
|
|
/// `footerLines` is the pre-truncated reference block; an empty array keeps the
|
|
/// image area exactly as it was before the footer existed.
|
|
public init(capture: Capture, pageIndex: Int, pageCount: Int, footerLines: [String] = []) {
|
|
let pageNumberFont = NSFont.systemFont(ofSize: 9, weight: .semibold)
|
|
let timestampFont = NSFont.systemFont(ofSize: 9, weight: .regular)
|
|
let tickLabelFont = NSFont.systemFont(ofSize: 8, weight: .semibold)
|
|
let footerLabelFont = NSFont.systemFont(ofSize: 7.5, weight: .regular)
|
|
|
|
isLandscape = capture.isLandscape
|
|
pageRect = CGRect(origin: .zero, size: isLandscape ? Self.landscapePage : Self.portraitPage)
|
|
let W = pageRect.width
|
|
let H = pageRect.height
|
|
|
|
let contentMinX = Self.marginAll
|
|
let contentMaxX = W - Self.marginAll
|
|
let contentMinY = Self.marginAll
|
|
let contentMaxY = H - Self.marginAll
|
|
let contentWidth = contentMaxX - contentMinX
|
|
|
|
headerRect = CGRect(
|
|
x: contentMinX,
|
|
y: contentMaxY - Self.headerHeight,
|
|
width: contentWidth,
|
|
height: Self.headerHeight
|
|
)
|
|
|
|
self.footerLines = footerLines
|
|
let footerHeight = footerLines.isEmpty
|
|
? 0
|
|
: CGFloat(footerLines.count) * Self.footerLineHeight
|
|
footerRect = CGRect(
|
|
x: contentMinX,
|
|
y: contentMinY,
|
|
width: contentWidth,
|
|
height: footerHeight
|
|
)
|
|
let imageBoxMinY = contentMinY + (footerLines.isEmpty ? 0 : footerHeight + Self.footerImageGap)
|
|
|
|
imageBoxRect = CGRect(
|
|
x: contentMinX,
|
|
y: imageBoxMinY,
|
|
width: contentWidth,
|
|
height: headerRect.minY - Self.headerImageGap - imageBoxMinY
|
|
)
|
|
|
|
let pointSize = CGSize(
|
|
width: CGFloat(capture.pixelWidth) / capture.scale,
|
|
height: CGFloat(capture.pixelHeight) / capture.scale
|
|
)
|
|
let fitScale = min(
|
|
imageBoxRect.width / pointSize.width,
|
|
imageBoxRect.height / pointSize.height,
|
|
1.0
|
|
)
|
|
let drawnSize = CGSize(
|
|
width: pointSize.width * fitScale,
|
|
height: pointSize.height * fitScale
|
|
)
|
|
imageRect = CGRect(
|
|
x: imageBoxRect.midX - drawnSize.width / 2,
|
|
y: imageBoxRect.midY - drawnSize.height / 2,
|
|
width: drawnSize.width,
|
|
height: drawnSize.height
|
|
)
|
|
|
|
let metricsFont = timestampFont as CTFont
|
|
let ascent = CTFontGetAscent(metricsFont)
|
|
let descent = CTFontGetDescent(metricsFont)
|
|
let baselineY = headerRect.minY + (headerRect.height - (ascent + descent)) / 2 + descent
|
|
|
|
// Footer baselines, top line first, using the footer font's own descent.
|
|
let footerMetrics = footerLabelFont as CTFont
|
|
let footerAscent = CTFontGetAscent(footerMetrics)
|
|
let footerDescent = CTFontGetDescent(footerMetrics)
|
|
let footerLeading = Self.footerLineHeight
|
|
var origins: [CGPoint] = []
|
|
origins.reserveCapacity(footerLines.count)
|
|
for index in footerLines.indices {
|
|
let lineBottom = footerRect.maxY - CGFloat(index + 1) * footerLeading
|
|
origins.append(CGPoint(
|
|
x: footerRect.minX,
|
|
y: lineBottom + max(0, (footerLeading - (footerAscent + footerDescent)) / 2) + footerDescent
|
|
))
|
|
}
|
|
footerOrigins = origins
|
|
|
|
pageNumberText = "\(pageIndex) / \(pageCount)"
|
|
pageNumberOrigin = CGPoint(x: headerRect.minX, y: baselineY)
|
|
|
|
timestampText = DubaiTime.stamp(capture.capturedAt)
|
|
let pageNumberWidth = Self.measuredWidth(pageNumberText, font: pageNumberFont)
|
|
timestampOrigin = CGPoint(x: headerRect.minX + pageNumberWidth + 10, y: baselineY)
|
|
|
|
let groupRightX = headerRect.maxX
|
|
let failBoxMinX = groupRightX - Self.tickBoxSize
|
|
let tickBoxY = headerRect.midY - Self.tickBoxSize / 2
|
|
failTickBox = CGRect(
|
|
x: failBoxMinX,
|
|
y: tickBoxY,
|
|
width: Self.tickBoxSize,
|
|
height: Self.tickBoxSize
|
|
)
|
|
|
|
let failLabelWidth = Self.measuredWidth("FAIL", font: tickLabelFont)
|
|
let failLabelMaxX = failTickBox.minX - Self.tickGroupGap
|
|
failLabelOrigin = CGPoint(x: failLabelMaxX - failLabelWidth, y: baselineY)
|
|
|
|
let passBoxMaxX = failLabelOrigin.x - Self.tickGroupGap
|
|
passTickBox = CGRect(
|
|
x: passBoxMaxX - Self.tickBoxSize,
|
|
y: tickBoxY,
|
|
width: Self.tickBoxSize,
|
|
height: Self.tickBoxSize
|
|
)
|
|
|
|
let passLabelWidth = Self.measuredWidth("PASS", font: tickLabelFont)
|
|
let passLabelMaxX = passTickBox.minX - Self.tickGroupGap
|
|
passLabelOrigin = CGPoint(x: passLabelMaxX - passLabelWidth, y: baselineY)
|
|
}
|
|
|
|
public static func == (lhs: PageLayout, rhs: PageLayout) -> Bool {
|
|
lhs.isLandscape == rhs.isLandscape
|
|
&& lhs.pageRect == rhs.pageRect
|
|
&& lhs.headerRect == rhs.headerRect
|
|
&& lhs.imageBoxRect == rhs.imageBoxRect
|
|
&& lhs.imageRect == rhs.imageRect
|
|
&& lhs.pageNumberText == rhs.pageNumberText
|
|
&& lhs.pageNumberOrigin == rhs.pageNumberOrigin
|
|
&& lhs.timestampText == rhs.timestampText
|
|
&& lhs.timestampOrigin == rhs.timestampOrigin
|
|
&& lhs.footerRect == rhs.footerRect
|
|
&& lhs.footerLines == rhs.footerLines
|
|
&& lhs.footerOrigins == rhs.footerOrigins
|
|
&& lhs.passLabelOrigin == rhs.passLabelOrigin
|
|
&& lhs.failLabelOrigin == rhs.failLabelOrigin
|
|
&& lhs.passTickBox == rhs.passTickBox
|
|
&& lhs.failTickBox == rhs.failTickBox
|
|
}
|
|
|
|
private static func measuredWidth(_ text: String, font: NSFont) -> CGFloat {
|
|
let attributed = NSAttributedString(string: text, attributes: [.font: font])
|
|
let line = CTLineCreateWithAttributedString(attributed)
|
|
return CGFloat(CTLineGetTypographicBounds(line, nil, nil, nil))
|
|
}
|
|
}
|