smart_printer/smart_printer/FeatureIcons.swift

import Cocoa

enum FeatureIconKind {
    case scanFile
    case printText
    case printContacts
    case drawPrint
    case ocrFile
}

final class FeatureIconView: NSView {
    private let kind: FeatureIconKind

    init(kind: FeatureIconKind) {
        self.kind = kind
        super.init(frame: .zero)
        translatesAutoresizingMaskIntoConstraints = false
        setContentHuggingPriority(.required, for: .horizontal)
        setContentHuggingPriority(.required, for: .vertical)
        setContentCompressionResistancePriority(.required, for: .horizontal)
        setContentCompressionResistancePriority(.required, for: .vertical)
    }

    @available(*, unavailable)
    required init?(coder: NSCoder) { nil }

    override var isFlipped: Bool { true }
    override var isOpaque: Bool { false }

    override func draw(_ dirtyRect: NSRect) {
        super.draw(dirtyRect)
        guard let context = NSGraphicsContext.current?.cgContext else { return }

        switch kind {
        case .scanFile: drawScanFile(in: context)
        case .printText: drawPrintText(in: context)
        case .printContacts: drawPrintContacts(in: context)
        case .drawPrint: drawDrawPrint(in: context)
        case .ocrFile: drawOCRFile(in: context)
        }
    }

    // MARK: - Layout

    /// Shared artboard so every icon fills the same visual area.
    private struct IconLayout {
        let fill: CGRect
        let d: CGFloat

        init(bounds: NSRect) {
            let side = min(bounds.width, bounds.height)
            let originX = (bounds.width - side) / 2
            let originY = (bounds.height - side) / 2
            let inset = side * 0.12
            fill = CGRect(x: originX + inset, y: originY + inset, width: side - inset * 2, height: side - inset * 2)
            d = fill.width
        }

        func rect(_ x: CGFloat, _ y: CGFloat, _ w: CGFloat, _ h: CGFloat) -> CGRect {
            CGRect(
                x: fill.minX + fill.width * x,
                y: fill.minY + fill.height * y,
                width: fill.width * w,
                height: fill.height * h
            )
        }

        func dim(_ fraction: CGFloat) -> CGFloat {
            d * fraction
        }
    }

    // MARK: - Scan File

    private func drawScanFile(in context: CGContext) {
        let layout = IconLayout(bounds: bounds)

        let bodyRect = layout.rect(0.08, 0.38, 0.84, 0.50)
        drawSoftShadow(in: context, rect: CGRect(x: bodyRect.minX, y: bodyRect.maxY - layout.dim(0.03), width: bodyRect.width, height: layout.dim(0.05)), radius: layout.dim(0.025))

        let blueTop = NSColor(red: 0.38, green: 0.66, blue: 1.0, alpha: 1)
        let blueBottom = NSColor(red: 0.18, green: 0.44, blue: 0.94, alpha: 1)
        fillGradient(in: context, path: roundedRect(bodyRect, radius: layout.dim(0.06)), colors: [blueTop.cgColor, blueBottom.cgColor], start: CGPoint(x: bodyRect.midX, y: bodyRect.minY), end: CGPoint(x: bodyRect.midX, y: bodyRect.maxY))

        let glassRect = CGRect(x: bodyRect.minX + layout.dim(0.06), y: bodyRect.minY + layout.dim(0.05), width: bodyRect.width * 0.84, height: bodyRect.height * 0.52)
        context.setFillColor(NSColor.white.withAlphaComponent(0.25).cgColor)
        context.addPath(roundedRect(glassRect, radius: layout.dim(0.03)))
        context.fillPath()

        let lidRect = layout.rect(0.06, 0.22, 0.88, 0.18)
        fillGradient(in: context, path: roundedRect(lidRect, radius: layout.dim(0.04)), colors: [NSColor(red: 0.55, green: 0.76, blue: 1.0, alpha: 1).cgColor, blueTop.cgColor], start: CGPoint(x: lidRect.midX, y: lidRect.minY), end: CGPoint(x: lidRect.midX, y: lidRect.maxY))

        let paperRect = layout.rect(0.28, 0.06, 0.44, 0.20)
        context.setFillColor(NSColor.white.cgColor)
        context.addPath(roundedRect(paperRect, radius: layout.dim(0.02)))
        context.fillPath()

        for i in 0..<3 {
            let lineY = paperRect.minY + layout.dim(0.06) + CGFloat(i) * layout.dim(0.045)
            let lineW = paperRect.width * (0.85 - CGFloat(i) * 0.1)
            context.setFillColor(NSColor(red: 0.72, green: 0.82, blue: 0.98, alpha: 1).cgColor)
            context.addPath(roundedRect(CGRect(x: paperRect.minX + layout.dim(0.05), y: lineY, width: lineW, height: layout.dim(0.025)), radius: layout.dim(0.01)))
            context.fillPath()
        }

        let lightRect = CGRect(x: bodyRect.maxX - layout.dim(0.14), y: bodyRect.minY + layout.dim(0.08), width: layout.dim(0.06), height: layout.dim(0.06))
        context.setFillColor(NSColor(red: 0.30, green: 0.90, blue: 0.55, alpha: 1).cgColor)
        context.fillEllipse(in: lightRect)
    }

