a09d4b3da4
- 내보내기 완료 화면(공유·다시 만들기 아래)에 '내보낸 날짜의 일기 삭제…' — 확인 다이얼로그, iCloud 전 기기 삭제·양식 보존 안내, 열람 전용 숨김 - 별도 Section 조건부 삽입은 시트 표시 중 렌더되지 않아 기존 섹션 분기 안 배치로 확정 - PDF/스티치 PNG 렌더 코어를 DiaryExportRenderer로 추출 — 데이터 정리·초기화 백업이 재사용 (동작·규칙 불변, PDF 산출 회귀 확인) - -diaryExportDeleteTest E2E: 내보내기→삭제→재실행 후 달력 마커 소멸 확인 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01NNxA172hNDRpDsJ2qztKPf
532 lines
24 KiB
Swift
532 lines
24 KiB
Swift
//
|
||
// DiaryExportSheet.swift
|
||
// Haru_Danim
|
||
//
|
||
// 일기 내보내기 — 날짜 구간(부터~까지) 또는 복수 날짜 지정(1개만도 가능)으로
|
||
// 해당 날짜들의 일기를 PDF 또는 이미지(PNG)로 만들어 공유한다.
|
||
// - PDF: 일기 페이지(요약 + 노트들)를 각각 한 페이지로 담은 문서 1개
|
||
// - 이미지: 날짜마다 페이지들을 세로로 이어 붙인 PNG 1장씩
|
||
// 렌더는 화면과 동일한 논리 크기(요약 768pt 폭 / 노트 768×1024pt)에서 2배율로 수행한다.
|
||
//
|
||
|
||
import SwiftUI
|
||
import SwiftData
|
||
import PencilKit
|
||
import UIKit
|
||
|
||
struct DiaryExportSheet: View {
|
||
@Environment(\.dismiss) private var dismiss
|
||
@Environment(\.modelContext) private var context
|
||
@Environment(\.diaryReadOnly) private var readOnly
|
||
|
||
@Query private var diaryEntries: [DiaryEntry]
|
||
@Query(sort: \Action.createdAt) private var allActionsQuery: [Action]
|
||
@Query private var diaryTemplates: [DiaryTemplate]
|
||
@AppStorage(LocalPrefsKeys.actionOrder, store: AppGroup.defaults) private var actionOrderRaw = ""
|
||
|
||
private enum SelectionMode: String, CaseIterable, Identifiable {
|
||
case range, picks
|
||
var id: String { rawValue }
|
||
var label: String {
|
||
switch self {
|
||
case .range: return String(localized: "구간 지정")
|
||
case .picks: return String(localized: "날짜 지정")
|
||
}
|
||
}
|
||
}
|
||
|
||
private enum ExportFormat: String, CaseIterable, Identifiable {
|
||
case pdf, image
|
||
var id: String { rawValue }
|
||
var label: String {
|
||
switch self {
|
||
case .pdf: return "PDF"
|
||
case .image: return String(localized: "이미지")
|
||
}
|
||
}
|
||
}
|
||
|
||
@State private var mode: SelectionMode = .range
|
||
@State private var startDate: Date = Calendar.current.date(byAdding: .day, value: -6, to: .now)!
|
||
@State private var endDate: Date = .now
|
||
@State private var picks: Set<DateComponents> = []
|
||
@State private var format: ExportFormat = .pdf
|
||
@State private var isRendering = false
|
||
@State private var resultURLs: [URL] = []
|
||
@State private var confirmingDelete = false
|
||
|
||
private var math: DayMath { DayMath() }
|
||
|
||
private var orderedActions: [Action] {
|
||
LocalPrefs.orderedActions(allActionsQuery, raw: actionOrderRaw)
|
||
}
|
||
|
||
/// 선택 조건에 해당하고 내용이 있는 일기 (날짜순).
|
||
/// 날짜 선택 UI에서 고른 달력일은 곧 일기 키의 달력일이다 — DiaryEntry.dayKey가
|
||
/// "해당 달력일의 자정"이므로 자정(startOfDay)을 키로 직접 쓴다.
|
||
/// ⚠️ 자정 Date를 dayKey(for:)에 넣으면 하루 시작 시간이 자정보다 늦을 때
|
||
/// 전날로 밀려, 고른 날짜의 전날 일기가 내보내지는 버그가 있었다.
|
||
private var targetEntries: [DiaryEntry] {
|
||
let keys: Set<Date>
|
||
switch mode {
|
||
case .range:
|
||
let startKey = math.calendar.startOfDay(for: min(startDate, endDate))
|
||
let endKey = math.calendar.startOfDay(for: max(startDate, endDate))
|
||
keys = Set(diaryEntries.map(\.dayKey).filter { $0 >= startKey && $0 <= endKey })
|
||
case .picks:
|
||
keys = Set(picks.compactMap { components in
|
||
math.calendar.date(from: components).map { math.calendar.startOfDay(for: $0) }
|
||
})
|
||
}
|
||
return diaryEntries
|
||
.filter { keys.contains($0.dayKey) && $0.hasContent }
|
||
.sorted { $0.dayKey < $1.dayKey }
|
||
}
|
||
|
||
var body: some View {
|
||
NavigationStack {
|
||
Form {
|
||
Section("날짜 선택") {
|
||
Picker("방식", selection: $mode) {
|
||
ForEach(SelectionMode.allCases) { mode in
|
||
Text(mode.label).tag(mode)
|
||
}
|
||
}
|
||
.pickerStyle(.segmented)
|
||
|
||
switch mode {
|
||
case .range:
|
||
DatePicker("부터", selection: $startDate, displayedComponents: .date)
|
||
DatePicker("까지", selection: $endDate, displayedComponents: .date)
|
||
case .picks:
|
||
MultiDatePicker("날짜", selection: $picks)
|
||
.frame(minHeight: 300)
|
||
.tint(AppTheme.green)
|
||
}
|
||
|
||
Label {
|
||
Text("일기를 쓴 날 \(targetEntries.count)일이 포함돼요")
|
||
} icon: {
|
||
Image(systemName: "pencil.and.scribble")
|
||
}
|
||
.font(.footnote)
|
||
.foregroundStyle(targetEntries.isEmpty ? AnyShapeStyle(.secondary) : AnyShapeStyle(AppTheme.green))
|
||
}
|
||
|
||
Section("형식") {
|
||
Picker("형식", selection: $format) {
|
||
ForEach(ExportFormat.allCases) { format in
|
||
Text(format.label).tag(format)
|
||
}
|
||
}
|
||
.pickerStyle(.segmented)
|
||
Text(format == .pdf
|
||
? "일기 페이지들을 담은 PDF 문서 1개를 만들어요."
|
||
: "날짜마다 페이지들을 세로로 이어 붙인 PNG 이미지를 만들어요.")
|
||
.font(.caption)
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
|
||
Section {
|
||
if isRendering {
|
||
HStack {
|
||
ProgressView()
|
||
Text("만드는 중…")
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
} else if resultURLs.isEmpty {
|
||
Button {
|
||
export()
|
||
} label: {
|
||
Label("내보내기", systemImage: "square.and.arrow.up")
|
||
.frame(maxWidth: .infinity)
|
||
}
|
||
.disabled(targetEntries.isEmpty)
|
||
} else {
|
||
ShareLink(items: resultURLs) {
|
||
Label("파일 \(resultURLs.count)개 공유", systemImage: "square.and.arrow.up")
|
||
.frame(maxWidth: .infinity)
|
||
}
|
||
Button("다시 만들기") {
|
||
resultURLs = []
|
||
}
|
||
.frame(maxWidth: .infinity)
|
||
// 내보내기 후 삭제 (1.4) — 결과물을 먼저 저장하도록 공유 아래에만 노출.
|
||
// 별도 Section 대신 같은 섹션의 분기 안에 두는 이유: 시트가 떠 있는
|
||
// 동안 뒤에 새 Section을 조건부 삽입하면 그려지지 않는 문제가 있었다
|
||
// (분기 교체는 섹션 구조가 안정적이라 안전). 열람 전용은 숨김 (§6.7)
|
||
if !readOnly {
|
||
Button(role: .destructive) {
|
||
confirmingDelete = true
|
||
} label: {
|
||
Label("내보낸 날짜의 일기 삭제…", systemImage: "trash")
|
||
.frame(maxWidth: .infinity)
|
||
}
|
||
}
|
||
}
|
||
} footer: {
|
||
if !resultURLs.isEmpty && !readOnly {
|
||
Text("삭제를 누르면 방금 내보낸 \(targetEntries.count)일의 일기(필기·사진·할 일 포함)를 앱에서 지워 저장 공간을 줄여요. iCloud 동기화를 켰다면 다른 기기에서도 함께 삭제돼요. 행동·기록·목표와 양식 라이브러리는 그대로 남아요.")
|
||
} else {
|
||
Text("결과물은 일기 상세와 같은 구성(요약 + 노트 페이지)으로 만들어져요.")
|
||
}
|
||
}
|
||
}
|
||
.confirmationDialog(
|
||
"일기 \(targetEntries.count)일치를 삭제할까요?",
|
||
isPresented: $confirmingDelete,
|
||
titleVisibility: .visible
|
||
) {
|
||
Button("삭제", role: .destructive) { deleteExported() }
|
||
} message: {
|
||
Text("먼저 공유로 파일을 저장했는지 확인해 주세요. 삭제는 되돌릴 수 없어요.")
|
||
}
|
||
.tint(AppTheme.green)
|
||
.scrollContentBackground(.hidden)
|
||
.background(AppTheme.background)
|
||
.navigationTitle("일기 내보내기")
|
||
.navigationBarTitleDisplayMode(.inline)
|
||
.toolbar {
|
||
ToolbarItem(placement: .topBarTrailing) {
|
||
Button("닫기") { dismiss() }
|
||
}
|
||
}
|
||
}
|
||
.onAppear {
|
||
#if DEBUG
|
||
// 검증용: -diaryExportRun pdf|image → 자동 내보내기 후 Documents에 결과 복사
|
||
if let raw = UserDefaults.standard.string(forKey: "diaryExportRun") {
|
||
format = raw == "image" ? .image : .pdf
|
||
export()
|
||
}
|
||
#endif
|
||
}
|
||
// 조건이 바뀌면 이전 결과를 무효화
|
||
.onChange(of: mode) { resultURLs = [] }
|
||
.onChange(of: startDate) { resultURLs = [] }
|
||
.onChange(of: endDate) { resultURLs = [] }
|
||
.onChange(of: picks) { resultURLs = [] }
|
||
.onChange(of: format) { resultURLs = [] }
|
||
}
|
||
|
||
// MARK: 내보낸 날짜 삭제 (1.4)
|
||
|
||
/// 방금 내보낸 일기들을 삭제 — cascade로 페이지·요소·할 일·기분 사진까지 정리되고,
|
||
/// 양식(DiaryTemplate)은 라이브러리 개념이라 남긴다 (§6.7 양식 삭제 정책과 동일)
|
||
private func deleteExported() {
|
||
for entry in targetEntries {
|
||
context.delete(entry)
|
||
}
|
||
DataChange.commit(context: context)
|
||
dismiss()
|
||
}
|
||
|
||
// MARK: 렌더링 (코어는 DiaryExportRenderer — 데이터 정리·초기화 백업과 공유)
|
||
|
||
private var renderer: DiaryExportRenderer {
|
||
DiaryExportRenderer(context: context, orderedActions: orderedActions,
|
||
templates: diaryTemplates, math: math)
|
||
}
|
||
|
||
private func export() {
|
||
isRendering = true
|
||
let entries = targetEntries
|
||
Task { @MainActor in
|
||
// 시트 UI가 스피너를 그릴 틈을 준다 (렌더 자체는 메인에서 수행)
|
||
try? await Task.sleep(for: .milliseconds(60))
|
||
var urls: [URL] = []
|
||
switch format {
|
||
case .pdf:
|
||
if let url = renderer.pdfURL(entries: entries, fileSlug: fileSlug) { urls = [url] }
|
||
case .image:
|
||
urls = entries.compactMap { renderer.stitchedImageURL($0) }
|
||
}
|
||
resultURLs = urls
|
||
isRendering = false
|
||
#if DEBUG
|
||
if UserDefaults.standard.string(forKey: "diaryExportRun") != nil,
|
||
let docs = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first {
|
||
for url in urls {
|
||
let dest = docs.appendingPathComponent(url.lastPathComponent)
|
||
try? FileManager.default.removeItem(at: dest)
|
||
try? FileManager.default.copyItem(at: url, to: dest)
|
||
}
|
||
}
|
||
// 검증용: -diaryExportDeleteTest YES → 내보내기 완료 후 '삭제' 버튼과
|
||
// 같은 가드·같은 경로로 삭제 실행 (E2E — 재실행 후 달력 마커 소멸로 판정)
|
||
if UserDefaults.standard.bool(forKey: "diaryExportDeleteTest"),
|
||
!urls.isEmpty, !readOnly {
|
||
try? await Task.sleep(for: .seconds(1))
|
||
deleteExported()
|
||
}
|
||
#endif
|
||
}
|
||
}
|
||
|
||
private var fileSlug: String {
|
||
let entries = targetEntries
|
||
// 파일명은 언어별 현지화 (ExportSnapshot.fileName과 같은 이유)
|
||
guard let first = entries.first else { return String(localized: "일기") }
|
||
if entries.count == 1 { return String(localized: "일기-\(DiaryExportRenderer.slugDate(first.dayKey))") }
|
||
return String(localized: "일기-\(DiaryExportRenderer.slugDate(first.dayKey))~\(DiaryExportRenderer.slugDate(entries.last!.dayKey))")
|
||
}
|
||
}
|
||
|
||
// MARK: - 일기 렌더 코어 (1.4에서 시트에서 추출 — 초기화 백업과 공유)
|
||
|
||
/// 일기 → PDF/스티치 PNG 렌더러. 시트와 '데이터 정리·초기화'(삭제 전 백업)가 공유한다.
|
||
/// 렌더 규칙은 기존과 동일: 화면(하루 정리)과 같은 스냅숏 구성, 라이트 트레잇 고정,
|
||
/// 논리 크기(요약 768pt 폭 / 노트 768×1024pt) 2배율.
|
||
@MainActor
|
||
struct DiaryExportRenderer {
|
||
let context: ModelContext
|
||
let orderedActions: [Action]
|
||
let templates: [DiaryTemplate]
|
||
let math: DayMath
|
||
|
||
static func slugDate(_ date: Date) -> String {
|
||
let formatter = DateFormatter()
|
||
formatter.dateFormat = "yyyy-MM-dd"
|
||
return formatter.string(from: date)
|
||
}
|
||
|
||
/// 렌더 대상 날짜(논리적 하루)에 겹치는 기록만 그때그때 조회 — 전량 @Query 로드 방지
|
||
private func fetchRecords(for entry: DiaryEntry) -> (sessions: [TimeSession], counts: [CountEntry]) {
|
||
let range = math.dayRange(forKey: entry.dayKey)
|
||
let lower = range.lowerBound
|
||
let upper = range.upperBound
|
||
let farFuture = Date.distantFuture
|
||
let sessions = (try? context.fetch(FetchDescriptor<TimeSession>(
|
||
predicate: #Predicate { $0.startAt < upper && ($0.endAt ?? farFuture) > lower }
|
||
))) ?? []
|
||
let counts = (try? context.fetch(FetchDescriptor<CountEntry>(
|
||
predicate: #Predicate { $0.timestamp >= lower && $0.timestamp < upper }
|
||
))) ?? []
|
||
return (sessions, counts)
|
||
}
|
||
|
||
/// 한 일기의 모든 페이지를 이미지로 (요약 + 노트들)
|
||
func renderPages(_ entry: DiaryEntry) -> [UIImage] {
|
||
var images: [UIImage] = []
|
||
let records = fetchRecords(for: entry)
|
||
var snapshot = ExportBuilder.history(
|
||
dayKey: entry.dayKey, weeklyTimetable: false,
|
||
sessions: records.sessions, entries: records.counts,
|
||
orderedActions: orderedActions, excludedActionIDs: [], math: math,
|
||
trimHours: false
|
||
)
|
||
// 화면(하루 정리)과 동일하게 그날 숨긴 행동은 타임테이블에서만 제외 (기록 목록은 전체 유지).
|
||
// 날짜별 재정의가 없으면 기기 기본값이 적용된다 (DiaryDefaults, 1.2 — 화면과 동일 규칙)
|
||
let hidden = DiaryDefaults.effectiveHiddenActions(for: entry)
|
||
if !hidden.isEmpty {
|
||
let excluded = Set(
|
||
orderedActions.filter { hidden.contains($0.uuid.uuidString) }.map(\.persistentModelID)
|
||
)
|
||
if !excluded.isEmpty {
|
||
snapshot = snapshot.replacingTimetableSections(with: ExportBuilder.history(
|
||
dayKey: entry.dayKey, weeklyTimetable: false,
|
||
sessions: records.sessions, entries: records.counts,
|
||
orderedActions: orderedActions, excludedActionIDs: excluded, math: math,
|
||
trimHours: false
|
||
))
|
||
}
|
||
}
|
||
// 화면(하루 정리)과 동일하게 24시간 전체 + 선택한 캘린더 일정을 담는다
|
||
snapshot = snapshot.injectingCalendarEvents(DiaryCalendarEvents.timetableBlocks(for: entry, math: math))
|
||
let summary = DiaryPrintSummaryView(entry: entry, snapshot: snapshot)
|
||
let summaryRenderer = ImageRenderer(content: summary)
|
||
summaryRenderer.scale = 2
|
||
summaryRenderer.isOpaque = true
|
||
if let image = summaryRenderer.uiImage {
|
||
images.append(image)
|
||
}
|
||
for page in entry.pages where page.hasContent {
|
||
let size = DiaryPageMetrics.size
|
||
var drawingImage: UIImage?
|
||
if !page.drawingData.isEmpty, let drawing = try? PKDrawing(data: page.drawingData) {
|
||
// 인쇄 페이지는 라이트 고정(흰 종이)이라 획 색도 라이트 기준으로 못 박는다 —
|
||
// PKDrawing.image는 호출 시점의 현재 트레잇을 따르므로, 고정하지 않으면
|
||
// 다크 모드에서 내보낼 때 획이 반전된 색(흰색)으로 렌더될 수 있다
|
||
UITraitCollection(userInterfaceStyle: .light).performAsCurrent {
|
||
drawingImage = drawing.image(from: CGRect(origin: .zero, size: size), scale: 2)
|
||
}
|
||
}
|
||
// 배경 양식도 화면과 동일하게 담는다 (양식이 삭제됐으면 화면처럼 빈 캔버스)
|
||
var templateImage: UIImage?
|
||
if !page.templateID.isEmpty,
|
||
let template = templates.first(where: { $0.uuid.uuidString == page.templateID }) {
|
||
templateImage = DiaryTemplateRenderer.image(
|
||
for: template, pageIndex: page.templatePageIndex, scale: 2
|
||
)
|
||
}
|
||
let view = DiaryPrintNotePageView(page: page, drawingImage: drawingImage,
|
||
templateImage: templateImage)
|
||
let renderer = ImageRenderer(content: view)
|
||
renderer.scale = 2
|
||
renderer.isOpaque = true
|
||
if let image = renderer.uiImage {
|
||
images.append(image)
|
||
}
|
||
}
|
||
return images
|
||
}
|
||
|
||
/// PDF 1개 — 일기 페이지마다 PDF 한 페이지 (페이지 크기는 내용 크기 그대로)
|
||
func pdfURL(entries: [DiaryEntry], fileSlug: String) -> URL? {
|
||
let url = FileManager.default.temporaryDirectory
|
||
.appendingPathComponent(String(localized: "하루다님-\(fileSlug).pdf"))
|
||
let bounds = CGRect(origin: .zero, size: DiaryPageMetrics.size)
|
||
let renderer = UIGraphicsPDFRenderer(bounds: bounds)
|
||
do {
|
||
try renderer.writePDF(to: url) { pdf in
|
||
for entry in entries {
|
||
for image in renderPages(entry) {
|
||
let pageWidth = DiaryPageMetrics.size.width
|
||
let pageHeight = image.size.height * pageWidth / image.size.width
|
||
let pageBounds = CGRect(x: 0, y: 0, width: pageWidth, height: pageHeight)
|
||
pdf.beginPage(withBounds: pageBounds, pageInfo: [:])
|
||
image.draw(in: pageBounds)
|
||
}
|
||
}
|
||
}
|
||
return url
|
||
} catch {
|
||
return nil
|
||
}
|
||
}
|
||
|
||
/// 날짜 하나 → 페이지들을 세로로 이어 붙인 PNG
|
||
func stitchedImageURL(_ entry: DiaryEntry) -> URL? {
|
||
let images = renderPages(entry)
|
||
guard !images.isEmpty else { return nil }
|
||
let width = DiaryPageMetrics.size.width
|
||
let gap: CGFloat = 20
|
||
let heights = images.map { $0.size.height * width / $0.size.width }
|
||
let totalHeight = heights.reduce(0, +) + gap * CGFloat(images.count - 1)
|
||
|
||
let rendererFormat = UIGraphicsImageRendererFormat()
|
||
rendererFormat.scale = 2
|
||
let renderer = UIGraphicsImageRenderer(
|
||
size: CGSize(width: width, height: totalHeight), format: rendererFormat
|
||
)
|
||
let stitched = renderer.image { ctx in
|
||
UIColor(AppTheme.background).setFill()
|
||
ctx.fill(CGRect(x: 0, y: 0, width: width, height: totalHeight))
|
||
var y: CGFloat = 0
|
||
for (image, height) in zip(images, heights) {
|
||
image.draw(in: CGRect(x: 0, y: y, width: width, height: height))
|
||
y += height + gap
|
||
}
|
||
}
|
||
guard let data = stitched.pngData() else { return nil }
|
||
let url = FileManager.default.temporaryDirectory
|
||
.appendingPathComponent(String(localized: "하루다님-일기-\(Self.slugDate(entry.dayKey)).png"))
|
||
try? data.write(to: url, options: .atomic)
|
||
return url
|
||
}
|
||
}
|
||
|
||
// MARK: - 인쇄용 요약 페이지 (768pt 고정 폭)
|
||
|
||
struct DiaryPrintSummaryView: View {
|
||
let entry: DiaryEntry
|
||
let snapshot: ExportSnapshot
|
||
|
||
private let width: CGFloat = 768
|
||
private var innerWidth: CGFloat { width - 40 - 28 }
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 14) {
|
||
HStack(alignment: .top) {
|
||
VStack(alignment: .leading, spacing: 3) {
|
||
Text(Format.fullDate(entry.dayKey))
|
||
.font(.system(size: 26, weight: .bold))
|
||
Text("하루 다님 일기")
|
||
.font(.subheadline)
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
if !entry.moodEmoji.isEmpty {
|
||
Text(entry.moodEmoji)
|
||
.font(.system(size: 44))
|
||
}
|
||
if let data = entry.moodImageData, let image = UIImage(data: data) {
|
||
Image(uiImage: image)
|
||
.resizable()
|
||
.scaledToFill()
|
||
.frame(width: 64, height: 64)
|
||
.clipShape(RoundedRectangle(cornerRadius: 14, style: .continuous))
|
||
}
|
||
}
|
||
|
||
if !entry.todos.isEmpty {
|
||
VStack(alignment: .leading, spacing: 8) {
|
||
Text("오늘 할 일")
|
||
.font(.subheadline.weight(.semibold))
|
||
ForEach(entry.todos, id: \.uuid) { todo in
|
||
HStack(spacing: 8) {
|
||
Image(systemName: todo.isDone ? "checkmark.circle.fill" : "circle")
|
||
.foregroundStyle(todo.isDone ? AnyShapeStyle(AppTheme.green) : AnyShapeStyle(.secondary))
|
||
Text(todo.text)
|
||
.font(.footnote)
|
||
.strikethrough(todo.isDone, color: .secondary)
|
||
.foregroundStyle(todo.isDone ? .secondary : .primary)
|
||
}
|
||
}
|
||
}
|
||
.padding(14)
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
.background(AppTheme.surface, in: RoundedRectangle(cornerRadius: 16, style: .continuous))
|
||
}
|
||
|
||
if !snapshot.hero.isEmpty {
|
||
ExportHeroRow(stats: snapshot.hero)
|
||
}
|
||
ForEach(Array(snapshot.sections.enumerated()), id: \.offset) { _, section in
|
||
ExportSectionView(section: section, innerWidth: innerWidth)
|
||
}
|
||
}
|
||
.padding(20)
|
||
.frame(width: width, alignment: .leading)
|
||
.background(AppTheme.background)
|
||
.environment(\.colorScheme, .light)
|
||
}
|
||
}
|
||
|
||
// MARK: - 인쇄용 노트 페이지 (768×1024 고정)
|
||
|
||
struct DiaryPrintNotePageView: View {
|
||
let page: DiaryPage
|
||
let drawingImage: UIImage?
|
||
var templateImage: UIImage? = nil
|
||
|
||
var body: some View {
|
||
ZStack {
|
||
Rectangle().fill(AppTheme.surface)
|
||
if page.lined, templateImage == nil {
|
||
DiaryLinedPaper(spacing: page.lineSpacing)
|
||
}
|
||
if let templateImage {
|
||
Image(uiImage: templateImage)
|
||
.resizable()
|
||
.scaledToFit()
|
||
}
|
||
ForEach(page.items, id: \.uuid) { item in
|
||
DiaryItemView(
|
||
item: item,
|
||
pageSize: DiaryPageMetrics.size,
|
||
arranging: false,
|
||
selectedID: .constant(nil)
|
||
)
|
||
}
|
||
if let drawingImage {
|
||
Image(uiImage: drawingImage)
|
||
.resizable()
|
||
.scaledToFit()
|
||
}
|
||
}
|
||
.frame(width: DiaryPageMetrics.size.width, height: DiaryPageMetrics.size.height)
|
||
.environment(\.colorScheme, .light)
|
||
}
|
||
}
|