diff --git a/.gitignore b/.gitignore index ab853e7..f595cbc 100644 --- a/.gitignore +++ b/.gitignore @@ -32,6 +32,9 @@ playground.xcworkspace .build/ +# Generated app bundle (Scripts/build-app.sh) +build/ + # CocoaPods # # We recommend against adding the Pods directory to your .gitignore. However diff --git a/CONCEPT.md b/CONCEPT.md index 6ef6a89..566aee8 100644 --- a/CONCEPT.md +++ b/CONCEPT.md @@ -175,7 +175,8 @@ sie bei der nächsten Automatik erhalten bleiben. ## 7. Oberfläche und Interaktion - **Ruhige Papieroptik** mit warmen Hintergründen, Akzentgrün, Gold und - Burgunder; Serif-Überschriften, klare Piktogramme. + Burgunder; Serif-Überschriften, klare Piktogramme. Das App-Icon greift die + Gestaltung auf: eine Kirchen-Silhouette hinter einer Kalenderkarte. - **Kalender als Tabelle:** eine Zeile pro Tag, feste Spalten für Datum, Liturgie/Lesungen und die vier Kirchen. Sonntage, Hochfeste und gebotene Feiertage sind farblich hinterlegt; liturgische Farbbalken markieren den Tag. diff --git a/README.md b/README.md index 0944ef7..d6346e5 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,114 @@ # LektorenPlan +macOS-SwiftUI-Prototyp für die Planung von Lektorinnen, Lektoren und +Kommunionhelferinnen/-helfern in der Pfarreiengemeinschaft Bad Godesberg +(St. Andreas, St. Evergislus, Herz Jesu, St. Hildegard). + +Das ausführliche Grobkonzept liegt in [CONCEPT.md](CONCEPT.md). + +## Voraussetzungen + +- macOS 14 oder neuer +- Xcode 15 oder neuer bzw. Swift 5.9+ +- Keine externen Abhängigkeiten + +## Bauen und starten + +```bash +# Debug-Build und Tests +swift build +swift test + +# App-Bundle erzeugen und öffnen +./Scripts/build-app.sh debug +open build/LektorenPlan.app +``` + +Alternativ `Package.swift` in Xcode öffnen und das Schema `LektorenPlan` +starten. + +Die App legt ihre Datenbank unter +`~/Library/Application Support/LektorenPlan/lektorenplan.sqlite` an und befüllt +sie beim ersten Start mit Demo-Daten. Über **Einstellungen → Demo-Daten +zurücksetzen** lässt sich der Ausgangszustand wiederherstellen. + +## Funktionsüberblick + +- **Kalender & Planung:** Tageszeilen mit Liturgie, Lesungen und Gottesdiensten + der vier Kirchen; Sonntage, Hochfeste und gebotene Feiertage hervorgehoben. +- **Zeitstrahl:** frei wählbarer Zeitraum mit Griffen und Marken für Quartale, + Osterzeit, Weihnachtszeit und Kirchenjahr. +- **Automatische Planung:** harte Ausschlüsse (Rolle, Abwesenheit, Monatslimit, + Doppelbelegung, Einsatztag) und weiche Präferenzen (Kirche, Gottesdienst, + Wochentag, Fairness). +- **Manuelle Nachsteuerung:** Kandidatenvorschläge mit Warnhinweisen, + Einsätze sperren oder entfernen. +- **Gottesdienstordnung:** wiederkehrende Vorlagen, Ausnahmen und + Sondergottesdienste. +- **Team:** Personen, Rollen, Präferenzen, Abwesenheiten, Monatslimits. +- **Statistik:** Besetzungsquote, Fairness, Monatsverlauf, Kirchenverteilung, + Präferenztreffer, Einsatzübersicht (Swift Charts). +- **Austausch:** JSON-Export und -Import für Planungsabschnitte oder Ressourcen + mit Vorschau vor dem Zusammenführen. +- **PDF & Druck:** A4 quer mit automatischer Pagination, PDFKit-Vorschau, + Sichern und direkter Druck. + +## Liturgische Daten + +Die App nutzt den liturgischen Kalender für das Erzbistum Köln über +[www.eucharistiefeier.de](https://www.eucharistiefeier.de). Für 2025–2028 ist +ein Offline-Snapshot enthalten; der aktuelle Jahrgang kann in den Einstellungen +oder über die Kalender-Schaltfläche online aktualisiert werden. + +> Daten von www.eucharistiefeier.de – fair use, ausschließlich zur Anzeige. +> Die Daten bleiben Eigentum der Quelle. + +## Projektstruktur + +``` +Sources/ +├── LektorenPlanCore/ Modelle, SQLite, Liturgie, Planer, Statistik +├── LektorenPlan/ SwiftUI-App, Views, Sheets, PDF-Renderer +Tests/LektorenPlanCoreTests/ +Resources/AppIcon.icns App-Icon +Scripts/build-app.sh erzeugt build/LektorenPlan.app +Scripts/make-icon.swift erzeugt Resources/AppIcon.icns +CONCEPT.md Grobkonzept +``` + +## App-Icon + +Das Icon zeigt eine Kirche als Linienzeichnung im Hintergrund und eine +stilisierte Kalenderkarte im Vordergrund. Es wird per Skript als +ICNS-Datei erzeugt und beim Bauen ins App-Bundle kopiert: + +```bash +swift Scripts/make-icon.swift +./Scripts/build-app.sh debug +``` + +Die Vorschau in voller Auflösung landet unter `build/AppIcon-1024.png`. + +## Entwicklungshelfer + +Für visuelle Prüfungen ohne Bildschirmaufnahme-Berechtigung kann die App eine +Ansicht als PNG rendern und/oder den Plan als PDF schreiben: + +```bash +BIN=$(swift build --show-bin-path) +LP_SNAPSHOT=/tmp/plan.png "$BIN/LektorenPlan" +LP_SNAPSHOT=/tmp/statistik.png LP_SNAPSHOT_VIEW=statistics \ + LP_SNAPSHOT_HEIGHT=2000 "$BIN/LektorenPlan" +LP_PDF=/tmp/plan.pdf "$BIN/LektorenPlan" +``` + +`LP_SNAPSHOT_VIEW` akzeptiert `planning`, `root`, `team`, `order`, +`statistics`, `exchange` und `settings`. Der Auto-Sync ist bei +Snapshot-Läufen deaktiviert. + +## Status + +Prototyp 0.1. Die Demo-Personen und Kontaktdaten sind fiktiv. Produktive +Aspekte wie Benutzerkonten, Benachrichtigungen, Signierung und ein +Mehrbenutzerbetrieb sind noch nicht umgesetzt; siehe Abschnitt „Grenzen“ in +[CONCEPT.md](CONCEPT.md). diff --git a/Resources/AppIcon.icns b/Resources/AppIcon.icns new file mode 100644 index 0000000..6b7c4c8 Binary files /dev/null and b/Resources/AppIcon.icns differ diff --git a/Scripts/build-app.sh b/Scripts/build-app.sh index f030083..0416470 100755 --- a/Scripts/build-app.sh +++ b/Scripts/build-app.sh @@ -19,6 +19,11 @@ mkdir -p "$MACOS" "$RESOURCES" cp "$BIN_DIR/LektorenPlan" "$MACOS/LektorenPlan" +# App icon +if [ -f "$ROOT/Resources/AppIcon.icns" ]; then + cp "$ROOT/Resources/AppIcon.icns" "$RESOURCES/AppIcon.icns" +fi + # Copy SwiftPM resource bundles so Bundle.module keeps working inside the app. for bundle in "$BIN_DIR"/*.bundle; do [ -e "$bundle" ] || continue @@ -36,6 +41,8 @@ cat > "$CONTENTS/Info.plist" <<'PLIST' LektorenPlan CFBundleIdentifier de.badgodesberg.lektorenplan + CFBundleIconFile + AppIcon CFBundleInfoDictionaryVersion 6.0 CFBundleName diff --git a/Scripts/make-icon.swift b/Scripts/make-icon.swift new file mode 100755 index 0000000..c2ad19f --- /dev/null +++ b/Scripts/make-icon.swift @@ -0,0 +1,495 @@ +#!/usr/bin/env swift +// +// Erzeugt das App-Icon für LektorenPlan: +// eine Kirche als Linienzeichnung im Hintergrund, davor eine stilisierte +// Kalenderkarte im Papier-Look der App. +// +// Aufruf: swift Scripts/make-icon.swift +// Ergebnis: Resources/AppIcon.icns (und build/AppIcon-1024.png als Vorschau) +// + +import AppKit +import Foundation + +private enum Icon { + + // MARK: - Palette + + static func color(_ hex: UInt32, alpha: CGFloat = 1) -> NSColor { + NSColor( + srgbRed: CGFloat((hex >> 16) & 0xFF) / 255, + green: CGFloat((hex >> 8) & 0xFF) / 255, + blue: CGFloat(hex & 0xFF) / 255, + alpha: alpha + ) + } + + static let paperTop = color(0xFCF6E8) + static let paperBottom = color(0xEADDC3) + static let accent = color(0x2E5B57) + static let accentLight = color(0x3A716A) + static let accentDeep = color(0x22463F) + static let gold = color(0xB7863B) + static let goldLight = color(0xD9B36A) + static let burgundy = color(0x7E3D4A) + static let cardTop = color(0xFFFEF9) + static let cardBottom = color(0xFFF7E7) + static let cellFill = color(0xF3EAD9) + static let cellStroke = color(0xE0D2B8) + static let cardStroke = color(0xE4D6BC) + + // MARK: - Geometry + + static let canvas: CGFloat = 1024 + static let bodyRect = NSRect(x: 100, y: 100, width: 824, height: 824) + static let bodyRadius: CGFloat = 188 + static let cardRect = NSRect(x: 232, y: 560, width: 560, height: 336) + static let cardRadius: CGFloat = 54 + static let bandHeight: CGFloat = 88 + + // MARK: - Helpers + + static func path(_ rect: NSRect, radius: CGFloat) -> NSBezierPath { + NSBezierPath(roundedRect: rect, xRadius: radius, yRadius: radius) + } + + static func stroke(_ path: NSBezierPath, _ color: NSColor, width: CGFloat) { + color.setStroke() + path.lineWidth = width + path.lineJoinStyle = .round + path.lineCapStyle = .round + path.stroke() + } + + static func fill(_ path: NSBezierPath, _ color: NSColor) { + color.setFill() + path.fill() + } + + static func fillGradient( + _ path: NSBezierPath, + top: NSColor, + bottom: NSColor, + topY: CGFloat, + bottomY: CGFloat + ) { + guard let gradient = NSGradient(colors: [top, bottom]) else { return } + NSGraphicsContext.saveGraphicsState() + path.addClip() + gradient.draw( + from: NSPoint(x: path.bounds.midX, y: topY), + to: NSPoint(x: path.bounds.midX, y: bottomY), + options: [] + ) + NSGraphicsContext.restoreGraphicsState() + } + + static func line(_ points: [NSPoint], _ color: NSColor, width: CGFloat) { + guard let first = points.first else { return } + let p = NSBezierPath() + p.move(to: first) + for point in points.dropFirst() { p.line(to: point) } + stroke(p, color, width: width) + } + + static func circle(center: NSPoint, radius: CGFloat) -> NSBezierPath { + NSBezierPath(ovalIn: NSRect( + x: center.x - radius, + y: center.y - radius, + width: radius * 2, + height: radius * 2 + )) + } + + // MARK: - Drawing + + static func draw() { + drawBody() + drawChurch() + drawCard() + drawRings() + drawGrid() + drawDots() + } + + static func drawBody() { + let body = path(bodyRect, radius: bodyRadius) + + // Soft drop shadow. + NSGraphicsContext.saveGraphicsState() + let shadow = NSShadow() + shadow.shadowColor = NSColor.black.withAlphaComponent(0.22) + shadow.shadowBlurRadius = 38 + shadow.shadowOffset = NSSize(width: 0, height: 18) + shadow.set() + fill(body, paperBottom) + NSGraphicsContext.restoreGraphicsState() + + fillGradient(body, top: paperTop, bottom: paperBottom, topY: bodyRect.minY, bottomY: bodyRect.maxY) + + // Warm light behind the church. + NSGraphicsContext.saveGraphicsState() + body.addClip() + let glowRect = NSRect(x: 232, y: 170, width: 560, height: 560) + if let glow = NSGradient(colors: [ + gold.withAlphaComponent(0.20), + gold.withAlphaComponent(0.0) + ]) { + glow.draw(in: NSBezierPath(ovalIn: glowRect), relativeCenterPosition: .zero) + } + NSGraphicsContext.restoreGraphicsState() + + // Inner rim highlight. + let inset = bodyRect.insetBy(dx: 3, dy: 3) + let rim = path(inset, radius: bodyRadius - 3) + stroke(rim, NSColor.white.withAlphaComponent(0.38), width: 2.5) + } + + static func drawChurch() { + let strokeColor = accent.withAlphaComponent(0.55) + let fillColor = accent.withAlphaComponent(0.065) + let lineWidth: CGFloat = 11 + + // Nave + let nave = NSBezierPath() + nave.move(to: NSPoint(x: 348, y: 566)) + nave.line(to: NSPoint(x: 600, y: 566)) + nave.line(to: NSPoint(x: 600, y: 840)) + nave.line(to: NSPoint(x: 348, y: 840)) + nave.close() + fill(nave, fillColor) + stroke(nave, strokeColor, width: lineWidth) + + // Gable roof + let roof = NSBezierPath() + roof.move(to: NSPoint(x: 312, y: 574)) + roof.line(to: NSPoint(x: 474, y: 354)) + roof.line(to: NSPoint(x: 636, y: 574)) + roof.close() + fill(roof, fillColor) + stroke(roof, strokeColor, width: lineWidth) + + // Tower + let tower = NSBezierPath() + tower.move(to: NSPoint(x: 596, y: 500)) + tower.line(to: NSPoint(x: 716, y: 500)) + tower.line(to: NSPoint(x: 716, y: 840)) + tower.line(to: NSPoint(x: 596, y: 840)) + tower.close() + fill(tower, fillColor) + stroke(tower, strokeColor, width: lineWidth) + + // Spire + let spire = NSBezierPath() + spire.move(to: NSPoint(x: 584, y: 506)) + spire.line(to: NSPoint(x: 656, y: 296)) + spire.line(to: NSPoint(x: 728, y: 506)) + spire.close() + fill(spire, fillColor) + stroke(spire, strokeColor, width: lineWidth) + + // Cross on the tower + line([NSPoint(x: 656, y: 296), NSPoint(x: 656, y: 230)], gold, width: 13) + line([NSPoint(x: 620, y: 263), NSPoint(x: 692, y: 263)], gold, width: 13) + + // Small cross on the nave gable + line([NSPoint(x: 474, y: 354), NSPoint(x: 474, y: 322)], gold, width: 8) + line([NSPoint(x: 457, y: 338), NSPoint(x: 491, y: 338)], gold, width: 8) + + // Rose window + let roseCenter = NSPoint(x: 474, y: 452) + let rose = circle(center: roseCenter, radius: 42) + stroke(rose, accent.withAlphaComponent(0.52), width: 10) + for index in 0..<8 { + let angle = CGFloat(index) * .pi / 4 + let from = NSPoint( + x: roseCenter.x + cos(angle) * 11, + y: roseCenter.y + sin(angle) * 11 + ) + let to = NSPoint( + x: roseCenter.x + cos(angle) * 35, + y: roseCenter.y + sin(angle) * 35 + ) + line([from, to], accent.withAlphaComponent(0.30), width: 5) + } + fill(circle(center: roseCenter, radius: 8), accent.withAlphaComponent(0.18)) + + // Belfry window + let belfry = path(NSRect(x: 634, y: 516, width: 44, height: 64), radius: 22) + stroke(belfry, accent.withAlphaComponent(0.46), width: 8) + line([NSPoint(x: 656, y: 528), NSPoint(x: 656, y: 566)], accent.withAlphaComponent(0.30), width: 4) + } + + static func drawRings() { + for centerX in [CGFloat(400), CGFloat(624)] { + let ringRect = NSRect(x: centerX - 15, y: 506, width: 30, height: 84) + let ring = path(ringRect, radius: 15) + + // Slight shadow so the rings sit on top of the band. + NSGraphicsContext.saveGraphicsState() + let shadow = NSShadow() + shadow.shadowColor = NSColor.black.withAlphaComponent(0.20) + shadow.shadowBlurRadius = 8 + shadow.shadowOffset = NSSize(width: 0, height: 4) + shadow.set() + fill(ring, gold) + NSGraphicsContext.restoreGraphicsState() + + fillGradient(ring, top: goldLight, bottom: gold, topY: ringRect.minY, bottomY: ringRect.maxY) + stroke(ring, gold.withAlphaComponent(0.65), width: 2.5) + + // Soft highlight on the left flank. + let highlight = path( + NSRect(x: ringRect.minX + 4, y: ringRect.minY + 10, width: 5, height: ringRect.height - 20), + radius: 2.5 + ) + fill(highlight, NSColor.white.withAlphaComponent(0.32)) + } + } + + static func drawCard() { + let card = path(cardRect, radius: cardRadius) + + // Shadow + NSGraphicsContext.saveGraphicsState() + let shadow = NSShadow() + shadow.shadowColor = NSColor.black.withAlphaComponent(0.18) + shadow.shadowBlurRadius = 30 + shadow.shadowOffset = NSSize(width: 0, height: 16) + shadow.set() + fill(card, cardBottom) + NSGraphicsContext.restoreGraphicsState() + + fillGradient(card, top: cardTop, bottom: cardBottom, topY: cardRect.minY, bottomY: cardRect.maxY) + + // Accent band + NSGraphicsContext.saveGraphicsState() + card.addClip() + let band = NSRect(x: cardRect.minX, y: cardRect.minY, width: cardRect.width, height: bandHeight) + let bandPath = NSBezierPath(rect: band) + fillGradient( + bandPath, + top: accentLight, + bottom: accentDeep, + topY: band.minY, + bottomY: band.maxY + ) + NSGraphicsContext.restoreGraphicsState() + + // Thin gold seam under the band + line( + [NSPoint(x: cardRect.minX + 2, y: cardRect.minY + bandHeight), + NSPoint(x: cardRect.maxX - 2, y: cardRect.minY + bandHeight)], + gold.withAlphaComponent(0.9), + width: 3 + ) + + // Small gold cross in the band + let bandCenterY = cardRect.minY + bandHeight / 2 + line([NSPoint(x: 512, y: bandCenterY - 22), NSPoint(x: 512, y: bandCenterY + 20)], gold, width: 6) + line([NSPoint(x: 491, y: bandCenterY - 4), NSPoint(x: 533, y: bandCenterY - 4)], gold, width: 6) + + // Card outline + stroke(card, cardStroke, width: 2.5) + } + + static func drawGrid() { + let columns = 5 + let rows = 3 + let cellWidth: CGFloat = 79 + let cellHeight: CGFloat = 48 + let gapX: CGFloat = 14 + let gapY: CGFloat = 12 + + let totalWidth = CGFloat(columns) * cellWidth + CGFloat(columns - 1) * gapX + let originX = cardRect.midX - totalWidth / 2 + let originY = cardRect.minY + bandHeight + 30 + + for row in 0.. NSBitmapImageRep { + guard let rep = NSBitmapImageRep( + bitmapDataPlanes: nil, + pixelsWide: Int(canvas), + pixelsHigh: Int(canvas), + bitsPerSample: 8, + samplesPerPixel: 4, + hasAlpha: true, + isPlanar: false, + colorSpaceName: .deviceRGB, + bytesPerRow: 0, + bitsPerPixel: 0 + ) else { fatalError("Bitmap konnte nicht erzeugt werden") } + rep.size = NSSize(width: canvas, height: canvas) + + NSGraphicsContext.saveGraphicsState() + guard let context = NSGraphicsContext(bitmapImageRep: rep) else { + fatalError("Grafikkontext konnte nicht erzeugt werden") + } + NSGraphicsContext.current = context + context.imageInterpolation = .high + context.shouldAntialias = true + + // Flip to a top-left origin so the drawing code reads top-to-bottom. + let transform = NSAffineTransform() + transform.translateX(by: 0, yBy: canvas) + transform.scaleX(by: 1, yBy: -1) + transform.concat() + + draw() + + NSGraphicsContext.restoreGraphicsState() + return rep + } + + static func pngData(from image: NSImage, size: Int) -> Data? { + guard let rep = NSBitmapImageRep( + bitmapDataPlanes: nil, + pixelsWide: size, + pixelsHigh: size, + bitsPerSample: 8, + samplesPerPixel: 4, + hasAlpha: true, + isPlanar: false, + colorSpaceName: .deviceRGB, + bytesPerRow: 0, + bitsPerPixel: 0 + ) else { return nil } + rep.size = NSSize(width: size, height: size) + + NSGraphicsContext.saveGraphicsState() + guard let context = NSGraphicsContext(bitmapImageRep: rep) else { return nil } + NSGraphicsContext.current = context + context.imageInterpolation = .high + context.shouldAntialias = true + NSColor.clear.setFill() + NSRect(x: 0, y: 0, width: size, height: size).fill() + image.draw( + in: NSRect(x: 0, y: 0, width: size, height: size), + from: NSRect(x: 0, y: 0, width: canvas, height: canvas), + operation: .sourceOver, + fraction: 1 + ) + NSGraphicsContext.restoreGraphicsState() + return rep.representation(using: .png, properties: [:]) + } +} + +// MARK: - Main + +let root = URL(fileURLWithPath: #filePath) + .deletingLastPathComponent() + .deletingLastPathComponent() +let resources = root.appendingPathComponent("Resources", isDirectory: true) +let build = root.appendingPathComponent("build", isDirectory: true) +let fileManager = FileManager.default + +try fileManager.createDirectory(at: resources, withIntermediateDirectories: true) +try fileManager.createDirectory(at: build, withIntermediateDirectories: true) + +let masterRep = Icon.renderMaster() +guard let masterPNG = masterRep.representation(using: .png, properties: [:]) else { + fatalError("Master-PNG konnte nicht erzeugt werden") +} +try masterPNG.write(to: build.appendingPathComponent("AppIcon-1024.png")) + +guard let masterImage = NSImage(data: masterPNG) else { + fatalError("Master-Bild konnte nicht geladen werden") +} + +let iconset = resources.appendingPathComponent("AppIcon.iconset", isDirectory: true) +try? fileManager.removeItem(at: iconset) +try fileManager.createDirectory(at: iconset, withIntermediateDirectories: true) + +let variants: [(name: String, size: Int)] = [ + ("icon_16x16", 16), + ("icon_16x16@2x", 32), + ("icon_32x32", 32), + ("icon_32x32@2x", 64), + ("icon_128x128", 128), + ("icon_128x128@2x", 256), + ("icon_256x256", 256), + ("icon_256x256@2x", 512), + ("icon_512x512", 512), + ("icon_512x512@2x", 1024) +] + +for variant in variants { + guard let data = Icon.pngData(from: masterImage, size: variant.size) else { + fatalError("PNG für \(variant.name) konnte nicht erzeugt werden") + } + try data.write(to: iconset.appendingPathComponent("\(variant.name).png")) +} + +let icnsURL = resources.appendingPathComponent("AppIcon.icns") +try? fileManager.removeItem(at: icnsURL) + +let iconutil = Process() +iconutil.executableURL = URL(fileURLWithPath: "/usr/bin/iconutil") +iconutil.arguments = ["-c", "icns", iconset.path, "-o", icnsURL.path] +try iconutil.run() +iconutil.waitUntilExit() +guard iconutil.terminationStatus == 0 else { + fatalError("iconutil ist mit Status \(iconutil.terminationStatus) fehlgeschlagen") +} + +try? fileManager.removeItem(at: iconset) + +print("Icon erzeugt: \(icnsURL.path)") +print("Vorschau: \(build.appendingPathComponent("AppIcon-1024.png").path)")