    // MARK: - Print Text

    private func drawPrintText(in context: CGContext) {
        let layout = IconLayout(bounds: bounds)

        let frameRect = layout.rect(0.08, 0.08, 0.84, 0.84)
        drawSoftShadow(in: context, rect: frameRect.insetBy(dx: layout.dim(0.04), dy: -layout.dim(0.02)), radius: layout.dim(0.03))

        context.setStrokeColor(NSColor(red: 0.62, green: 0.44, blue: 0.96, alpha: 1).cgColor)
        context.setLineWidth(layout.dim(0.03))
        context.setLineDash(phase: 0, lengths: [layout.dim(0.04), layout.dim(0.04)])
        context.addPath(roundedRect(frameRect, radius: layout.dim(0.04)))
        context.strokePath()
        context.setLineDash(phase: 0, lengths: [])

        let purple = NSColor(red: 0.55, green: 0.36, blue: 0.96, alpha: 1)
        let font = NSFont.systemFont(ofSize: layout.dim(0.40), weight: .bold)
        let attrs: [NSAttributedString.Key: Any] = [.font: font, .foregroundColor: purple]
        let text = "T" as NSString
        let textSize = text.size(withAttributes: attrs)
        text.draw(at: CGPoint(x: frameRect.midX - textSize.width / 2, y: frameRect.midY - textSize.height / 2), withAttributes: attrs)
    }

    // MARK: - Print Contacts

    private func drawPrintContacts(in context: CGContext) {
        let layout = IconLayout(bounds: bounds)

        let bookRect = layout.rect(0.08, 0.08, 0.84, 0.84)
        drawSoftShadow(in: context, rect: CGRect(x: bookRect.minX, y: bookRect.maxY - layout.dim(0.03), width: bookRect.width, height: layout.dim(0.05)), radius: layout.dim(0.025))

        let greenTop = NSColor(red: 0.42, green: 0.86, blue: 0.52, alpha: 1)
        let greenBottom = NSColor(red: 0.18, green: 0.68, blue: 0.38, alpha: 1)
        fillGradient(in: context, path: roundedRect(bookRect, radius: layout.dim(0.05)), colors: [greenTop.cgColor, greenBottom.cgColor], start: CGPoint(x: bookRect.midX, y: bookRect.minY), end: CGPoint(x: bookRect.midX, y: bookRect.maxY))

        let spineRect = CGRect(x: bookRect.minX, y: bookRect.minY, width: layout.dim(0.08), height: bookRect.height)
        context.setFillColor(NSColor(red: 0.12, green: 0.52, blue: 0.30, alpha: 1).cgColor)
        context.addPath(roundedRect(spineRect, radius: layout.dim(0.02), topLeft: layout.dim(0.05), topRight: 0, bottomLeft: layout.dim(0.05), bottomRight: 0))
        context.fillPath()

        let tabColors: [NSColor] = [
            NSColor(red: 0.96, green: 0.55, blue: 0.55, alpha: 1),
            NSColor(red: 0.55, green: 0.72, blue: 0.96, alpha: 1),
            NSColor(red: 0.96, green: 0.82, blue: 0.40, alpha: 1),
        ]
        for (i, color) in tabColors.enumerated() {
            let tabRect = CGRect(x: bookRect.maxX - layout.dim(0.02), y: bookRect.minY + layout.dim(0.10) + CGFloat(i) * layout.dim(0.14), width: layout.dim(0.10), height: layout.dim(0.10))
            context.setFillColor(color.cgColor)
            context.addPath(roundedRect(tabRect, radius: layout.dim(0.02), topLeft: 0, topRight: layout.dim(0.02), bottomLeft: 0, bottomRight: layout.dim(0.02)))
            context.fillPath()
        }

        let personCenter = CGPoint(x: bookRect.midX - layout.dim(0.02), y: bookRect.midY + layout.dim(0.04))
        context.setFillColor(NSColor.white.cgColor)
        context.fillEllipse(in: CGRect(x: personCenter.x - layout.dim(0.10), y: personCenter.y - layout.dim(0.16), width: layout.dim(0.20), height: layout.dim(0.20)))
        context.fillEllipse(in: CGRect(x: personCenter.x - layout.dim(0.14), y: personCenter.y + layout.dim(0.02), width: layout.dim(0.28), height: layout.dim(0.22)))
    }

    // MARK: - Draw & Print

    private func drawDrawPrint(in context: CGContext) {
        let layout = IconLayout(bounds: bounds)

        let paletteRect = layout.rect(0.06, 0.14, 0.80, 0.72)
        drawSoftShadow(in: context, rect: CGRect(x: paletteRect.minX, y: paletteRect.maxY - layout.dim(0.02), width: paletteRect.width, height: layout.dim(0.04)), radius: layout.dim(0.025))

        let woodTop = NSColor(red: 0.96, green: 0.78, blue: 0.48, alpha: 1)
        let woodBottom = NSColor(red: 0.86, green: 0.58, blue: 0.28, alpha: 1)
        let palettePath = paletteShape(in: paletteRect)
        fillGradient(in: context, path: palettePath, colors: [woodTop.cgColor, woodBottom.cgColor], start: CGPoint(x: paletteRect.midX, y: paletteRect.minY), end: CGPoint(x: paletteRect.midX, y: paletteRect.maxY))

        let paintColors: [NSColor] = [
            NSColor(red: 0.96, green: 0.35, blue: 0.35, alpha: 1),
            NSColor(red: 0.35, green: 0.65, blue: 0.96, alpha: 1),
            NSColor(red: 0.35, green: 0.82, blue: 0.45, alpha: 1),
            NSColor(red: 0.96, green: 0.78, blue: 0.25, alpha: 1),
            NSColor(red: 0.72, green: 0.40, blue: 0.96, alpha: 1),
        ]
        let thumbCenter = CGPoint(x: paletteRect.minX + paletteRect.width * 0.18, y: paletteRect.midY)
        for (i, color) in paintColors.enumerated() {
            let angle = CGFloat(i) * .pi * 0.32 - .pi * 0.5
            let radius = paletteRect.width * 0.28
            let dotCenter = CGPoint(x: thumbCenter.x + cos(angle) * radius, y: thumbCenter.y + sin(angle) * radius * 0.55)
            let dotSize = layout.dim(0.09)
            context.setFillColor(color.cgColor)
            context.fillEllipse(in: CGRect(x: dotCenter.x - dotSize / 2, y: dotCenter.y - dotSize / 2, width: dotSize, height: dotSize))
        }

        context.saveGState()
        context.translateBy(x: layout.fill.minX + layout.fill.width * 0.58, y: layout.fill.minY + layout.fill.height * 0.04)
        context.rotate(by: -.pi / 5)
        let brushRect = CGRect(x: 0, y: 0, width: layout.dim(0.10), height: layout.dim(0.44))
        fillGradient(in: context, path: roundedRect(brushRect, radius: layout.dim(0.02)), colors: [NSColor(red: 0.72, green: 0.48, blue: 0.28, alpha: 1).cgColor, NSColor(red: 0.52, green: 0.32, blue: 0.18, alpha: 1).cgColor], start: CGPoint(x: brushRect.midX, y: brushRect.minY), end: CGPoint(x: brushRect.midX, y: brushRect.maxY))
        let bristleRect = CGRect(x: brushRect.midX - layout.dim(0.05), y: brushRect.maxY - layout.dim(0.02), width: layout.dim(0.10), height: layout.dim(0.10))
        context.setFillColor(NSColor(red: 0.96, green: 0.55, blue: 0.30, alpha: 1).cgColor)
        context.fillEllipse(in: bristleRect)
        context.restoreGState()
    }

    private func paletteShape(in rect: CGRect) -> CGPath {
        let path = CGMutablePath()
        path.addEllipse(in: rect)
        let thumb = CGRect(x: rect.minX - rect.width * 0.08, y: rect.midY - rect.height * 0.18, width: rect.width * 0.22, height: rect.height * 0.36)
        path.addEllipse(in: thumb)
        return path
    }

    // MARK: - OCR File

    private func drawOCRFile(in context: CGContext) {
        let layout = IconLayout(bounds: bounds)

        let docRect = layout.rect(0.08, 0.06, 0.84, 0.88)
        drawSoftShadow(in: context, rect: CGRect(x: docRect.minX, y: docRect.maxY - layout.dim(0.03), width: docRect.width, height: layout.dim(0.05)), radius: layout.dim(0.025))

        context.setFillColor(NSColor.white.cgColor)
        context.addPath(roundedRect(docRect, radius: layout.dim(0.04)))
        context.fillPath()

        let purpleTop = NSColor(red: 0.62, green: 0.44, blue: 0.96, alpha: 1)
        let purpleBottom = NSColor(red: 0.45, green: 0.28, blue: 0.86, alpha: 1)
        let headerRect = CGRect(x: docRect.minX, y: docRect.minY, width: docRect.width, height: layout.dim(0.18))
        fillGradient(in: context, path: roundedRect(headerRect, radius: layout.dim(0.04), topLeft: layout.dim(0.04), topRight: layout.dim(0.04), bottomLeft: 0, bottomRight: 0), colors: [purpleTop.cgColor, purpleBottom.cgColor], start: CGPoint(x: headerRect.midX, y: headerRect.minY), end: CGPoint(x: headerRect.midX, y: headerRect.maxY))

        let font = NSFont.systemFont(ofSize: layout.dim(0.14), weight: .bold)
        let attrs: [NSAttributedString.Key: Any] = [.font: font, .foregroundColor: NSColor.white]
        let text = "OCR" as NSString
        let textSize = text.size(withAttributes: attrs)
        text.draw(at: CGPoint(x: docRect.midX - textSize.width / 2, y: docRect.minY + layout.dim(0.04)), withAttributes: attrs)

        let lineColor = NSColor(red: 0.78, green: 0.72, blue: 0.96, alpha: 1)
        for i in 0..<4 {
            let lineY = docRect.minY + layout.dim(0.24) + CGFloat(i) * layout.dim(0.10)
            let lineW = docRect.width * (0.80 - CGFloat(i) * 0.08)
            context.setFillColor(lineColor.cgColor)
            context.addPath(roundedRect(CGRect(x: docRect.minX + layout.dim(0.08), y: lineY, width: lineW, height: layout.dim(0.035)), radius: layout.dim(0.012)))
            context.fillPath()
        }
    }

    // MARK: - Helpers

    private func drawSoftShadow(in context: CGContext, rect: CGRect, radius: CGFloat) {
        context.saveGState()
        context.setFillColor(NSColor.black.withAlphaComponent(0.10).cgColor)
        context.addPath(roundedRect(rect.offsetBy(dx: 0, dy: radius * 0.2), radius: radius))
        context.fillPath()
        context.restoreGState()
    }

    private func fillGradient(in context: CGContext, path: CGPath, colors: [CGColor], start: CGPoint, end: CGPoint) {
        context.saveGState()
        context.addPath(path)
        context.clip()
        guard let gradient = CGGradient(colorsSpace: CGColorSpaceCreateDeviceRGB(), colors: colors as CFArray, locations: [0, 1]) else {
            context.restoreGState()
            return
        }
        context.drawLinearGradient(gradient, start: start, end: end, options: [])
        context.restoreGState()
    }

    private func roundedRect(_ rect: CGRect, radius: CGFloat) -> CGPath {
        roundedRect(rect, radius: radius, topLeft: radius, topRight: radius, bottomLeft: radius, bottomRight: radius)
    }

    private func roundedRect(_ rect: CGRect, radius: CGFloat, topLeft: CGFloat, topRight: CGFloat, bottomLeft: CGFloat, bottomRight: CGFloat) -> CGPath {
        let path = CGMutablePath()
        path.move(to: CGPoint(x: rect.minX + topLeft, y: rect.maxY))
        path.addLine(to: CGPoint(x: rect.maxX - topRight, y: rect.maxY))
        path.addQuadCurve(to: CGPoint(x: rect.maxX, y: rect.maxY - topRight), control: CGPoint(x: rect.maxX, y: rect.maxY))
        path.addLine(to: CGPoint(x: rect.maxX, y: rect.minY + bottomRight))
        path.addQuadCurve(to: CGPoint(x: rect.maxX - bottomRight, y: rect.minY), control: CGPoint(x: rect.maxX, y: rect.minY))
        path.addLine(to: CGPoint(x: rect.minX + bottomLeft, y: rect.minY))
        path.addQuadCurve(to: CGPoint(x: rect.minX, y: rect.minY + bottomLeft), control: CGPoint(x: rect.minX, y: rect.minY))
        path.addLine(to: CGPoint(x: rect.minX, y: rect.maxY - topLeft))
        path.addQuadCurve(to: CGPoint(x: rect.minX + topLeft, y: rect.maxY), control: CGPoint(x: rect.minX, y: rect.maxY))
        path.closeSubpath()
        return path
    }
}