mirror of
https://github.com/h3pdesign/Neon-Vision-Editor
synced 2026-04-21 13:27:16 +00:00
3313 lines
138 KiB
Swift
3313 lines
138 KiB
Swift
import SwiftUI
|
|
#if os(macOS)
|
|
import AppKit
|
|
#endif
|
|
#if canImport(CoreText)
|
|
import CoreText
|
|
#endif
|
|
#if canImport(UIKit)
|
|
import UIKit
|
|
#endif
|
|
|
|
|
|
|
|
/// MARK: - Types
|
|
|
|
struct NeonSettingsView: View {
|
|
private struct SettingsTabPage: View {
|
|
let title: String
|
|
let systemImage: String
|
|
let tag: String
|
|
let content: AnyView
|
|
|
|
var body: some View {
|
|
content
|
|
.tabItem { Label(title, systemImage: systemImage) }
|
|
.tag(tag)
|
|
}
|
|
}
|
|
|
|
fileprivate static let defaultSettingsTab = "general"
|
|
private static var cachedEditorFonts: [String] = []
|
|
let supportsOpenInTabs: Bool
|
|
let supportsTranslucency: Bool
|
|
@EnvironmentObject private var supportPurchaseManager: SupportPurchaseManager
|
|
@EnvironmentObject private var appUpdateManager: AppUpdateManager
|
|
@Environment(\.horizontalSizeClass) private var horizontalSizeClass
|
|
@Environment(\.colorScheme) private var systemColorScheme
|
|
@Environment(\.openURL) private var openURL
|
|
@AppStorage("SettingsOpenInTabs") private var openInTabs: String = "system"
|
|
@AppStorage("SettingsEditorFontName") private var editorFontName: String = ""
|
|
@AppStorage("SettingsUseSystemFont") private var useSystemFont: Bool = false
|
|
@AppStorage("SettingsEditorFontSize") private var editorFontSize: Double = 14
|
|
@AppStorage("SettingsLineHeight") private var lineHeight: Double = 1.0
|
|
@AppStorage("SettingsAppearance") private var appearance: String = "system"
|
|
@AppStorage("SettingsToolbarSymbolsColorMac") private var toolbarSymbolsColorMacRaw: String = "blue"
|
|
#if os(iOS)
|
|
@AppStorage("EnableTranslucentWindow") private var translucentWindow: Bool = true
|
|
#else
|
|
@AppStorage("EnableTranslucentWindow") private var translucentWindow: Bool = false
|
|
#endif
|
|
@AppStorage("SettingsMacTranslucencyMode") private var macTranslucencyModeRaw: String = "balanced"
|
|
@AppStorage("SettingsReopenLastSession") private var reopenLastSession: Bool = true
|
|
@AppStorage("SettingsOpenWithBlankDocument") private var openWithBlankDocument: Bool = true
|
|
@AppStorage("SettingsDefaultNewFileLanguage") private var defaultNewFileLanguage: String = "plain"
|
|
@AppStorage("SettingsConfirmCloseDirtyTab") private var confirmCloseDirtyTab: Bool = true
|
|
@AppStorage("SettingsConfirmClearEditor") private var confirmClearEditor: Bool = true
|
|
@AppStorage("SettingsRemoteSessionsEnabled") private var remoteSessionsEnabled: Bool = false
|
|
@AppStorage("SettingsRemoteHost") private var remoteHost: String = ""
|
|
@AppStorage("SettingsRemoteUsername") private var remoteUsername: String = ""
|
|
@AppStorage("SettingsRemotePort") private var remotePort: Int = 22
|
|
@AppStorage("SettingsRemotePreparedTarget") private var remotePreparedTarget: String = ""
|
|
@AppStorage(AppUpdateManager.autoCheckEnabledKey) private var autoCheckForUpdates: Bool = true
|
|
@AppStorage(AppUpdateManager.updateIntervalKey) private var updateCheckIntervalRaw: String = AppUpdateCheckInterval.daily.rawValue
|
|
@AppStorage(AppUpdateManager.autoDownloadEnabledKey) private var autoDownloadUpdates: Bool = false
|
|
|
|
@AppStorage("SettingsShowLineNumbers") private var showLineNumbers: Bool = true
|
|
@AppStorage("SettingsHighlightCurrentLine") private var highlightCurrentLine: Bool = false
|
|
@AppStorage("SettingsHighlightMatchingBrackets") private var highlightMatchingBrackets: Bool = false
|
|
@AppStorage("SettingsShowScopeGuides") private var showScopeGuides: Bool = false
|
|
@AppStorage("SettingsHighlightScopeBackground") private var highlightScopeBackground: Bool = false
|
|
@AppStorage("SettingsLineWrapEnabled") private var lineWrapEnabled: Bool = false
|
|
@AppStorage("SettingsIndentStyle") private var indentStyle: String = "spaces"
|
|
@AppStorage("SettingsIndentWidth") private var indentWidth: Int = 4
|
|
@AppStorage("SettingsAutoIndent") private var autoIndent: Bool = true
|
|
@AppStorage("SettingsAutoCloseBrackets") private var autoCloseBrackets: Bool = false
|
|
@AppStorage("SettingsTrimTrailingWhitespace") private var trimTrailingWhitespace: Bool = false
|
|
@AppStorage("SettingsTrimWhitespaceForSyntaxDetection") private var trimWhitespaceForSyntaxDetection: Bool = false
|
|
@AppStorage("EditorVimModeEnabled") private var vimModeEnabled: Bool = false
|
|
@AppStorage("EditorVimInterceptionEnabled") private var vimInterceptionEnabled: Bool = false
|
|
@AppStorage("SettingsProjectNavigatorPlacement") private var projectNavigatorPlacementRaw: String = ContentView.ProjectNavigatorPlacement.trailing.rawValue
|
|
@AppStorage("SettingsPerformancePreset") private var performancePresetRaw: String = ContentView.PerformancePreset.balanced.rawValue
|
|
@AppStorage("SettingsLargeFileSyntaxHighlighting") private var largeFileSyntaxHighlightingRaw: String = "minimal"
|
|
@AppStorage("SettingsLargeFileOpenMode") private var largeFileOpenModeRaw: String = "deferred"
|
|
|
|
@AppStorage("SettingsCompletionEnabled") private var completionEnabled: Bool = false
|
|
@AppStorage("SettingsCompletionFromDocument") private var completionFromDocument: Bool = false
|
|
@AppStorage("SettingsCompletionFromSyntax") private var completionFromSyntax: Bool = false
|
|
@AppStorage("SelectedAIModel") private var selectedAIModelRaw: String = AIModel.appleIntelligence.rawValue
|
|
@AppStorage("SettingsActiveTab") private var settingsActiveTab: String = defaultSettingsTab
|
|
@AppStorage("SettingsTemplateLanguage") private var settingsTemplateLanguage: String = "swift"
|
|
@State private var remoteSessionStore = RemoteSessionStore.shared
|
|
@State private var grokAPIToken: String = ""
|
|
@State private var openAIAPIToken: String = ""
|
|
@State private var geminiAPIToken: String = ""
|
|
@State private var anthropicAPIToken: String = ""
|
|
@State private var showSupportPurchaseDialog: Bool = false
|
|
@State private var showDataDisclosureDialog: Bool = false
|
|
@State private var showRemoteConnectSheet: Bool = false
|
|
@State private var availableEditorFonts: [String] = []
|
|
@State private var moreSectionTab: String = "support"
|
|
@State private var editorSectionTab: String = "basics"
|
|
@State private var diagnosticsCopyStatus: String = ""
|
|
@State private var remotePreparationStatus: String = ""
|
|
@State private var remoteConnectNickname: String = ""
|
|
@State private var supportRefreshTask: Task<Void, Never>?
|
|
@State private var isDiscoveringFonts: Bool = false
|
|
private let privacyPolicyURL = URL(string: "https://github.com/h3pdesign/Neon-Vision-Editor/blob/main/PRIVACY.md")
|
|
private let termsOfUseURL = URL(string: "https://www.apple.com/legal/internet-services/itunes/dev/stdeula/")
|
|
|
|
@AppStorage("SettingsThemeName") private var selectedTheme: String = "Neon Glow"
|
|
@AppStorage("SettingsThemeTextColor") private var themeTextHex: String = "#EDEDED"
|
|
@AppStorage("SettingsThemeBackgroundColor") private var themeBackgroundHex: String = "#0E1116"
|
|
@AppStorage("SettingsThemeCursorColor") private var themeCursorHex: String = "#4EA4FF"
|
|
@AppStorage("SettingsThemeSelectionColor") private var themeSelectionHex: String = "#2A3340"
|
|
@AppStorage("SettingsThemeKeywordColor") private var themeKeywordHex: String = "#F5D90A"
|
|
@AppStorage("SettingsThemeStringColor") private var themeStringHex: String = "#4EA4FF"
|
|
@AppStorage("SettingsThemeNumberColor") private var themeNumberHex: String = "#FFB86C"
|
|
@AppStorage("SettingsThemeCommentColor") private var themeCommentHex: String = "#7F8C98"
|
|
@AppStorage("SettingsThemeTypeColor") private var themeTypeHex: String = "#32D269"
|
|
@AppStorage("SettingsThemeBuiltinColor") private var themeBuiltinHex: String = "#EC7887"
|
|
@AppStorage("SettingsThemeBoldKeywords") private var themeBoldKeywords: Bool = false
|
|
@AppStorage("SettingsThemeItalicComments") private var themeItalicComments: Bool = false
|
|
@AppStorage("SettingsThemeUnderlineLinks") private var themeUnderlineLinks: Bool = false
|
|
@AppStorage("SettingsThemeBoldMarkdownHeadings") private var themeBoldMarkdownHeadings: Bool = false
|
|
@AppStorage("MarkdownPreviewBackgroundStyle") private var markdownPreviewBackgroundStyleRaw: String = "automatic"
|
|
|
|
private var inputFieldBackground: Color {
|
|
#if os(macOS)
|
|
Color(nsColor: .windowBackgroundColor)
|
|
#else
|
|
Color(.secondarySystemBackground)
|
|
#endif
|
|
}
|
|
|
|
private let themes: [String] = editorThemeNames
|
|
|
|
private let templateLanguages: [String] = [
|
|
"swift", "python", "javascript", "typescript", "php", "java", "kotlin", "go", "ruby", "rust",
|
|
"cobol", "dotenv", "proto", "graphql", "rst", "nginx", "sql", "html", "expressionengine", "css", "c", "cpp",
|
|
"csharp", "objective-c", "json", "xml", "yaml", "toml", "csv", "ini", "vim", "log", "ipynb",
|
|
"markdown", "tex", "bash", "zsh", "powershell", "standard", "plain"
|
|
]
|
|
|
|
private var isCompactSettingsLayout: Bool {
|
|
#if os(iOS)
|
|
horizontalSizeClass == .compact
|
|
#else
|
|
false
|
|
#endif
|
|
}
|
|
|
|
private var useTwoColumnSettingsLayout: Bool {
|
|
#if os(iOS)
|
|
horizontalSizeClass == .regular
|
|
#else
|
|
false
|
|
#endif
|
|
}
|
|
|
|
private var isIPadRegularSettingsLayout: Bool {
|
|
#if os(iOS)
|
|
useTwoColumnSettingsLayout
|
|
#else
|
|
false
|
|
#endif
|
|
}
|
|
|
|
private var isIPadDevice: Bool {
|
|
#if os(iOS)
|
|
UIDevice.current.userInterfaceIdiom == .pad
|
|
#else
|
|
false
|
|
#endif
|
|
}
|
|
|
|
private var vimModeBinding: Binding<Bool> {
|
|
Binding(
|
|
get: { vimModeEnabled && vimInterceptionEnabled },
|
|
set: { enabled in
|
|
vimModeEnabled = enabled
|
|
vimInterceptionEnabled = enabled
|
|
NotificationCenter.default.post(
|
|
name: .vimModeStateDidChange,
|
|
object: nil,
|
|
userInfo: ["insertMode": !enabled]
|
|
)
|
|
}
|
|
)
|
|
}
|
|
|
|
private var standardLabelWidth: CGFloat {
|
|
useTwoColumnSettingsLayout ? 180 : 140
|
|
}
|
|
|
|
private var startupLabelWidth: CGFloat {
|
|
useTwoColumnSettingsLayout ? 220 : 180
|
|
}
|
|
|
|
private enum UI {
|
|
static let space6: CGFloat = 6
|
|
static let space8: CGFloat = 8
|
|
static let space10: CGFloat = 10
|
|
static let space12: CGFloat = 12
|
|
static let space16: CGFloat = 16
|
|
static let space20: CGFloat = 20
|
|
static let fieldCorner: CGFloat = 6
|
|
static let groupPadding: CGFloat = 14
|
|
static let sidePaddingCompact: CGFloat = 12
|
|
static let sidePaddingRegular: CGFloat = 20
|
|
static let sidePaddingIPadRegular: CGFloat = 40
|
|
static let topPadding: CGFloat = 14
|
|
static let bottomPadding: CGFloat = 16
|
|
static let cardCorner: CGFloat = 12
|
|
static let cardStrokeOpacity: Double = 0.15
|
|
static let mobileHeaderTopPadding: CGFloat = 10
|
|
static let cardAccentHeight: CGFloat = 4
|
|
#if os(macOS)
|
|
static let macHeaderIconSize: CGFloat = 34
|
|
static let macHeaderBadgeCorner: CGFloat = 10
|
|
#endif
|
|
}
|
|
|
|
private enum Typography {
|
|
static let sectionHeadline = Font.headline
|
|
static let sectionSubheadline = Font.subheadline
|
|
static let footnote = Font.footnote
|
|
static let monoBody = Font.system(size: 13, weight: .regular, design: .monospaced)
|
|
static let sectionTitle = Font.title3.weight(.semibold)
|
|
}
|
|
|
|
#if os(iOS)
|
|
private enum MobileCardEmphasis {
|
|
case primary
|
|
case secondary
|
|
}
|
|
#endif
|
|
|
|
#if os(macOS)
|
|
private enum MacTranslucencyModeOption: String, CaseIterable, Identifiable {
|
|
case subtle
|
|
case balanced
|
|
case vibrant
|
|
|
|
var id: String { rawValue }
|
|
|
|
var title: String {
|
|
switch self {
|
|
case .subtle: return "Subtle"
|
|
case .balanced: return "Balanced"
|
|
case .vibrant: return "Vibrant"
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
init(
|
|
supportsOpenInTabs: Bool = true,
|
|
supportsTranslucency: Bool = true
|
|
) {
|
|
self.supportsOpenInTabs = supportsOpenInTabs
|
|
self.supportsTranslucency = supportsTranslucency
|
|
}
|
|
|
|
private var settingsTabs: some View {
|
|
TabView(selection: $settingsActiveTab) {
|
|
SettingsTabPage(
|
|
title: "General",
|
|
systemImage: "gearshape",
|
|
tag: "general",
|
|
content: AnyView(generalTab)
|
|
)
|
|
SettingsTabPage(
|
|
title: "Editor",
|
|
systemImage: "slider.horizontal.3",
|
|
tag: "editor",
|
|
content: AnyView(editorTab)
|
|
)
|
|
SettingsTabPage(
|
|
title: "Templates",
|
|
systemImage: "doc.badge.plus",
|
|
tag: "templates",
|
|
content: AnyView(templateTab)
|
|
)
|
|
SettingsTabPage(
|
|
title: "Themes",
|
|
systemImage: "paintpalette",
|
|
tag: "themes",
|
|
content: AnyView(themeTab)
|
|
)
|
|
#if os(iOS)
|
|
SettingsTabPage(
|
|
title: "More",
|
|
systemImage: "ellipsis.circle",
|
|
tag: "more",
|
|
content: AnyView(moreTab)
|
|
)
|
|
#else
|
|
SettingsTabPage(
|
|
title: "Support",
|
|
systemImage: "heart",
|
|
tag: "support",
|
|
content: AnyView(supportTab)
|
|
)
|
|
SettingsTabPage(
|
|
title: "AI",
|
|
systemImage: "brain.head.profile",
|
|
tag: "ai",
|
|
content: AnyView(aiTab)
|
|
)
|
|
SettingsTabPage(
|
|
title: "Remote",
|
|
systemImage: "rectangle.connected.to.line.below",
|
|
tag: "remote",
|
|
content: AnyView(remoteTab)
|
|
)
|
|
#endif
|
|
#if os(macOS)
|
|
if ReleaseRuntimePolicy.isUpdaterEnabledForCurrentDistribution {
|
|
SettingsTabPage(
|
|
title: "Updates",
|
|
systemImage: "arrow.triangle.2.circlepath.circle",
|
|
tag: "updates",
|
|
content: AnyView(updatesTab)
|
|
)
|
|
}
|
|
#endif
|
|
}
|
|
#if os(iOS)
|
|
.animation(.easeOut(duration: 0.22), value: settingsActiveTab)
|
|
#endif
|
|
}
|
|
|
|
private func localized(_ key: String) -> String {
|
|
NSLocalizedString(key, comment: "")
|
|
}
|
|
|
|
private func localized(_ key: String, _ value: CVarArg) -> String {
|
|
String(format: NSLocalizedString(key, comment: ""), value)
|
|
}
|
|
|
|
private func localized(_ key: String, _ values: CVarArg...) -> String {
|
|
String(format: NSLocalizedString(key, comment: ""), arguments: values)
|
|
}
|
|
|
|
private var shouldShowSupportPurchaseControls: Bool {
|
|
#if os(iOS)
|
|
true
|
|
#else
|
|
supportPurchaseManager.canUseInAppPurchases
|
|
#endif
|
|
}
|
|
|
|
var body: some View {
|
|
settingsTabs
|
|
#if os(macOS)
|
|
.background(settingsWindowBackground)
|
|
.frame(
|
|
minWidth: macSettingsWindowSize.min.width,
|
|
idealWidth: macSettingsWindowSize.ideal.width,
|
|
minHeight: macSettingsWindowSize.min.height,
|
|
idealHeight: macSettingsWindowSize.ideal.height
|
|
)
|
|
.background(
|
|
SettingsWindowConfigurator(
|
|
minSize: macSettingsWindowSize.min,
|
|
idealSize: macSettingsWindowSize.ideal,
|
|
translucentEnabled: supportsTranslucency && translucentWindow,
|
|
translucencyModeRaw: macTranslucencyModeRaw,
|
|
appearanceRaw: appearance,
|
|
effectiveColorScheme: effectiveSettingsColorScheme
|
|
)
|
|
)
|
|
#endif
|
|
.preferredColorScheme(preferredColorSchemeOverride)
|
|
#if os(iOS)
|
|
.navigationTitle("")
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
#endif
|
|
.onAppear {
|
|
settingsActiveTab = Self.defaultSettingsTab
|
|
if moreSectionTab.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
|
|
moreSectionTab = "support"
|
|
}
|
|
selectedTheme = canonicalThemeName(selectedTheme)
|
|
migrateLegacyPinkSettingsIfNeeded()
|
|
loadAvailableEditorFontsIfNeeded()
|
|
if settingsActiveTab == "ai" || (settingsActiveTab == "more" && moreSectionTab == "ai") {
|
|
loadAPITokensIfNeeded()
|
|
}
|
|
if settingsActiveTab == "support" || (settingsActiveTab == "more" && moreSectionTab == "support") {
|
|
refreshSupportStoreStateIfNeeded()
|
|
}
|
|
appUpdateManager.setAutoCheckEnabled(autoCheckForUpdates)
|
|
appUpdateManager.setUpdateInterval(selectedUpdateInterval)
|
|
appUpdateManager.setAutoDownloadEnabled(autoDownloadUpdates)
|
|
#if os(macOS)
|
|
applyAppearanceImmediately()
|
|
#endif
|
|
}
|
|
.onChange(of: appearance) { _, _ in
|
|
#if os(macOS)
|
|
applyAppearanceImmediately()
|
|
#endif
|
|
}
|
|
.onChange(of: showScopeGuides) { _, enabled in
|
|
if enabled && lineWrapEnabled {
|
|
lineWrapEnabled = false
|
|
}
|
|
}
|
|
.onChange(of: highlightScopeBackground) { _, enabled in
|
|
if enabled && lineWrapEnabled {
|
|
lineWrapEnabled = false
|
|
}
|
|
}
|
|
.onChange(of: lineWrapEnabled) { _, enabled in
|
|
if enabled {
|
|
showScopeGuides = false
|
|
highlightScopeBackground = false
|
|
}
|
|
}
|
|
.onChange(of: autoCheckForUpdates) { _, enabled in
|
|
appUpdateManager.setAutoCheckEnabled(enabled)
|
|
}
|
|
.onChange(of: updateCheckIntervalRaw) { _, _ in
|
|
appUpdateManager.setUpdateInterval(selectedUpdateInterval)
|
|
}
|
|
.onChange(of: autoDownloadUpdates) { _, enabled in
|
|
appUpdateManager.setAutoDownloadEnabled(enabled)
|
|
}
|
|
.onChange(of: settingsActiveTab) { _, newValue in
|
|
#if os(iOS)
|
|
if newValue == "more" {
|
|
moreSectionTab = "support"
|
|
}
|
|
#else
|
|
if newValue == "ai" {
|
|
loadAPITokensIfNeeded()
|
|
} else if newValue == "support" {
|
|
refreshSupportStoreStateIfNeeded()
|
|
}
|
|
#endif
|
|
}
|
|
.onChange(of: moreSectionTab) { _, newValue in
|
|
if newValue == "ai" && settingsActiveTab == "more" {
|
|
loadAPITokensIfNeeded()
|
|
} else if newValue == "support" && settingsActiveTab == "more" {
|
|
refreshSupportStoreStateIfNeeded()
|
|
}
|
|
}
|
|
.onChange(of: selectedTheme) { _, newValue in
|
|
let canonical = canonicalThemeName(newValue)
|
|
if canonical != newValue {
|
|
selectedTheme = canonical
|
|
}
|
|
}
|
|
.confirmationDialog("Support Neon Vision Editor", isPresented: $showSupportPurchaseDialog, titleVisibility: .visible) {
|
|
Button(localized("Send Tip %@", supportPurchaseManager.supportPriceLabel)) {
|
|
Task { await supportPurchaseManager.purchaseSupport() }
|
|
}
|
|
Button("Cancel", role: .cancel) {}
|
|
} message: {
|
|
Text("Optional consumable support purchase. Can be purchased multiple times. No features are locked behind this purchase.")
|
|
}
|
|
.alert(
|
|
"App Store",
|
|
isPresented: Binding(
|
|
get: { supportPurchaseManager.statusMessage != nil },
|
|
set: { if !$0 { supportPurchaseManager.statusMessage = nil } }
|
|
)
|
|
) {
|
|
Button("OK", role: .cancel) {}
|
|
} message: {
|
|
Text(supportPurchaseManager.statusMessage ?? "")
|
|
}
|
|
.sheet(isPresented: $showDataDisclosureDialog) {
|
|
dataDisclosureDialog
|
|
}
|
|
.sheet(isPresented: $showRemoteConnectSheet) {
|
|
remoteConnectSheet
|
|
}
|
|
.onDisappear {
|
|
supportRefreshTask?.cancel()
|
|
supportRefreshTask = nil
|
|
}
|
|
}
|
|
|
|
private func refreshSupportStoreStateIfNeeded() {
|
|
guard supportRefreshTask == nil else { return }
|
|
supportRefreshTask = Task {
|
|
await supportPurchaseManager.refreshStoreState()
|
|
await MainActor.run {
|
|
supportRefreshTask = nil
|
|
}
|
|
}
|
|
}
|
|
|
|
private func loadAPITokensIfNeeded() {
|
|
if grokAPIToken.isEmpty { grokAPIToken = SecureTokenStore.token(for: .grok) }
|
|
if openAIAPIToken.isEmpty { openAIAPIToken = SecureTokenStore.token(for: .openAI) }
|
|
if geminiAPIToken.isEmpty { geminiAPIToken = SecureTokenStore.token(for: .gemini) }
|
|
if anthropicAPIToken.isEmpty { anthropicAPIToken = SecureTokenStore.token(for: .anthropic) }
|
|
}
|
|
|
|
private var preferredColorSchemeOverride: ColorScheme? {
|
|
ReleaseRuntimePolicy.preferredColorScheme(for: appearance)
|
|
}
|
|
|
|
#if os(macOS)
|
|
private func applyAppearanceImmediately() {
|
|
let target: NSAppearance?
|
|
switch appearance {
|
|
case "light":
|
|
target = NSAppearance(named: .aqua)
|
|
case "dark":
|
|
target = NSAppearance(named: .darkAqua)
|
|
default:
|
|
target = nil
|
|
}
|
|
NSApp.appearance = target
|
|
for window in NSApp.windows {
|
|
window.appearance = target
|
|
}
|
|
}
|
|
#endif
|
|
|
|
private var generalTab: some View {
|
|
settingsContainer {
|
|
settingsSectionHeader(
|
|
icon: "gearshape",
|
|
title: "General",
|
|
subtitle: "Window behavior, startup defaults, and confirmation preferences."
|
|
)
|
|
|
|
#if os(iOS)
|
|
if useTwoColumnSettingsLayout {
|
|
iPadQuickSummaryCard
|
|
}
|
|
#endif
|
|
|
|
if useTwoColumnSettingsLayout {
|
|
LazyVGrid(columns: [GridItem(.flexible(), spacing: UI.space16), GridItem(.flexible(), spacing: UI.space16)], spacing: UI.space16) {
|
|
windowSection
|
|
editorFontSection
|
|
startupSection
|
|
confirmationsSection
|
|
}
|
|
} else {
|
|
windowSection
|
|
editorFontSection
|
|
startupSection
|
|
confirmationsSection
|
|
}
|
|
}
|
|
}
|
|
|
|
private var windowSection: some View {
|
|
#if os(iOS)
|
|
settingsCardSection(
|
|
title: "Window",
|
|
icon: "macwindow.badge.plus",
|
|
showsAccentStripe: false,
|
|
tip: "Choose how windows open and how appearance is applied."
|
|
) {
|
|
if supportsOpenInTabs {
|
|
iOSLabeledRow("Open in Tabs") {
|
|
Picker("", selection: $openInTabs) {
|
|
Text("Follow System").tag("system")
|
|
Text("Always").tag("always")
|
|
Text("Never").tag("never")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
}
|
|
}
|
|
|
|
iOSLabeledRow("Appearance") {
|
|
Picker("", selection: $appearance) {
|
|
Text("System").tag("system")
|
|
Text("Light").tag("light")
|
|
Text("Dark").tag("dark")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
}
|
|
|
|
if supportsTranslucency {
|
|
iOSToggleRow("Translucent Window", isOn: $translucentWindow)
|
|
}
|
|
}
|
|
#else
|
|
GroupBox("Window") {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
if supportsOpenInTabs {
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text("Open in Tabs")
|
|
.frame(width: isCompactSettingsLayout ? nil : standardLabelWidth, alignment: .leading)
|
|
Picker("", selection: $openInTabs) {
|
|
Text("Follow System").tag("system")
|
|
Text("Always").tag("always")
|
|
Text("Never").tag("never")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
}
|
|
}
|
|
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text("Appearance")
|
|
.frame(width: isCompactSettingsLayout ? nil : standardLabelWidth, alignment: .leading)
|
|
Picker("", selection: $appearance) {
|
|
Text("System").tag("system")
|
|
Text("Light").tag("light")
|
|
Text("Dark").tag("dark")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
}
|
|
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text("Toolbar Symbols")
|
|
.frame(width: isCompactSettingsLayout ? nil : standardLabelWidth, alignment: .leading)
|
|
Picker("", selection: $toolbarSymbolsColorMacRaw) {
|
|
Text("Blue").tag("blue")
|
|
Text("Dark Gray").tag("darkGray")
|
|
Text("Black").tag("black")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
}
|
|
|
|
if supportsTranslucency {
|
|
Toggle("Translucent Window", isOn: $translucentWindow)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text("Translucency Mode")
|
|
.frame(width: isCompactSettingsLayout ? nil : standardLabelWidth, alignment: .leading)
|
|
Picker("", selection: $macTranslucencyModeRaw) {
|
|
ForEach(MacTranslucencyModeOption.allCases) { option in
|
|
Text(option.title).tag(option.rawValue)
|
|
}
|
|
}
|
|
.pickerStyle(.segmented)
|
|
.disabled(!translucentWindow)
|
|
}
|
|
}
|
|
}
|
|
.padding(UI.groupPadding)
|
|
}
|
|
#endif
|
|
}
|
|
|
|
private var editorFontSection: some View {
|
|
#if os(iOS)
|
|
settingsCardSection(
|
|
title: "Editor Font",
|
|
icon: "textformat",
|
|
emphasis: .secondary,
|
|
showsAccentStripe: false
|
|
) {
|
|
iOSToggleRow("Use System Font", isOn: $useSystemFont)
|
|
|
|
iOSLabeledRow("Font") {
|
|
Picker("", selection: selectedFontBinding) {
|
|
Text("System").tag(systemFontSentinel)
|
|
ForEach(availableEditorFonts, id: \.self) { fontName in
|
|
Text(fontName).tag(fontName)
|
|
}
|
|
}
|
|
.pickerStyle(.menu)
|
|
.padding(.vertical, UI.space6)
|
|
.padding(.horizontal, UI.space8)
|
|
.background(inputFieldBackground)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: UI.fieldCorner)
|
|
.stroke(Color.secondary.opacity(0.35), lineWidth: 1)
|
|
)
|
|
.cornerRadius(UI.fieldCorner)
|
|
}
|
|
|
|
iOSLabeledRow("Font Size") {
|
|
HStack(spacing: UI.space12) {
|
|
Text(localized("%lld pt", Int64(Int(editorFontSize))))
|
|
.font(.body.monospacedDigit())
|
|
.frame(minWidth: 64, alignment: .trailing)
|
|
Stepper("", value: $editorFontSize, in: 10...28, step: 1)
|
|
.labelsHidden()
|
|
}
|
|
}
|
|
|
|
VStack(alignment: .leading, spacing: UI.space8) {
|
|
HStack(alignment: .firstTextBaseline, spacing: UI.space12) {
|
|
Text("Line Height")
|
|
.frame(width: iOSSettingsLabelWidth, alignment: .leading)
|
|
Spacer(minLength: 0)
|
|
Text(String(format: "%.2fx", lineHeight))
|
|
.font(.body.monospacedDigit())
|
|
.frame(width: 64, alignment: .trailing)
|
|
}
|
|
Slider(value: $lineHeight, in: 1.0...1.8, step: 0.05)
|
|
}
|
|
}
|
|
#else
|
|
GroupBox("Editor Font") {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
Toggle("Use System Font", isOn: $useSystemFont)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text("Font")
|
|
.frame(width: isCompactSettingsLayout ? nil : standardLabelWidth, alignment: .leading)
|
|
VStack(alignment: .leading, spacing: UI.space8) {
|
|
HStack(spacing: UI.space8) {
|
|
Text(useSystemFont ? "System" : (editorFontName.isEmpty ? "System" : editorFontName))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
Button(showFontList ? "Hide Font List" : "Show Font List") {
|
|
showFontList.toggle()
|
|
}
|
|
.buttonStyle(.borderless)
|
|
}
|
|
if showFontList {
|
|
Picker("", selection: selectedFontBinding) {
|
|
Text("System").tag(systemFontSentinel)
|
|
ForEach(availableEditorFonts, id: \.self) { fontName in
|
|
Text(fontName).tag(fontName)
|
|
}
|
|
}
|
|
.pickerStyle(.menu)
|
|
.padding(.vertical, UI.space6)
|
|
.padding(.horizontal, UI.space8)
|
|
.background(inputFieldBackground)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: UI.fieldCorner)
|
|
.stroke(Color.secondary.opacity(0.35), lineWidth: 1)
|
|
)
|
|
.cornerRadius(UI.fieldCorner)
|
|
}
|
|
}
|
|
.frame(maxWidth: isCompactSettingsLayout ? .infinity : 240, alignment: .leading)
|
|
#if os(macOS)
|
|
Button("Choose…") {
|
|
useSystemFont = false
|
|
showFontList = true
|
|
}
|
|
.disabled(useSystemFont)
|
|
#endif
|
|
}
|
|
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text("Font Size")
|
|
.frame(width: isCompactSettingsLayout ? nil : standardLabelWidth, alignment: .leading)
|
|
Stepper(value: $editorFontSize, in: 10...28, step: 1) {
|
|
Text(localized("%lld pt", Int64(Int(editorFontSize))))
|
|
}
|
|
.frame(maxWidth: isCompactSettingsLayout ? .infinity : 220, alignment: .leading)
|
|
}
|
|
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text("Line Height")
|
|
.frame(width: isCompactSettingsLayout ? nil : standardLabelWidth, alignment: .leading)
|
|
Slider(value: $lineHeight, in: 1.0...1.8, step: 0.05)
|
|
.frame(maxWidth: isCompactSettingsLayout ? .infinity : 240)
|
|
Text(String(format: "%.2fx", lineHeight))
|
|
.frame(width: 54, alignment: .trailing)
|
|
}
|
|
}
|
|
.padding(UI.groupPadding)
|
|
}
|
|
#endif
|
|
}
|
|
|
|
private var startupSection: some View {
|
|
Group {
|
|
#if os(iOS)
|
|
settingsCardSection(
|
|
title: "Startup",
|
|
icon: "bolt.horizontal",
|
|
emphasis: .secondary,
|
|
showsAccentStripe: false
|
|
) {
|
|
startupSectionContent
|
|
}
|
|
#else
|
|
GroupBox("Startup") {
|
|
startupSectionContent
|
|
.padding(UI.groupPadding)
|
|
}
|
|
#endif
|
|
}
|
|
.onChange(of: openWithBlankDocument) { _, isEnabled in
|
|
if isEnabled {
|
|
reopenLastSession = false
|
|
}
|
|
}
|
|
.onChange(of: reopenLastSession) { _, isEnabled in
|
|
if isEnabled {
|
|
openWithBlankDocument = false
|
|
}
|
|
}
|
|
}
|
|
|
|
private var startupSectionContent: some View {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
Toggle("Open with Blank Document", isOn: $openWithBlankDocument)
|
|
.disabled(reopenLastSession)
|
|
Toggle("Reopen Last Session", isOn: $reopenLastSession)
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text("Default New File Language")
|
|
.frame(width: isCompactSettingsLayout ? nil : startupLabelWidth, alignment: .leading)
|
|
Picker("", selection: $defaultNewFileLanguage) {
|
|
ForEach(templateLanguages, id: \.self) { lang in
|
|
Text(languageLabel(for: lang)).tag(lang)
|
|
}
|
|
}
|
|
.pickerStyle(.menu)
|
|
}
|
|
Text("Tip: Enable only one startup mode to keep app launch behavior predictable.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
|
|
private var confirmationsSection: some View {
|
|
Group {
|
|
#if os(iOS)
|
|
settingsCardSection(
|
|
title: "Confirmations",
|
|
icon: "checkmark.shield",
|
|
emphasis: .secondary,
|
|
showsAccentStripe: false
|
|
) {
|
|
confirmationsSectionContent
|
|
}
|
|
#else
|
|
GroupBox("Confirmations") {
|
|
confirmationsSectionContent
|
|
.padding(UI.groupPadding)
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
private var confirmationsSectionContent: some View {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
Toggle("Confirm Before Closing Dirty Tab", isOn: $confirmCloseDirtyTab)
|
|
Toggle("Confirm Before Clearing Editor", isOn: $confirmClearEditor)
|
|
}
|
|
}
|
|
|
|
#if os(iOS)
|
|
private var iOSSettingsLabelWidth: CGFloat {
|
|
useTwoColumnSettingsLayout ? 176 : 138
|
|
}
|
|
|
|
private func iOSLabeledRow<Content: View>(_ label: LocalizedStringKey, @ViewBuilder content: () -> Content) -> some View {
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text(label)
|
|
.frame(width: iOSSettingsLabelWidth, alignment: .leading)
|
|
content()
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
}
|
|
|
|
private func iOSToggleRow(_ label: LocalizedStringKey, isOn: Binding<Bool>) -> some View {
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text(label)
|
|
.frame(width: iOSSettingsLabelWidth, alignment: .leading)
|
|
Spacer(minLength: 0)
|
|
Toggle("", isOn: isOn)
|
|
.labelsHidden()
|
|
}
|
|
}
|
|
|
|
private var selectedAIModelDisplayName: String {
|
|
(AIModel(rawValue: selectedAIModelRaw) ?? .appleIntelligence).displayName
|
|
}
|
|
|
|
private var editorFontSummaryLabel: String {
|
|
let fontLabel = useSystemFont ? "System" : (editorFontName.isEmpty ? "System" : editorFontName)
|
|
return "\(fontLabel) • \(Int(editorFontSize)) pt • \(String(format: "%.2fx", lineHeight))"
|
|
}
|
|
|
|
private var mobileSettingsAccentColor: Color {
|
|
switch settingsActiveTab {
|
|
case "general":
|
|
return .teal
|
|
case "editor":
|
|
return .blue
|
|
case "templates":
|
|
return .mint
|
|
case "themes":
|
|
return .orange
|
|
case "ai":
|
|
return .indigo
|
|
case "remote":
|
|
return .cyan
|
|
case "support":
|
|
return .pink
|
|
case "more":
|
|
switch moreSectionTab {
|
|
case "ai":
|
|
return .indigo
|
|
case "remote":
|
|
return .cyan
|
|
default:
|
|
return .pink
|
|
}
|
|
default:
|
|
return .accentColor
|
|
}
|
|
}
|
|
|
|
private var iPadQuickSummaryCard: some View {
|
|
settingsCardSection(
|
|
title: "Current Setup",
|
|
icon: "rectangle.stack.badge.person.crop",
|
|
showsAccentStripe: false,
|
|
tip: "Snapshot updates immediately as settings change."
|
|
) {
|
|
VStack(alignment: .leading, spacing: UI.space8) {
|
|
HStack(spacing: UI.space8) {
|
|
Image(systemName: "paintpalette")
|
|
.foregroundStyle(.secondary)
|
|
.accessibilityHidden(true)
|
|
Text("Theme")
|
|
.foregroundStyle(.secondary)
|
|
Spacer(minLength: 8)
|
|
Text(selectedTheme)
|
|
.font(.body.weight(.semibold))
|
|
}
|
|
HStack(spacing: UI.space8) {
|
|
Image(systemName: "textformat")
|
|
.foregroundStyle(.secondary)
|
|
.accessibilityHidden(true)
|
|
Text("Editor Font")
|
|
.foregroundStyle(.secondary)
|
|
Spacer(minLength: 8)
|
|
Text(editorFontSummaryLabel)
|
|
.font(.body.weight(.semibold))
|
|
.multilineTextAlignment(.trailing)
|
|
}
|
|
HStack(spacing: UI.space8) {
|
|
Image(systemName: "brain.head.profile")
|
|
.foregroundStyle(.secondary)
|
|
.accessibilityHidden(true)
|
|
Text("AI Model")
|
|
.foregroundStyle(.secondary)
|
|
Spacer(minLength: 8)
|
|
Text(selectedAIModelDisplayName)
|
|
.font(.body.weight(.semibold))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func settingsCardSection<Content: View>(
|
|
title: LocalizedStringKey,
|
|
icon: String? = nil,
|
|
emphasis: MobileCardEmphasis = .primary,
|
|
showsAccentStripe: Bool = false,
|
|
tip: LocalizedStringKey? = nil,
|
|
@ViewBuilder content: () -> Content
|
|
) -> some View {
|
|
let strokeOpacity = emphasis == .primary ? 0.24 : 0.16
|
|
let shadowOpacity = emphasis == .primary ? 0.10 : 0.04
|
|
return VStack(alignment: .leading, spacing: UI.space12) {
|
|
HStack(alignment: .firstTextBaseline, spacing: UI.space8) {
|
|
if let icon {
|
|
Image(systemName: icon)
|
|
.font(.subheadline.weight(.semibold))
|
|
.foregroundStyle(mobileSettingsAccentColor)
|
|
.accessibilityHidden(true)
|
|
}
|
|
Text(title)
|
|
.font(Typography.sectionHeadline)
|
|
}
|
|
content()
|
|
if let tip {
|
|
Text(tip)
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(UI.groupPadding)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: UI.cardCorner, style: .continuous)
|
|
.fill(emphasis == .primary ? .regularMaterial : .thinMaterial)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: UI.cardCorner, style: .continuous)
|
|
.stroke(Color.secondary.opacity(strokeOpacity), lineWidth: 1)
|
|
)
|
|
.shadow(color: Color.black.opacity(shadowOpacity), radius: emphasis == .primary ? 10 : 6, x: 0, y: emphasis == .primary ? 4 : 2)
|
|
)
|
|
.overlay(alignment: .topLeading) {
|
|
if showsAccentStripe {
|
|
Capsule(style: .continuous)
|
|
.fill(mobileSettingsAccentColor.opacity(emphasis == .primary ? 0.95 : 0.70))
|
|
.frame(height: UI.cardAccentHeight)
|
|
.padding(.horizontal, UI.space12)
|
|
.padding(.top, UI.space8)
|
|
}
|
|
}
|
|
.clipShape(RoundedRectangle(cornerRadius: UI.cardCorner, style: .continuous))
|
|
.transition(.move(edge: .bottom).combined(with: .opacity))
|
|
}
|
|
#endif
|
|
|
|
private let systemFontSentinel = "__system__"
|
|
@State private var selectedFontValue: String = "__system__"
|
|
@State private var showFontList: Bool = {
|
|
#if os(macOS)
|
|
false
|
|
#else
|
|
true
|
|
#endif
|
|
}()
|
|
|
|
private var selectedFontBinding: Binding<String> {
|
|
Binding(
|
|
get: {
|
|
if useSystemFont { return systemFontSentinel }
|
|
if editorFontName.isEmpty { return systemFontSentinel }
|
|
if availableEditorFonts.isEmpty { return systemFontSentinel }
|
|
if !availableEditorFonts.contains(editorFontName) { return systemFontSentinel }
|
|
return editorFontName
|
|
},
|
|
set: { newValue in
|
|
selectedFontValue = newValue
|
|
if newValue == systemFontSentinel {
|
|
useSystemFont = true
|
|
} else {
|
|
useSystemFont = false
|
|
editorFontName = newValue
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
private func loadAvailableEditorFontsIfNeeded() {
|
|
if !availableEditorFonts.isEmpty {
|
|
syncSelectedFontValue()
|
|
return
|
|
}
|
|
if !Self.cachedEditorFonts.isEmpty {
|
|
availableEditorFonts = Self.cachedEditorFonts
|
|
syncSelectedFontValue()
|
|
return
|
|
}
|
|
guard !isDiscoveringFonts else { return }
|
|
isDiscoveringFonts = true
|
|
let selectedEditorFont = editorFontName
|
|
// Defer and compute font list off the main thread to avoid settings-open hitches.
|
|
DispatchQueue.global(qos: .userInitiated).async {
|
|
let rawNames = CTFontManagerCopyAvailablePostScriptNames() as NSArray
|
|
var names = Array(Set(rawNames.compactMap { $0 as? String })).sorted()
|
|
if !selectedEditorFont.isEmpty && !names.contains(selectedEditorFont) {
|
|
names.insert(selectedEditorFont, at: 0)
|
|
}
|
|
DispatchQueue.main.async {
|
|
Self.cachedEditorFonts = names
|
|
availableEditorFonts = names
|
|
syncSelectedFontValue()
|
|
isDiscoveringFonts = false
|
|
}
|
|
}
|
|
}
|
|
|
|
private func syncSelectedFontValue() {
|
|
if useSystemFont || editorFontName.isEmpty {
|
|
selectedFontValue = systemFontSentinel
|
|
return
|
|
}
|
|
selectedFontValue = availableEditorFonts.contains(editorFontName) ? editorFontName : systemFontSentinel
|
|
}
|
|
|
|
private var selectedUpdateInterval: AppUpdateCheckInterval {
|
|
AppUpdateCheckInterval(rawValue: updateCheckIntervalRaw) ?? .daily
|
|
}
|
|
|
|
private var editorTab: some View {
|
|
settingsContainer(maxWidth: isIPadRegularSettingsLayout ? 1120 : 760) {
|
|
settingsSectionHeader(
|
|
icon: "slider.horizontal.3",
|
|
title: "Editor",
|
|
subtitle: "Display, indentation, editing behavior, and completion sources."
|
|
)
|
|
|
|
if isIPadRegularSettingsLayout {
|
|
LazyVGrid(
|
|
columns: [GridItem(.flexible(), spacing: UI.space16), GridItem(.flexible(), spacing: UI.space16)],
|
|
spacing: UI.space16
|
|
) {
|
|
editorBasicsSettings
|
|
editorBehaviorSettings
|
|
}
|
|
} else {
|
|
editorSectionPicker
|
|
if editorSectionTab == "basics" {
|
|
editorBasicsSettings
|
|
} else {
|
|
editorBehaviorSettings
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private var editorSectionPicker: some View {
|
|
VStack(alignment: .leading, spacing: UI.space8) {
|
|
Text("Section")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
Picker("Section", selection: $editorSectionTab) {
|
|
Text("Basics").tag("basics")
|
|
Text("Behavior").tag("behavior")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
|
|
private var editorBasicsSettings: some View {
|
|
#if os(iOS)
|
|
VStack(spacing: UI.space16) {
|
|
settingsCardSection(
|
|
title: "Display",
|
|
icon: "eye",
|
|
tip: "Scope visuals are best used with line wrap disabled."
|
|
) {
|
|
Toggle("Show Line Numbers", isOn: $showLineNumbers)
|
|
Toggle("Highlight Current Line", isOn: $highlightCurrentLine)
|
|
Toggle("Highlight Matching Brackets", isOn: $highlightMatchingBrackets)
|
|
Toggle("Show Scope Guides (Non-Swift)", isOn: $showScopeGuides)
|
|
Toggle("Highlight Scoped Region", isOn: $highlightScopeBackground)
|
|
Toggle("Line Wrap", isOn: $lineWrapEnabled)
|
|
Text("When Line Wrap is enabled, scope guides/scoped region are turned off to avoid layout conflicts.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
Text("Scope guides are intended for non-Swift languages. Swift favors matching-token highlight.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
Text("Invisible character markers are disabled to avoid whitespace glyph artifacts.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
|
|
settingsCardSection(
|
|
title: "Indentation",
|
|
icon: "increase.indent",
|
|
emphasis: .secondary
|
|
) {
|
|
Picker("Indent Style", selection: $indentStyle) {
|
|
Text("Spaces").tag("spaces")
|
|
Text("Tabs").tag("tabs")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
|
|
Stepper(value: $indentWidth, in: 2...8, step: 1) {
|
|
Text(localized("Indent Width: %lld", Int64(indentWidth)))
|
|
}
|
|
}
|
|
|
|
settingsCardSection(
|
|
title: "Layout",
|
|
icon: "sidebar.left",
|
|
emphasis: .secondary
|
|
) {
|
|
Picker("Project Navigator Position", selection: $projectNavigatorPlacementRaw) {
|
|
Text("Left").tag(ContentView.ProjectNavigatorPlacement.leading.rawValue)
|
|
Text("Right").tag(ContentView.ProjectNavigatorPlacement.trailing.rawValue)
|
|
}
|
|
.pickerStyle(.segmented)
|
|
}
|
|
}
|
|
#else
|
|
GroupBox("Editor Basics") {
|
|
VStack(alignment: .leading, spacing: 16) {
|
|
VStack(alignment: .leading, spacing: UI.space10) {
|
|
Text("Display")
|
|
.font(Typography.sectionHeadline)
|
|
Toggle("Show Line Numbers", isOn: $showLineNumbers)
|
|
Toggle("Highlight Current Line", isOn: $highlightCurrentLine)
|
|
Toggle("Highlight Matching Brackets", isOn: $highlightMatchingBrackets)
|
|
Toggle("Show Scope Guides (Non-Swift)", isOn: $showScopeGuides)
|
|
Toggle("Highlight Scoped Region", isOn: $highlightScopeBackground)
|
|
Toggle("Line Wrap", isOn: $lineWrapEnabled)
|
|
Text("When Line Wrap is enabled, scope guides/scoped region are turned off to avoid layout conflicts.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
Text("Scope guides are intended for non-Swift languages. Swift favors matching-token highlight.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
Text("Invisible character markers are disabled to avoid whitespace glyph artifacts.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
|
|
Divider()
|
|
|
|
VStack(alignment: .leading, spacing: UI.space10) {
|
|
Text("Indentation")
|
|
.font(Typography.sectionHeadline)
|
|
Picker("Indent Style", selection: $indentStyle) {
|
|
Text("Spaces").tag("spaces")
|
|
Text("Tabs").tag("tabs")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
|
|
Stepper(value: $indentWidth, in: 2...8, step: 1) {
|
|
Text(localized("Indent Width: %lld", Int64(indentWidth)))
|
|
}
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
|
|
Divider()
|
|
|
|
VStack(alignment: .leading, spacing: UI.space10) {
|
|
Text("Layout")
|
|
.font(Typography.sectionHeadline)
|
|
Picker("Project Navigator Position", selection: $projectNavigatorPlacementRaw) {
|
|
Text("Left").tag(ContentView.ProjectNavigatorPlacement.leading.rawValue)
|
|
Text("Right").tag(ContentView.ProjectNavigatorPlacement.trailing.rawValue)
|
|
}
|
|
.pickerStyle(.segmented)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(UI.groupPadding)
|
|
}
|
|
#endif
|
|
}
|
|
|
|
private var editorBehaviorSettings: some View {
|
|
#if os(iOS)
|
|
VStack(spacing: UI.space16) {
|
|
settingsCardSection(
|
|
title: "Performance",
|
|
icon: "speedometer",
|
|
emphasis: .secondary
|
|
) {
|
|
Picker("Preset", selection: $performancePresetRaw) {
|
|
Text("Balanced").tag(ContentView.PerformancePreset.balanced.rawValue)
|
|
Text("Large Files").tag(ContentView.PerformancePreset.largeFiles.rawValue)
|
|
Text("Battery").tag(ContentView.PerformancePreset.battery.rawValue)
|
|
}
|
|
.pickerStyle(.segmented)
|
|
Text("Balanced keeps default behavior. Large Files and Battery enter performance mode earlier.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
Picker("Large File Syntax", selection: $largeFileSyntaxHighlightingRaw) {
|
|
Text("Off").tag("off")
|
|
Text("Minimal").tag("minimal")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
Picker("Large File Open", selection: $largeFileOpenModeRaw) {
|
|
Text("Standard").tag("standard")
|
|
Text("Deferred").tag("deferred")
|
|
Text("Plain Text").tag("plainText")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
Text("Minimal colors only visible JSON lines plus a small buffer using a strict work budget.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
Text("Deferred uses a lightweight loading step and chunked editor install. Plain Text keeps large-file sessions unstyled.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
|
|
settingsCardSection(
|
|
title: "Editing",
|
|
icon: "keyboard",
|
|
emphasis: .secondary
|
|
) {
|
|
Toggle("Auto Indent", isOn: $autoIndent)
|
|
Toggle("Auto Close Brackets", isOn: $autoCloseBrackets)
|
|
Toggle("Trim Trailing Whitespace", isOn: $trimTrailingWhitespace)
|
|
Toggle("Trim Edges for Syntax Detection", isOn: $trimWhitespaceForSyntaxDetection)
|
|
if isIPadDevice {
|
|
Divider()
|
|
Toggle("Enable Vim Mode", isOn: vimModeBinding)
|
|
Text("Requires a hardware keyboard on iPad. Escape returns to Normal mode, and the status line shows INSERT or NORMAL while Vim mode is active.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
|
|
settingsCardSection(
|
|
title: "Completion",
|
|
icon: "sparkles",
|
|
emphasis: .secondary
|
|
) {
|
|
Toggle("Enable Completion", isOn: $completionEnabled)
|
|
Toggle("Include Words in Document", isOn: $completionFromDocument)
|
|
Toggle("Include Syntax Keywords", isOn: $completionFromSyntax)
|
|
Text("For lower latency on large files, keep only one completion source enabled.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
#else
|
|
GroupBox("Editor Behavior") {
|
|
VStack(alignment: .leading, spacing: 16) {
|
|
VStack(alignment: .leading, spacing: UI.space10) {
|
|
Text("Performance")
|
|
.font(Typography.sectionHeadline)
|
|
Picker("Preset", selection: $performancePresetRaw) {
|
|
Text("Balanced").tag(ContentView.PerformancePreset.balanced.rawValue)
|
|
Text("Large Files").tag(ContentView.PerformancePreset.largeFiles.rawValue)
|
|
Text("Battery").tag(ContentView.PerformancePreset.battery.rawValue)
|
|
}
|
|
.pickerStyle(.segmented)
|
|
Text("Balanced keeps default behavior. Large Files and Battery enter performance mode earlier.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
Picker("Large File Syntax", selection: $largeFileSyntaxHighlightingRaw) {
|
|
Text("Off").tag("off")
|
|
Text("Minimal").tag("minimal")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
Picker("Large File Open", selection: $largeFileOpenModeRaw) {
|
|
Text("Standard").tag("standard")
|
|
Text("Deferred").tag("deferred")
|
|
Text("Plain Text").tag("plainText")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
Text("Minimal colors only visible JSON lines plus a small buffer using a strict work budget.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
Text("Deferred uses a lightweight loading step and chunked editor install. Plain Text keeps large-file sessions unstyled.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
|
|
Divider()
|
|
|
|
VStack(alignment: .leading, spacing: UI.space10) {
|
|
Text("Editing")
|
|
.font(Typography.sectionHeadline)
|
|
Toggle("Auto Indent", isOn: $autoIndent)
|
|
Toggle("Auto Close Brackets", isOn: $autoCloseBrackets)
|
|
Toggle("Trim Trailing Whitespace", isOn: $trimTrailingWhitespace)
|
|
Toggle("Trim Edges for Syntax Detection", isOn: $trimWhitespaceForSyntaxDetection)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
|
|
Divider()
|
|
|
|
VStack(alignment: .leading, spacing: UI.space10) {
|
|
Text("Completion")
|
|
.font(Typography.sectionHeadline)
|
|
Toggle("Enable Completion", isOn: $completionEnabled)
|
|
Toggle("Include Words in Document", isOn: $completionFromDocument)
|
|
Toggle("Include Syntax Keywords", isOn: $completionFromSyntax)
|
|
Text("For lower latency on large files, keep only one completion source enabled.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(UI.groupPadding)
|
|
}
|
|
#endif
|
|
}
|
|
|
|
private var templateTab: some View {
|
|
settingsContainer(maxWidth: 640) {
|
|
settingsSectionHeader(
|
|
icon: "doc.badge.plus",
|
|
title: "Templates",
|
|
subtitle: "Control language-specific starter content used when inserting templates."
|
|
)
|
|
#if os(iOS)
|
|
settingsCardSection(
|
|
title: "Completion Template",
|
|
icon: "doc.text",
|
|
tip: "Template content is inserted exactly as shown."
|
|
) {
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text("Language")
|
|
.frame(width: isCompactSettingsLayout ? nil : standardLabelWidth, alignment: .leading)
|
|
Picker("", selection: $settingsTemplateLanguage) {
|
|
ForEach(templateLanguages, id: \.self) { lang in
|
|
Text(languageLabel(for: lang)).tag(lang)
|
|
}
|
|
}
|
|
.frame(maxWidth: isCompactSettingsLayout ? .infinity : 220, alignment: .leading)
|
|
.pickerStyle(.menu)
|
|
.padding(.vertical, UI.space6)
|
|
.padding(.horizontal, UI.space8)
|
|
.background(Color.clear)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: 8)
|
|
.stroke(Color.secondary.opacity(0.35), lineWidth: 1)
|
|
)
|
|
.cornerRadius(8)
|
|
}
|
|
|
|
TextEditor(text: templateBinding(for: settingsTemplateLanguage))
|
|
.font(Typography.monoBody)
|
|
.frame(minHeight: 200, maxHeight: 320)
|
|
.scrollContentBackground(.hidden)
|
|
.background(Color.clear)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: 8)
|
|
.stroke(Color.secondary.opacity(0.2), lineWidth: 1)
|
|
)
|
|
|
|
HStack(spacing: UI.space12) {
|
|
Button("Reset to Default", role: .destructive) {
|
|
UserDefaults.standard.removeObject(forKey: templateOverrideKey(for: settingsTemplateLanguage))
|
|
}
|
|
Button("Use Default Template") {
|
|
if let fallback = defaultTemplate(for: settingsTemplateLanguage) {
|
|
UserDefaults.standard.set(fallback, forKey: templateOverrideKey(for: settingsTemplateLanguage))
|
|
}
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
#else
|
|
GroupBox("Completion Template") {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text("Language")
|
|
.frame(width: isCompactSettingsLayout ? nil : standardLabelWidth, alignment: .leading)
|
|
Picker("", selection: $settingsTemplateLanguage) {
|
|
ForEach(templateLanguages, id: \.self) { lang in
|
|
Text(languageLabel(for: lang)).tag(lang)
|
|
}
|
|
}
|
|
.frame(maxWidth: isCompactSettingsLayout ? .infinity : 220, alignment: .leading)
|
|
.pickerStyle(.menu)
|
|
.padding(.vertical, UI.space6)
|
|
.padding(.horizontal, UI.space8)
|
|
.background(Color.clear)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: 8)
|
|
.stroke(Color.secondary.opacity(0.35), lineWidth: 1)
|
|
)
|
|
.cornerRadius(8)
|
|
}
|
|
|
|
TextEditor(text: templateBinding(for: settingsTemplateLanguage))
|
|
.font(Typography.monoBody)
|
|
.frame(minHeight: 200, maxHeight: 320)
|
|
.scrollContentBackground(.hidden)
|
|
.background(Color.clear)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: 8)
|
|
.stroke(Color.secondary.opacity(0.2), lineWidth: 1)
|
|
)
|
|
|
|
HStack(spacing: UI.space12) {
|
|
Button("Reset to Default", role: .destructive) {
|
|
UserDefaults.standard.removeObject(forKey: templateOverrideKey(for: settingsTemplateLanguage))
|
|
}
|
|
Button("Use Default Template") {
|
|
if let fallback = defaultTemplate(for: settingsTemplateLanguage) {
|
|
UserDefaults.standard.set(fallback, forKey: templateOverrideKey(for: settingsTemplateLanguage))
|
|
}
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
.padding(UI.groupPadding)
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
private var themeTab: some View {
|
|
let isCustom = selectedTheme == "Custom"
|
|
let palette = themePaletteColors(for: selectedTheme)
|
|
let previewTheme = currentEditorTheme(colorScheme: effectiveSettingsColorScheme)
|
|
return settingsContainer(maxWidth: 760) {
|
|
settingsSectionHeader(
|
|
icon: "paintpalette",
|
|
title: "Themes",
|
|
subtitle: "Pick a preset or customize token colors for your editing environment."
|
|
)
|
|
Group {
|
|
if isCompactSettingsLayout {
|
|
VStack(alignment: .leading, spacing: UI.space16) {
|
|
themeSelectionPane
|
|
themeCustomizationPane(isCustom: isCustom, palette: palette, previewTheme: previewTheme)
|
|
}
|
|
} else {
|
|
HStack(alignment: .top, spacing: UI.space16) {
|
|
themeSelectionPane
|
|
themeCustomizationPane(isCustom: isCustom, palette: palette, previewTheme: previewTheme)
|
|
}
|
|
}
|
|
}
|
|
#if os(iOS)
|
|
.padding(.top, 20)
|
|
#endif
|
|
}
|
|
}
|
|
|
|
private var themeSelectionPane: some View {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
#if os(macOS)
|
|
let listView = List(themes, id: \.self, selection: $selectedTheme) { theme in
|
|
HStack {
|
|
Text(theme)
|
|
Spacer(minLength: 8)
|
|
if theme == selectedTheme {
|
|
Image(systemName: "checkmark.circle.fill")
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
.contentShape(Rectangle())
|
|
.listRowBackground(Color.clear)
|
|
}
|
|
.frame(minWidth: 200)
|
|
.listStyle(.plain)
|
|
.background(Color.clear)
|
|
if #available(macOS 13.0, *) {
|
|
listView.scrollContentBackground(.hidden)
|
|
} else {
|
|
listView
|
|
}
|
|
#else
|
|
if isCompactSettingsLayout {
|
|
VStack(alignment: .leading, spacing: UI.space10) {
|
|
Text("Theme")
|
|
.font(Typography.sectionSubheadline)
|
|
.foregroundStyle(.secondary)
|
|
|
|
Picker("Theme", selection: $selectedTheme) {
|
|
ForEach(themes, id: \.self) { theme in
|
|
Text(theme).tag(theme)
|
|
}
|
|
}
|
|
.pickerStyle(.menu)
|
|
.labelsHidden()
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(.horizontal, UI.space10)
|
|
.padding(.vertical, UI.space8)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 10, style: .continuous)
|
|
.fill(.thinMaterial)
|
|
)
|
|
|
|
Text(selectedTheme)
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
} else {
|
|
let listView = List {
|
|
ForEach(themes, id: \.self) { theme in
|
|
HStack {
|
|
Text(theme)
|
|
Spacer()
|
|
if theme == selectedTheme {
|
|
Image(systemName: "checkmark")
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
.contentShape(Rectangle())
|
|
.onTapGesture {
|
|
selectedTheme = theme
|
|
}
|
|
.listRowBackground(Color.clear)
|
|
}
|
|
Color.clear
|
|
.frame(height: 96)
|
|
.listRowSeparator(.hidden)
|
|
.listRowBackground(Color.clear)
|
|
}
|
|
.frame(minWidth: 200)
|
|
.listStyle(.plain)
|
|
.background(Color.clear)
|
|
if #available(iOS 16.0, *) {
|
|
listView.scrollContentBackground(.hidden)
|
|
} else {
|
|
listView
|
|
}
|
|
}
|
|
#endif
|
|
VStack(alignment: .leading, spacing: UI.space10) {
|
|
Text("Formatting")
|
|
.font(Typography.sectionSubheadline)
|
|
.foregroundStyle(.secondary)
|
|
|
|
LazyVGrid(
|
|
columns: [
|
|
GridItem(.flexible(minimum: 140), spacing: UI.space12, alignment: .leading),
|
|
GridItem(.flexible(minimum: 140), spacing: UI.space12, alignment: .leading)
|
|
],
|
|
alignment: .leading,
|
|
spacing: UI.space8
|
|
) {
|
|
Toggle("Bold keywords", isOn: $themeBoldKeywords)
|
|
Toggle("Italic comments", isOn: $themeItalicComments)
|
|
Toggle("Underline links", isOn: $themeUnderlineLinks)
|
|
Toggle("Bold Markdown headings", isOn: $themeBoldMarkdownHeadings)
|
|
}
|
|
}
|
|
.padding(UI.space12)
|
|
.background(settingsCardBackground(cornerRadius: UI.cardCorner))
|
|
|
|
VStack(alignment: .leading, spacing: UI.space10) {
|
|
Text("Markdown Preview")
|
|
.font(Typography.sectionSubheadline)
|
|
.foregroundStyle(.secondary)
|
|
|
|
Picker("Markdown Preview Background", selection: $markdownPreviewBackgroundStyleRaw) {
|
|
ForEach(ContentView.MarkdownPreviewBackgroundStyle.allCases) { style in
|
|
Text(style.title).tag(style.rawValue)
|
|
}
|
|
}
|
|
.pickerStyle(.menu)
|
|
.labelsHidden()
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(.horizontal, UI.space10)
|
|
.padding(.vertical, UI.space8)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 10, style: .continuous)
|
|
.fill(.thinMaterial)
|
|
)
|
|
|
|
Text("Choose how the Markdown preview surface behaves in light and dark mode.")
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.padding(UI.space12)
|
|
.background(settingsCardBackground(cornerRadius: UI.cardCorner))
|
|
}
|
|
.padding(UI.space8)
|
|
.background(settingsCardBackground(cornerRadius: UI.cardCorner))
|
|
}
|
|
|
|
private func themeCustomizationPane(
|
|
isCustom: Bool,
|
|
palette: ThemePaletteColors,
|
|
previewTheme: EditorTheme
|
|
) -> some View {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
HStack(alignment: .firstTextBaseline, spacing: UI.space8) {
|
|
Text("Theme Colors")
|
|
.font(Typography.sectionHeadline)
|
|
Text(isCustom ? "Custom" : "Preset")
|
|
.font(.caption.weight(.semibold))
|
|
.padding(.horizontal, 8)
|
|
.padding(.vertical, 3)
|
|
.background(
|
|
Capsule()
|
|
.fill(isCustom ? Color.blue.opacity(0.18) : Color.secondary.opacity(0.16))
|
|
)
|
|
.foregroundStyle(isCustom ? .blue : .secondary)
|
|
}
|
|
|
|
HStack(spacing: UI.space8) {
|
|
Circle().fill(palette.background).frame(width: 12, height: 12)
|
|
Circle().fill(palette.text).frame(width: 12, height: 12)
|
|
Circle().fill(palette.cursor).frame(width: 12, height: 12)
|
|
Circle().fill(palette.selection).frame(width: 12, height: 12)
|
|
Spacer()
|
|
Text(selectedTheme)
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.padding(.horizontal, UI.space10)
|
|
.padding(.vertical, UI.space8)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 10, style: .continuous)
|
|
.fill(.thinMaterial)
|
|
)
|
|
|
|
themePreviewSnippet(previewTheme: previewTheme)
|
|
|
|
VStack(alignment: .leading, spacing: UI.space10) {
|
|
Text("Base")
|
|
.font(Typography.sectionSubheadline)
|
|
.foregroundStyle(.secondary)
|
|
|
|
colorRow(title: "Text", color: isCustom ? hexBinding($themeTextHex, fallback: .white) : .constant(palette.text))
|
|
.disabled(!isCustom)
|
|
colorRow(title: "Background", color: isCustom ? hexBinding($themeBackgroundHex, fallback: .black) : .constant(palette.background))
|
|
.disabled(!isCustom)
|
|
colorRow(title: "Cursor", color: isCustom ? hexBinding($themeCursorHex, fallback: .blue) : .constant(palette.cursor))
|
|
.disabled(!isCustom)
|
|
colorRow(title: "Selection", color: isCustom ? hexBinding($themeSelectionHex, fallback: .gray) : .constant(palette.selection))
|
|
.disabled(!isCustom)
|
|
}
|
|
.padding(UI.space12)
|
|
.background(settingsCardBackground(cornerRadius: UI.cardCorner))
|
|
|
|
VStack(alignment: .leading, spacing: UI.space10) {
|
|
Text("Syntax")
|
|
.font(Typography.sectionSubheadline)
|
|
.foregroundStyle(.secondary)
|
|
|
|
colorRow(title: "Keywords", color: isCustom ? hexBinding($themeKeywordHex, fallback: .yellow) : .constant(palette.keyword))
|
|
.disabled(!isCustom)
|
|
colorRow(title: "Strings", color: isCustom ? hexBinding($themeStringHex, fallback: .blue) : .constant(palette.string))
|
|
.disabled(!isCustom)
|
|
colorRow(title: "Numbers", color: isCustom ? hexBinding($themeNumberHex, fallback: .orange) : .constant(palette.number))
|
|
.disabled(!isCustom)
|
|
colorRow(title: "Comments", color: isCustom ? hexBinding($themeCommentHex, fallback: .gray) : .constant(palette.comment))
|
|
.disabled(!isCustom)
|
|
colorRow(title: "Types", color: isCustom ? hexBinding($themeTypeHex, fallback: .green) : .constant(palette.type))
|
|
.disabled(!isCustom)
|
|
colorRow(title: "Builtins", color: isCustom ? hexBinding($themeBuiltinHex, fallback: .red) : .constant(palette.builtin))
|
|
.disabled(!isCustom)
|
|
}
|
|
.padding(UI.space12)
|
|
.background(settingsCardBackground(cornerRadius: UI.cardCorner))
|
|
|
|
Text(isCustom ? "Custom theme applies immediately. Formatting applies to every active theme." : "Select Custom to edit colors. Formatting applies to every active theme.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(UI.space12)
|
|
.background(settingsCardBackground(cornerRadius: 14))
|
|
}
|
|
|
|
private var selectedAIModelBinding: Binding<AIModel> {
|
|
Binding(
|
|
get: { AIModel(rawValue: selectedAIModelRaw) ?? .appleIntelligence },
|
|
set: { selectedAIModelRaw = $0.rawValue }
|
|
)
|
|
}
|
|
|
|
private var moreTab: some View {
|
|
settingsContainer(maxWidth: 560) {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
settingsSectionHeader(
|
|
icon: "ellipsis.circle",
|
|
title: "More",
|
|
subtitle: "AI setup, remote preview controls, provider credentials, and support options."
|
|
)
|
|
Picker("More Section", selection: $moreSectionTab) {
|
|
Text("Support").tag("support")
|
|
Text("AI").tag("ai")
|
|
Text("Remote").tag("remote")
|
|
Text("Diagnostics").tag("diagnostics")
|
|
}
|
|
.pickerStyle(.segmented)
|
|
}
|
|
.padding(UI.groupPadding)
|
|
.background(settingsCardBackground(cornerRadius: 14))
|
|
|
|
ZStack {
|
|
if moreSectionTab == "ai" {
|
|
aiSection
|
|
.transition(.opacity)
|
|
} else if moreSectionTab == "remote" {
|
|
remoteSection
|
|
.transition(.opacity)
|
|
} else if moreSectionTab == "diagnostics" {
|
|
diagnosticsSection
|
|
.transition(.opacity)
|
|
} else {
|
|
supportSection
|
|
.transition(.opacity)
|
|
}
|
|
}
|
|
.animation(.easeOut(duration: 0.15), value: moreSectionTab)
|
|
}
|
|
}
|
|
|
|
private var aiTab: some View {
|
|
settingsContainer(maxWidth: 560) {
|
|
settingsSectionHeader(
|
|
icon: "brain.head.profile",
|
|
title: "AI",
|
|
subtitle: "AI model, privacy disclosure, and provider credentials."
|
|
)
|
|
aiSection
|
|
}
|
|
}
|
|
|
|
private var supportTab: some View {
|
|
settingsContainer(maxWidth: 560) {
|
|
settingsSectionHeader(
|
|
icon: "heart",
|
|
title: "Support",
|
|
subtitle: "Optional consumable support tip and build-specific options."
|
|
)
|
|
supportSection
|
|
}
|
|
}
|
|
|
|
private var remoteTab: some View {
|
|
settingsContainer(maxWidth: 560) {
|
|
settingsSectionHeader(
|
|
icon: "rectangle.connected.to.line.below",
|
|
title: "Remote",
|
|
subtitle: "Optional, on-demand remote-session groundwork with zero startup activity."
|
|
)
|
|
remoteSection
|
|
}
|
|
}
|
|
|
|
private var trimmedRemoteHost: String {
|
|
remoteHost.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
}
|
|
|
|
private var trimmedRemoteUsername: String {
|
|
remoteUsername.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
}
|
|
|
|
private var trimmedRemoteConnectNickname: String {
|
|
remoteConnectNickname.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
}
|
|
|
|
private var canSubmitRemoteConnectDraft: Bool {
|
|
remoteSessionsEnabled && !trimmedRemoteHost.isEmpty
|
|
}
|
|
|
|
private var remoteStatusSummary: String {
|
|
if !remoteSessionsEnabled {
|
|
return "Local workspace only. Remote modules stay inactive until you enable this preview."
|
|
}
|
|
if remoteSessionStore.isRemotePreviewConnecting, let activeTarget = remoteSessionStore.activeTarget {
|
|
return "Connecting to \(activeTarget.connectionSummary). This TCP handshake is user-triggered and still does not enable file browsing or remote editing."
|
|
}
|
|
if remoteSessionStore.isRemotePreviewConnected, let activeTarget = remoteSessionStore.activeTarget {
|
|
return "Remote session active for \(activeTarget.connectionSummary). Phase 4 keeps the connection explicit and does not enable file browsing or remote editing."
|
|
}
|
|
if let activeTarget = remoteSessionStore.activeTarget {
|
|
return "Active preview target: \(activeTarget.connectionSummary). Starting a remote session now performs an explicit TCP connection attempt in Phase 4."
|
|
}
|
|
if !remoteSessionStore.savedTargets.isEmpty {
|
|
return "Remote preview is enabled. Choose a saved target or create a new local preview target when ready."
|
|
}
|
|
if !remotePreparedTarget.isEmpty {
|
|
return "Saved target: \(remotePreparedTarget). Open Connect to convert it into a reusable local target."
|
|
}
|
|
return "Remote preview is enabled, but no target is selected yet."
|
|
}
|
|
|
|
private func presentRemoteConnectSheet() {
|
|
if remoteConnectNickname.isEmpty {
|
|
if let activeTarget = remoteSessionStore.activeTarget {
|
|
remoteConnectNickname = activeTarget.displayTitle
|
|
} else if !trimmedRemoteHost.isEmpty {
|
|
remoteConnectNickname = trimmedRemoteHost
|
|
}
|
|
}
|
|
showRemoteConnectSheet = true
|
|
}
|
|
|
|
private func connectRemotePreview() {
|
|
guard canSubmitRemoteConnectDraft else { return }
|
|
guard let target = remoteSessionStore.connectPreview(
|
|
nickname: trimmedRemoteConnectNickname,
|
|
host: trimmedRemoteHost,
|
|
username: trimmedRemoteUsername,
|
|
port: remotePort
|
|
) else {
|
|
return
|
|
}
|
|
remoteSessionsEnabled = true
|
|
remotePreparedTarget = target.connectionSummary
|
|
remoteConnectNickname = target.nickname
|
|
remotePreparationStatus = "Local preview target selected. No network connection has been opened."
|
|
showRemoteConnectSheet = false
|
|
}
|
|
|
|
private func activateRemoteTarget(_ target: RemoteSessionStore.SavedTarget) {
|
|
remoteSessionsEnabled = true
|
|
remoteSessionStore.activateSavedTarget(id: target.id)
|
|
remotePreparedTarget = target.connectionSummary
|
|
remotePreparationStatus = "Switched to \(target.displayTitle). The workspace remains local."
|
|
}
|
|
|
|
private func startRemoteSession() {
|
|
guard remoteSessionsEnabled, remoteSessionStore.isRemotePreviewReady, !remoteSessionStore.isRemotePreviewConnecting else { return }
|
|
remotePreparationStatus = "Connecting to the selected target…"
|
|
Task {
|
|
let didConnect = await remoteSessionStore.startSession()
|
|
await MainActor.run {
|
|
remotePreparationStatus = didConnect
|
|
? remoteSessionStore.sessionStatusDetail
|
|
: (remoteSessionStore.sessionStatusDetail.isEmpty ? "Connection failed." : remoteSessionStore.sessionStatusDetail)
|
|
}
|
|
}
|
|
}
|
|
|
|
private func stopRemoteSession() {
|
|
remoteSessionStore.stopSession()
|
|
remotePreparationStatus = remoteSessionStore.sessionStatusDetail.isEmpty
|
|
? (remoteSessionStore.isRemotePreviewReady ? "Remote session stopped. Target stays selected for later." : "Remote session stopped.")
|
|
: remoteSessionStore.sessionStatusDetail
|
|
}
|
|
|
|
private func disconnectRemotePreview() {
|
|
remoteSessionStore.disconnectPreview()
|
|
remotePreparedTarget = ""
|
|
remotePreparationStatus = remoteSessionsEnabled ? "Remote preview target cleared. Workspace remains local." : ""
|
|
}
|
|
|
|
private func removeRemoteTarget(_ target: RemoteSessionStore.SavedTarget) {
|
|
let wasActive = remoteSessionStore.activeTargetID == target.id
|
|
remoteSessionStore.removeSavedTarget(id: target.id)
|
|
if wasActive {
|
|
remotePreparedTarget = ""
|
|
remotePreparationStatus = remoteSessionsEnabled ? "Removed the active remote preview target. Workspace remains local." : ""
|
|
} else {
|
|
remotePreparationStatus = "Removed \(target.displayTitle) from saved local targets."
|
|
}
|
|
}
|
|
|
|
private var remoteTargetActiveBadge: some View {
|
|
Text("Active")
|
|
.font(.caption.weight(.semibold))
|
|
.foregroundStyle(.secondary)
|
|
.padding(.horizontal, 8)
|
|
.padding(.vertical, 4)
|
|
.background(
|
|
Capsule(style: .continuous)
|
|
.fill(Color.secondary.opacity(0.12))
|
|
)
|
|
}
|
|
|
|
private var remoteRuntimeBadgeTitle: String {
|
|
switch remoteSessionStore.runtimeState {
|
|
case .connecting:
|
|
return "Connecting"
|
|
case .active:
|
|
return "Session Active"
|
|
case .failed:
|
|
return "Failed"
|
|
default:
|
|
return "Ready"
|
|
}
|
|
}
|
|
|
|
private var remoteSessionRuntimeBadge: some View {
|
|
Text(remoteRuntimeBadgeTitle)
|
|
.font(.caption.weight(.semibold))
|
|
.foregroundStyle(.secondary)
|
|
.padding(.horizontal, 8)
|
|
.padding(.vertical, 4)
|
|
.background(
|
|
Capsule(style: .continuous)
|
|
.fill(Color.secondary.opacity(0.12))
|
|
)
|
|
}
|
|
|
|
private func remoteTargetCard(_ target: RemoteSessionStore.SavedTarget) -> some View {
|
|
VStack(alignment: .leading, spacing: UI.space8) {
|
|
HStack(alignment: .firstTextBaseline, spacing: UI.space8) {
|
|
Text(target.displayTitle)
|
|
.font(.headline)
|
|
if remoteSessionStore.activeTargetID == target.id {
|
|
remoteTargetActiveBadge
|
|
remoteSessionRuntimeBadge
|
|
}
|
|
}
|
|
|
|
Text(target.connectionSummary)
|
|
.font(.footnote.monospaced())
|
|
.foregroundStyle(.secondary)
|
|
|
|
HStack(spacing: UI.space8) {
|
|
Button(remoteSessionStore.activeTargetID == target.id ? "Selected" : "Use Saved Target") {
|
|
activateRemoteTarget(target)
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
.disabled(!remoteSessionsEnabled || remoteSessionStore.activeTargetID == target.id)
|
|
|
|
Button("Remove") {
|
|
removeRemoteTarget(target)
|
|
}
|
|
.buttonStyle(.bordered)
|
|
}
|
|
}
|
|
.padding(UI.space12)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 16, style: .continuous)
|
|
.fill(inputFieldBackground.opacity(0.85))
|
|
)
|
|
}
|
|
|
|
private var remoteSessionActionButtons: some View {
|
|
ViewThatFits {
|
|
HStack(spacing: UI.space12) {
|
|
Button("Connect…") {
|
|
presentRemoteConnectSheet()
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
.disabled(!remoteSessionsEnabled)
|
|
|
|
Button("Start Session") {
|
|
startRemoteSession()
|
|
}
|
|
.buttonStyle(.bordered)
|
|
.disabled(!remoteSessionsEnabled || !remoteSessionStore.isRemotePreviewReady || remoteSessionStore.isRemotePreviewConnected || remoteSessionStore.isRemotePreviewConnecting)
|
|
|
|
Button("Stop Session") {
|
|
stopRemoteSession()
|
|
}
|
|
.buttonStyle(.bordered)
|
|
.disabled(!remoteSessionStore.isRemotePreviewConnected && !remoteSessionStore.isRemotePreviewConnecting)
|
|
|
|
Button("Disconnect") {
|
|
disconnectRemotePreview()
|
|
}
|
|
.buttonStyle(.bordered)
|
|
.disabled(!remoteSessionStore.isRemotePreviewReady && remotePreparedTarget.isEmpty)
|
|
}
|
|
|
|
VStack(alignment: .leading, spacing: UI.space8) {
|
|
Button("Connect…") {
|
|
presentRemoteConnectSheet()
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
.disabled(!remoteSessionsEnabled)
|
|
|
|
Button("Start Session") {
|
|
startRemoteSession()
|
|
}
|
|
.buttonStyle(.bordered)
|
|
.disabled(!remoteSessionsEnabled || !remoteSessionStore.isRemotePreviewReady || remoteSessionStore.isRemotePreviewConnected || remoteSessionStore.isRemotePreviewConnecting)
|
|
|
|
Button("Stop Session") {
|
|
stopRemoteSession()
|
|
}
|
|
.buttonStyle(.bordered)
|
|
.disabled(!remoteSessionStore.isRemotePreviewConnected && !remoteSessionStore.isRemotePreviewConnecting)
|
|
|
|
Button("Disconnect") {
|
|
disconnectRemotePreview()
|
|
}
|
|
.buttonStyle(.bordered)
|
|
.disabled(!remoteSessionStore.isRemotePreviewReady && remotePreparedTarget.isEmpty)
|
|
}
|
|
}
|
|
}
|
|
|
|
private var remoteSavedTargetsList: some View {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
ForEach(Array(remoteSessionStore.savedTargets), id: \.id) { target in
|
|
remoteTargetCard(target)
|
|
}
|
|
}
|
|
}
|
|
|
|
private var remoteConnectSheet: some View {
|
|
VStack(alignment: .leading, spacing: UI.space16) {
|
|
Text("Remote Connect")
|
|
.font(.title3.weight(.semibold))
|
|
|
|
Text("Connect stores and selects a preview target. Phase 4 adds an explicit TCP connection attempt only when you start a session, while file browsing and remote editing stay inactive.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
TextField("Nickname", text: $remoteConnectNickname)
|
|
.textFieldStyle(.roundedBorder)
|
|
TextField("Host", text: $remoteHost)
|
|
.textFieldStyle(.roundedBorder)
|
|
#if os(iOS)
|
|
.textInputAutocapitalization(.never)
|
|
.autocorrectionDisabled()
|
|
#endif
|
|
TextField("User", text: $remoteUsername)
|
|
.textFieldStyle(.roundedBorder)
|
|
#if os(iOS)
|
|
.textInputAutocapitalization(.never)
|
|
.autocorrectionDisabled()
|
|
#endif
|
|
Stepper(value: $remotePort, in: 1...65535) {
|
|
Text("Port \(remotePort)")
|
|
.font(.body.monospacedDigit())
|
|
}
|
|
}
|
|
|
|
HStack(spacing: UI.space12) {
|
|
Spacer()
|
|
|
|
Button("Cancel") {
|
|
showRemoteConnectSheet = false
|
|
}
|
|
.buttonStyle(.bordered)
|
|
|
|
Button("Connect Locally") {
|
|
connectRemotePreview()
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
.disabled(!canSubmitRemoteConnectDraft)
|
|
}
|
|
}
|
|
.padding(UI.space20)
|
|
.frame(minWidth: 320, idealWidth: 420)
|
|
}
|
|
|
|
private var remoteSection: some View {
|
|
VStack(spacing: UI.space20) {
|
|
#if os(iOS)
|
|
settingsCardSection(
|
|
title: "Remote Sessions",
|
|
icon: "rectangle.connected.to.line.below"
|
|
) {
|
|
iOSToggleRow("Enable Preview", isOn: $remoteSessionsEnabled)
|
|
|
|
Text("Remote support is opt-in. When disabled, Neon Vision Editor performs no remote handshake, no background polling, and no startup initialization for remote workflows.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
remoteSessionActionButtons
|
|
|
|
Text(remoteStatusSummary)
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
if !remoteSessionStore.savedTargets.isEmpty {
|
|
remoteSavedTargetsList
|
|
}
|
|
|
|
if !remotePreparationStatus.isEmpty {
|
|
Text(remotePreparationStatus)
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
|
|
settingsCardSection(
|
|
title: "Phase 4 Scope",
|
|
icon: "lock.shield",
|
|
emphasis: .secondary,
|
|
showsAccentStripe: false
|
|
) {
|
|
Text("Phase 4 adds an explicit user-triggered TCP connection attempt with timeout and manual stop. SSH login, remote file browsing, and live remote editing remain inactive.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
#else
|
|
GroupBox("Remote Sessions") {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
Toggle("Enable Remote Preview", isOn: $remoteSessionsEnabled)
|
|
|
|
Text("Remote support is opt-in. When disabled, Neon Vision Editor performs no remote handshake, no background polling, and no startup initialization for remote workflows.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
remoteSessionActionButtons
|
|
|
|
Text(remoteStatusSummary)
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
if !remoteSessionStore.savedTargets.isEmpty {
|
|
remoteSavedTargetsList
|
|
}
|
|
|
|
if !remotePreparationStatus.isEmpty {
|
|
Text(remotePreparationStatus)
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
.padding(UI.groupPadding)
|
|
}
|
|
|
|
GroupBox("Phase 4 Scope") {
|
|
Text("Phase 4 adds an explicit user-triggered TCP connection attempt with timeout and manual stop. SSH login, remote file browsing, and live remote editing remain inactive.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(UI.groupPadding)
|
|
}
|
|
#endif
|
|
}
|
|
.onChange(of: remoteSessionsEnabled) { _, isEnabled in
|
|
if !isEnabled {
|
|
remoteSessionStore.disconnectPreview()
|
|
remotePreparationStatus = ""
|
|
}
|
|
}
|
|
}
|
|
|
|
private var aiSection: some View {
|
|
VStack(spacing: UI.space20) {
|
|
#if os(iOS)
|
|
settingsCardSection(
|
|
title: "AI Model",
|
|
icon: "brain.head.profile"
|
|
) {
|
|
Picker("Model", selection: selectedAIModelBinding) {
|
|
Text("Apple Intelligence").tag(AIModel.appleIntelligence)
|
|
Text("Grok").tag(AIModel.grok)
|
|
Text("OpenAI").tag(AIModel.openAI)
|
|
Text("Gemini").tag(AIModel.gemini)
|
|
Text("Anthropic").tag(AIModel.anthropic)
|
|
}
|
|
.pickerStyle(.menu)
|
|
|
|
Text("The selected AI model is used for AI-assisted code completion.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
Button("Data Disclosure") {
|
|
showDataDisclosureDialog = true
|
|
}
|
|
.buttonStyle(.bordered)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
|
|
settingsCardSection(
|
|
title: "AI Provider API Keys",
|
|
icon: "key.fill",
|
|
emphasis: .secondary,
|
|
tip: "Keys are stored in the system Keychain."
|
|
) {
|
|
VStack(alignment: .center, spacing: UI.space12) {
|
|
aiKeyRow(title: "Grok", placeholder: "sk-…", value: $grokAPIToken, provider: .grok)
|
|
aiKeyRow(title: "OpenAI", placeholder: "sk-…", value: $openAIAPIToken, provider: .openAI)
|
|
aiKeyRow(title: "Gemini", placeholder: "AIza…", value: $geminiAPIToken, provider: .gemini)
|
|
aiKeyRow(title: "Anthropic", placeholder: "sk-ant-…", value: $anthropicAPIToken, provider: .anthropic)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .center)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
#else
|
|
GroupBox("AI Model") {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
Picker("Model", selection: selectedAIModelBinding) {
|
|
Text("Apple Intelligence").tag(AIModel.appleIntelligence)
|
|
Text("Grok").tag(AIModel.grok)
|
|
Text("OpenAI").tag(AIModel.openAI)
|
|
Text("Gemini").tag(AIModel.gemini)
|
|
Text("Anthropic").tag(AIModel.anthropic)
|
|
}
|
|
.pickerStyle(.menu)
|
|
|
|
Text("The selected AI model is used for AI-assisted code completion.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
Button("Data Disclosure") {
|
|
showDataDisclosureDialog = true
|
|
}
|
|
.buttonStyle(.bordered)
|
|
}
|
|
.padding(UI.groupPadding)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
|
|
GroupBox("AI Provider API Keys") {
|
|
VStack(alignment: .center, spacing: UI.space12) {
|
|
aiKeyRow(title: "Grok", placeholder: "sk-…", value: $grokAPIToken, provider: .grok)
|
|
aiKeyRow(title: "OpenAI", placeholder: "sk-…", value: $openAIAPIToken, provider: .openAI)
|
|
aiKeyRow(title: "Gemini", placeholder: "AIza…", value: $geminiAPIToken, provider: .gemini)
|
|
aiKeyRow(title: "Anthropic", placeholder: "sk-ant-…", value: $anthropicAPIToken, provider: .anthropic)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .center)
|
|
.padding(UI.groupPadding)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
#endif
|
|
}
|
|
}
|
|
|
|
private var supportSection: some View {
|
|
#if os(iOS)
|
|
settingsCardSection(
|
|
title: "Support Development",
|
|
icon: "heart.circle.fill",
|
|
emphasis: .secondary,
|
|
tip: "Support is optional. All editor features remain available without a purchase."
|
|
) {
|
|
supportSectionContent
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
#else
|
|
VStack(spacing: UI.space16) {
|
|
GroupBox(localized("Support Development")) {
|
|
supportSectionContent
|
|
.padding(UI.groupPadding)
|
|
}
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
#endif
|
|
}
|
|
|
|
private var supportSectionContent: some View {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
Text(localized("In-App Purchase is optional and only used to support the app."))
|
|
.foregroundStyle(.secondary)
|
|
Text(localized("Consumable support purchase. Can be purchased multiple times. No subscription and no auto-renewal."))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
if shouldShowSupportPurchaseControls {
|
|
VStack(alignment: .leading, spacing: UI.space8) {
|
|
Text(localized("App Store Price"))
|
|
.font(.caption.weight(.semibold))
|
|
.foregroundStyle(.secondary)
|
|
HStack(alignment: .firstTextBaseline, spacing: UI.space8) {
|
|
Text(
|
|
supportPurchaseManager.isLoadingProducts && supportPurchaseManager.supportProduct == nil
|
|
? localized("Loading...")
|
|
: localized("Current")
|
|
)
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
Spacer()
|
|
Text(supportPurchaseManager.supportPriceLabel)
|
|
.font(Typography.sectionTitle)
|
|
.monospacedDigit()
|
|
.accessibilityLabel(localized("App Store Price"))
|
|
.accessibilityValue(
|
|
supportPurchaseManager.supportProduct == nil
|
|
? localized("Price unavailable")
|
|
: supportPurchaseManager.supportPriceLabel
|
|
)
|
|
}
|
|
if supportPurchaseManager.supportProduct == nil && !supportPurchaseManager.isLoadingProducts {
|
|
Text(localized("Price unavailable right now. Tap Retry App Store."))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
if let lastRefresh = supportPurchaseManager.lastSuccessfulPriceRefreshAt {
|
|
Text(
|
|
localized(
|
|
"Last updated: %@",
|
|
lastRefresh.formatted(date: .abbreviated, time: .shortened)
|
|
)
|
|
)
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
.accessibilityLabel(localized("Last updated"))
|
|
.accessibilityValue(lastRefresh.formatted(date: .abbreviated, time: .shortened))
|
|
}
|
|
}
|
|
.padding(UI.space12)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: UI.cardCorner, style: .continuous)
|
|
.fill(Color.primary.opacity(0.04))
|
|
)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: UI.cardCorner, style: .continuous)
|
|
.stroke(Color.primary.opacity(UI.cardStrokeOpacity), lineWidth: 1)
|
|
)
|
|
|
|
HStack(spacing: UI.space12) {
|
|
Button(supportPurchaseManager.isPurchasing ? localized("Purchasing…") : localized("Send Support Tip")) {
|
|
guard supportPurchaseManager.canUseInAppPurchases else {
|
|
Task { await supportPurchaseManager.purchaseSupport() }
|
|
return
|
|
}
|
|
guard supportPurchaseManager.supportProduct != nil else {
|
|
Task { await supportPurchaseManager.refreshPrice() }
|
|
supportPurchaseManager.statusMessage = localized("Loading App Store product. Please try again in a moment.")
|
|
return
|
|
}
|
|
showSupportPurchaseDialog = true
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
.disabled(
|
|
supportPurchaseManager.isPurchasing
|
|
)
|
|
|
|
Button {
|
|
Task { await supportPurchaseManager.refreshPrice() }
|
|
} label: {
|
|
if supportPurchaseManager.isLoadingProducts {
|
|
HStack(spacing: UI.space8) {
|
|
ProgressView()
|
|
.controlSize(.small)
|
|
Text(localized("Retry App Store"))
|
|
}
|
|
} else {
|
|
Label(localized("Retry App Store"), systemImage: "arrow.clockwise")
|
|
}
|
|
}
|
|
.buttonStyle(.bordered)
|
|
.disabled(supportPurchaseManager.isLoadingProducts)
|
|
}
|
|
|
|
if !supportPurchaseManager.canUseInAppPurchases {
|
|
Text(localized("Direct notarized builds are unaffected: all editor features stay fully available without any purchase."))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
} else {
|
|
Text(localized("Direct notarized builds are unaffected: all editor features stay fully available without any purchase."))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
|
|
if let externalURL = SupportPurchaseManager.externalSupportURL {
|
|
Button {
|
|
openURL(externalURL)
|
|
} label: {
|
|
Label(localized("Support via Patreon"), systemImage: "safari")
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
}
|
|
|
|
HStack(spacing: UI.space16) {
|
|
if let privacyPolicyURL {
|
|
Link(destination: privacyPolicyURL) {
|
|
Label(localized("Privacy Policy"), systemImage: "hand.raised")
|
|
.font(.footnote.weight(.semibold))
|
|
}
|
|
}
|
|
|
|
if let termsOfUseURL {
|
|
Link(destination: termsOfUseURL) {
|
|
Label(localized("Terms of Use"), systemImage: "doc.text")
|
|
.font(.footnote.weight(.semibold))
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private var diagnosticsSection: some View {
|
|
let events = EditorPerformanceMonitor.shared.recentFileOpenEvents(limit: 8).reversed()
|
|
return VStack(spacing: UI.space16) {
|
|
#if os(iOS)
|
|
settingsCardSection(
|
|
title: "Diagnostics",
|
|
icon: "stethoscope",
|
|
emphasis: .secondary,
|
|
tip: "Safe local diagnostics for update and file-open troubleshooting."
|
|
) {
|
|
diagnosticsSectionContent(events: Array(events))
|
|
}
|
|
#else
|
|
GroupBox("Diagnostics") {
|
|
diagnosticsSectionContent(events: Array(events))
|
|
.padding(UI.groupPadding)
|
|
}
|
|
#endif
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
|
|
private func diagnosticsSectionContent(events: [EditorPerformanceMonitor.FileOpenEvent]) -> some View {
|
|
VStack(alignment: .leading, spacing: UI.space10) {
|
|
Text("Updater")
|
|
.font(.subheadline.weight(.semibold))
|
|
Text(localized("Last check result: %@", appUpdateManager.lastCheckResultSummary))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
if let checkedAt = appUpdateManager.lastCheckedAt {
|
|
Text(localized("Last checked: %@", checkedAt.formatted(date: .abbreviated, time: .shortened)))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
if let pausedUntil = appUpdateManager.pausedUntil, pausedUntil > Date() {
|
|
Text(localized("Auto-check pause active until %@ (%lld consecutive failures).", pausedUntil.formatted(date: .abbreviated, time: .shortened), appUpdateManager.consecutiveFailureCount))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.orange)
|
|
}
|
|
Text(localized("Staged update: %@", appUpdateManager.stagedUpdateVersionSummary))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
Text(localized("Last install attempt: %@", appUpdateManager.lastInstallAttemptSummary))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
Text("Recent updater log")
|
|
.font(.subheadline.weight(.semibold))
|
|
ScrollView {
|
|
Text(appUpdateManager.recentLogSnippet)
|
|
.font(Typography.monoBody)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.textSelection(.enabled)
|
|
}
|
|
.frame(maxHeight: 140)
|
|
|
|
Divider()
|
|
|
|
Text("File Open Timing")
|
|
.font(.subheadline.weight(.semibold))
|
|
if events.isEmpty {
|
|
Text("No recent file-open snapshots yet.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
} else {
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
ForEach(events) { event in
|
|
HStack(spacing: 8) {
|
|
Text(event.timestamp.formatted(date: .omitted, time: .shortened))
|
|
.font(.caption.monospacedDigit())
|
|
.foregroundStyle(.secondary)
|
|
Text("\(event.elapsedMilliseconds) ms")
|
|
.font(.caption.monospacedDigit())
|
|
Text(event.success ? "ok" : "fail")
|
|
.font(.caption.weight(.semibold))
|
|
.foregroundStyle(event.success ? .green : .red)
|
|
if let bytes = event.byteCount {
|
|
Text("\(bytes) bytes")
|
|
.font(.caption.monospacedDigit())
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
HStack(spacing: UI.space10) {
|
|
Button("Copy Diagnostics") {
|
|
copyDiagnosticsToClipboard()
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
Button("Clear Diagnostics") {
|
|
appUpdateManager.resetDiagnostics()
|
|
EditorPerformanceMonitor.shared.clearRecentFileOpenEvents()
|
|
diagnosticsCopyStatus = "Cleared"
|
|
}
|
|
if !diagnosticsCopyStatus.isEmpty {
|
|
Text(diagnosticsCopyStatus)
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private var diagnosticsExportText: String {
|
|
let events = EditorPerformanceMonitor.shared.recentFileOpenEvents(limit: 12)
|
|
var lines: [String] = []
|
|
lines.append("Neon Vision Editor Diagnostics")
|
|
lines.append("Timestamp: \(Date().formatted(date: .abbreviated, time: .shortened))")
|
|
lines.append("Updater.lastCheckResult: \(AppUpdateManager.sanitizedDiagnosticSummary(appUpdateManager.lastCheckResultSummary))")
|
|
lines.append("Updater.lastCheckedAt: \(appUpdateManager.lastCheckedAt?.formatted(date: .abbreviated, time: .shortened) ?? "never")")
|
|
lines.append("Updater.stagedVersion: \(appUpdateManager.stagedUpdateVersionSummary)")
|
|
lines.append("Updater.lastInstallAttempt: \(AppUpdateManager.sanitizedDiagnosticSummary(appUpdateManager.lastInstallAttemptSummary))")
|
|
if let pausedUntil = appUpdateManager.pausedUntil, pausedUntil > Date() {
|
|
lines.append("Updater.pauseUntil: \(pausedUntil.formatted(date: .abbreviated, time: .shortened))")
|
|
}
|
|
lines.append("Updater.consecutiveFailures: \(appUpdateManager.consecutiveFailureCount)")
|
|
lines.append("Updater.logSnippet:")
|
|
lines.append(appUpdateManager.recentLogSnippet)
|
|
lines.append("FileOpenEvents.count: \(events.count)")
|
|
for event in events {
|
|
lines.append(
|
|
"- \(event.timestamp.formatted(date: .omitted, time: .shortened)) | \(event.elapsedMilliseconds) ms | \(event.success ? "ok" : "fail") | bytes=\(event.byteCount.map(String.init) ?? "n/a")"
|
|
)
|
|
}
|
|
return lines.joined(separator: "\n")
|
|
}
|
|
|
|
private func copyDiagnosticsToClipboard() {
|
|
let text = diagnosticsExportText
|
|
#if os(macOS)
|
|
NSPasteboard.general.clearContents()
|
|
NSPasteboard.general.setString(text, forType: .string)
|
|
#elseif canImport(UIKit)
|
|
UIPasteboard.general.string = text
|
|
#endif
|
|
diagnosticsCopyStatus = "Copied"
|
|
}
|
|
|
|
#if os(macOS)
|
|
private var updatesTab: some View {
|
|
settingsContainer(maxWidth: 620) {
|
|
settingsSectionHeader(
|
|
icon: "arrow.triangle.2.circlepath.circle",
|
|
title: "Updates",
|
|
subtitle: "Update checks, intervals, and automatic installation behavior."
|
|
)
|
|
GroupBox("GitHub Release Updates") {
|
|
VStack(alignment: .leading, spacing: UI.space12) {
|
|
Toggle("Automatically check for updates", isOn: $autoCheckForUpdates)
|
|
|
|
HStack(alignment: .center, spacing: UI.space12) {
|
|
Text("Check Interval")
|
|
.frame(width: isCompactSettingsLayout ? nil : standardLabelWidth, alignment: .leading)
|
|
Picker("", selection: $updateCheckIntervalRaw) {
|
|
ForEach(AppUpdateCheckInterval.allCases) { interval in
|
|
Text(interval.title).tag(interval.rawValue)
|
|
}
|
|
}
|
|
.pickerStyle(.menu)
|
|
.frame(maxWidth: isCompactSettingsLayout ? .infinity : 220, alignment: .leading)
|
|
}
|
|
.disabled(!autoCheckForUpdates)
|
|
|
|
Toggle("Automatically install updates when available", isOn: $autoDownloadUpdates)
|
|
.disabled(!autoCheckForUpdates)
|
|
|
|
HStack(spacing: UI.space8) {
|
|
Button("Check Now") {
|
|
Task { await appUpdateManager.checkForUpdates(source: .manual) }
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
|
|
if let checkedAt = appUpdateManager.lastCheckedAt {
|
|
Text(localized("Last checked: %@", checkedAt.formatted(date: .abbreviated, time: .shortened)))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
|
|
VStack(alignment: .leading, spacing: UI.space6) {
|
|
Text(localized("Last check result: %@", appUpdateManager.lastCheckResultSummary))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
if let pausedUntil = appUpdateManager.pausedUntil, pausedUntil > Date() {
|
|
Text(localized("Auto-check pause active until %@ (%lld consecutive failures).", pausedUntil.formatted(date: .abbreviated, time: .shortened), appUpdateManager.consecutiveFailureCount))
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.orange)
|
|
}
|
|
}
|
|
|
|
Text("Uses GitHub release assets only. App Store Connect releases are not used by this updater.")
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.padding(UI.groupPadding)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
}
|
|
#endif
|
|
|
|
private var dataDisclosureDialog: some View {
|
|
NavigationStack {
|
|
ScrollView {
|
|
VStack(alignment: .leading, spacing: UI.space16) {
|
|
Text("Data Disclosure")
|
|
.font(.title3.weight(.semibold))
|
|
|
|
Text("The application does not collect analytics data, usage telemetry, advertising identifiers, device fingerprints, or background behavioral metrics. No automatic data transmission to developer-controlled servers occurs.")
|
|
Text("AI-assisted code completion is an optional feature. External network communication only occurs when a user explicitly enables AI completion and selects an external AI provider within the application settings.")
|
|
Text("When AI completion is triggered, the application transmits only the minimal contextual text necessary to generate a completion suggestion. This typically includes the code immediately surrounding the cursor position or the active selection.")
|
|
Text("The application does not automatically transmit full project folders, unrelated files, entire file system contents, contact data, location data, or device-specific identifiers.")
|
|
Text("Authentication credentials (API keys) for external AI providers are stored securely in the system keychain and are transmitted only to the user-selected provider for the purpose of completing the AI request.")
|
|
Text("All external communication is performed over encrypted HTTPS connections. If AI completion is disabled, the application performs no external AI-related network requests.")
|
|
|
|
HStack {
|
|
Spacer()
|
|
Button("Close") {
|
|
showDataDisclosureDialog = false
|
|
}
|
|
.buttonStyle(.bordered)
|
|
}
|
|
.padding(.top, UI.space8)
|
|
}
|
|
.font(Typography.footnote)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(UI.space20)
|
|
}
|
|
.navigationTitle("AI Data Disclosure")
|
|
#if os(iOS)
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
#endif
|
|
}
|
|
}
|
|
|
|
private func settingsSectionHeader(icon: String, title: LocalizedStringKey, subtitle: LocalizedStringKey) -> some View {
|
|
#if os(iOS)
|
|
Group {
|
|
if isIPadRegularSettingsLayout {
|
|
HStack(alignment: .top, spacing: UI.space12) {
|
|
Image(systemName: icon)
|
|
.font(.title3.weight(.semibold))
|
|
.foregroundStyle(.secondary)
|
|
.frame(width: 34, height: 34, alignment: .center)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 10, style: .continuous)
|
|
.fill(Color.secondary.opacity(0.10))
|
|
)
|
|
.accessibilityHidden(true)
|
|
|
|
VStack(alignment: .leading, spacing: UI.space6) {
|
|
Text(title)
|
|
.font(Typography.sectionTitle)
|
|
.multilineTextAlignment(.leading)
|
|
Text(subtitle)
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
.multilineTextAlignment(.leading)
|
|
}
|
|
Spacer(minLength: 0)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(.top, UI.space6)
|
|
.padding(.bottom, UI.space6)
|
|
} else {
|
|
HStack(alignment: .top, spacing: UI.space12) {
|
|
Image(systemName: icon)
|
|
.font(.title3.weight(.semibold))
|
|
.foregroundStyle(.secondary)
|
|
.frame(width: 36, height: 36, alignment: .center)
|
|
.accessibilityHidden(true)
|
|
|
|
VStack(alignment: .leading, spacing: UI.space6) {
|
|
Text(title)
|
|
.font(Typography.sectionTitle)
|
|
.multilineTextAlignment(.leading)
|
|
Text(subtitle)
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
.multilineTextAlignment(.leading)
|
|
}
|
|
Spacer(minLength: 0)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.padding(.top, UI.mobileHeaderTopPadding)
|
|
.padding(.bottom, UI.space6)
|
|
}
|
|
}
|
|
#else
|
|
HStack(alignment: .top, spacing: UI.space12) {
|
|
ZStack {
|
|
RoundedRectangle(cornerRadius: UI.macHeaderBadgeCorner, style: .continuous)
|
|
.fill(Color.accentColor.opacity(0.10))
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: UI.macHeaderBadgeCorner, style: .continuous)
|
|
.stroke(Color.accentColor.opacity(0.20), lineWidth: 1)
|
|
)
|
|
Image(systemName: icon)
|
|
.font(.headline.weight(.semibold))
|
|
.foregroundStyle(Color.accentColor)
|
|
}
|
|
.frame(width: UI.macHeaderIconSize, height: UI.macHeaderIconSize)
|
|
.accessibilityHidden(true)
|
|
|
|
VStack(alignment: .leading, spacing: UI.space6) {
|
|
Text(title)
|
|
.font(Typography.sectionTitle)
|
|
.multilineTextAlignment(.leading)
|
|
Text(subtitle)
|
|
.font(Typography.footnote)
|
|
.foregroundStyle(.secondary)
|
|
.multilineTextAlignment(.leading)
|
|
}
|
|
Spacer(minLength: 0)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.overlay(alignment: .bottom) {
|
|
Divider().opacity(0.45)
|
|
}
|
|
.padding(.bottom, UI.space6)
|
|
#endif
|
|
}
|
|
|
|
private func settingsContainer<Content: View>(maxWidth: CGFloat = 560, @ViewBuilder _ content: () -> Content) -> some View {
|
|
let effectiveMaxWidth = settingsEffectiveMaxWidth(base: maxWidth)
|
|
return ScrollView {
|
|
VStack(alignment: settingsShouldUseLeadingAlignment ? .leading : .center, spacing: settingsVerticalSpacing) {
|
|
content()
|
|
}
|
|
.frame(maxWidth: effectiveMaxWidth, alignment: settingsShouldUseLeadingAlignment ? .leading : .center)
|
|
.frame(maxWidth: .infinity, maxHeight: .infinity, alignment: settingsShouldUseLeadingAlignment ? .topLeading : .top)
|
|
.padding(.top, settingsTopPadding)
|
|
.padding(.bottom, settingsBottomPadding)
|
|
.padding(.horizontal, settingsHorizontalPadding)
|
|
#if os(iOS)
|
|
.animation(.easeOut(duration: 0.22), value: settingsActiveTab)
|
|
#endif
|
|
}
|
|
.background(settingsContainerBackground)
|
|
}
|
|
|
|
private var settingsVerticalSpacing: CGFloat {
|
|
#if os(iOS)
|
|
isIPadRegularSettingsLayout ? UI.space16 : UI.space20
|
|
#else
|
|
UI.space20
|
|
#endif
|
|
}
|
|
|
|
private var settingsTopPadding: CGFloat {
|
|
#if os(iOS)
|
|
isIPadRegularSettingsLayout ? UI.space8 : UI.topPadding
|
|
#else
|
|
UI.topPadding
|
|
#endif
|
|
}
|
|
|
|
private var settingsBottomPadding: CGFloat {
|
|
#if os(iOS)
|
|
isIPadRegularSettingsLayout ? UI.space12 : UI.bottomPadding
|
|
#else
|
|
UI.bottomPadding
|
|
#endif
|
|
}
|
|
|
|
private var settingsHorizontalPadding: CGFloat {
|
|
#if os(iOS)
|
|
if isCompactSettingsLayout { return UI.sidePaddingCompact }
|
|
if useTwoColumnSettingsLayout { return 28 }
|
|
return UI.sidePaddingRegular
|
|
#else
|
|
return isCompactSettingsLayout ? UI.sidePaddingCompact : 4
|
|
#endif
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var settingsContainerBackground: some View {
|
|
#if os(macOS)
|
|
Color.clear
|
|
#else
|
|
Color.clear.background(.ultraThinMaterial)
|
|
#endif
|
|
}
|
|
|
|
#if os(macOS)
|
|
@ViewBuilder
|
|
private var settingsWindowBackground: some View {
|
|
if supportsTranslucency && translucentWindow {
|
|
Color.clear
|
|
} else {
|
|
Color(nsColor: .windowBackgroundColor)
|
|
}
|
|
}
|
|
#endif
|
|
|
|
private func settingsEffectiveMaxWidth(base: CGFloat) -> CGFloat {
|
|
#if os(iOS)
|
|
if useTwoColumnSettingsLayout { return max(base, 780) }
|
|
return base
|
|
#else
|
|
return macSettingsContentMaxWidth
|
|
#endif
|
|
}
|
|
|
|
private func settingsCardBackground(cornerRadius: CGFloat) -> some View {
|
|
RoundedRectangle(cornerRadius: cornerRadius, style: .continuous)
|
|
.fill(.regularMaterial)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: cornerRadius, style: .continuous)
|
|
.stroke(Color.secondary.opacity(UI.cardStrokeOpacity), lineWidth: 1)
|
|
)
|
|
}
|
|
|
|
private var effectiveSettingsColorScheme: ColorScheme {
|
|
preferredColorSchemeOverride ?? systemColorScheme
|
|
}
|
|
|
|
private func colorRow(title: String, color: Binding<Color>) -> some View {
|
|
HStack {
|
|
Text(title)
|
|
.frame(width: isCompactSettingsLayout ? nil : standardLabelWidth, alignment: .leading)
|
|
ColorPicker("", selection: color, supportsOpacity: true)
|
|
.labelsHidden()
|
|
Spacer()
|
|
}
|
|
}
|
|
|
|
private func aiKeyRow(title: String, placeholder: String, value: Binding<String>, provider: APITokenKey) -> some View {
|
|
Group {
|
|
if isCompactSettingsLayout {
|
|
VStack(alignment: .leading, spacing: UI.space8) {
|
|
Text(title)
|
|
SecureField(placeholder, text: value)
|
|
.textFieldStyle(.plain)
|
|
.padding(.vertical, UI.space6)
|
|
.padding(.horizontal, UI.space8)
|
|
.background(inputFieldBackground)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: UI.fieldCorner)
|
|
.stroke(Color.secondary.opacity(0.35), lineWidth: 1)
|
|
)
|
|
.cornerRadius(UI.fieldCorner)
|
|
.onChange(of: value.wrappedValue) { _, new in
|
|
SecureTokenStore.setToken(new, for: provider)
|
|
}
|
|
}
|
|
} else {
|
|
HStack(spacing: UI.space12) {
|
|
Text(title)
|
|
.frame(width: standardLabelWidth, alignment: .leading)
|
|
SecureField(placeholder, text: value)
|
|
.textFieldStyle(.plain)
|
|
.padding(.vertical, UI.space6)
|
|
.padding(.horizontal, UI.space8)
|
|
.background(inputFieldBackground)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: UI.fieldCorner)
|
|
.stroke(Color.secondary.opacity(0.35), lineWidth: 1)
|
|
)
|
|
.cornerRadius(UI.fieldCorner)
|
|
.frame(maxWidth: 360)
|
|
.onChange(of: value.wrappedValue) { _, new in
|
|
SecureTokenStore.setToken(new, for: provider)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: isCompactSettingsLayout ? .leading : .center)
|
|
}
|
|
|
|
private func languageLabel(for lang: String) -> String {
|
|
switch lang {
|
|
case "php": return "PHP"
|
|
case "cobol": return "COBOL"
|
|
case "dotenv": return "Dotenv"
|
|
case "proto": return "Proto"
|
|
case "graphql": return "GraphQL"
|
|
case "rst": return "reStructuredText"
|
|
case "nginx": return "Nginx"
|
|
case "objective-c": return "Objective-C"
|
|
case "csharp": return "C#"
|
|
case "c": return "C"
|
|
case "cpp": return "C++"
|
|
case "json": return "JSON"
|
|
case "xml": return "XML"
|
|
case "yaml": return "YAML"
|
|
case "toml": return "TOML"
|
|
case "csv": return "CSV"
|
|
case "ini": return "INI"
|
|
case "sql": return "SQL"
|
|
case "vim": return "Vim"
|
|
case "log": return "Log"
|
|
case "ipynb": return "Jupyter Notebook"
|
|
case "tex": return "TeX"
|
|
case "html": return "HTML"
|
|
case "expressionengine": return "ExpressionEngine"
|
|
case "css": return "CSS"
|
|
case "standard": return "Standard"
|
|
default: return lang.capitalized
|
|
}
|
|
}
|
|
|
|
private var settingsShouldUseLeadingAlignment: Bool {
|
|
#if os(iOS)
|
|
true
|
|
#else
|
|
false
|
|
#endif
|
|
}
|
|
|
|
#if os(macOS)
|
|
private var macSettingsContentMaxWidth: CGFloat {
|
|
switch settingsActiveTab {
|
|
case "themes":
|
|
return 720
|
|
case "editor":
|
|
return 580
|
|
case "templates":
|
|
return 540
|
|
case "general":
|
|
return 540
|
|
case "ai":
|
|
return 580
|
|
case "updates":
|
|
return 520
|
|
case "support":
|
|
return 520
|
|
default:
|
|
return 540
|
|
}
|
|
}
|
|
|
|
private var macSettingsWindowSize: (min: NSSize, ideal: NSSize) {
|
|
// Keep a stable window envelope across tabs to avoid toolbar-tab jump/overflow relayout.
|
|
(NSSize(width: 740, height: 900), NSSize(width: 840, height: 980))
|
|
}
|
|
#endif
|
|
|
|
private func migrateLegacyPinkSettingsIfNeeded() {
|
|
if themeStringHex.uppercased() == "#FF7AD9" {
|
|
themeStringHex = "#4EA4FF"
|
|
}
|
|
}
|
|
|
|
private func templateOverrideKey(for language: String) -> String {
|
|
"TemplateOverride_\(language)"
|
|
}
|
|
|
|
private func templateBinding(for language: String) -> Binding<String> {
|
|
Binding<String>(
|
|
get: { UserDefaults.standard.string(forKey: templateOverrideKey(for: language)) ?? defaultTemplate(for: language) ?? "" },
|
|
set: { newValue in UserDefaults.standard.set(newValue, forKey: templateOverrideKey(for: language)) }
|
|
)
|
|
}
|
|
|
|
private func defaultTemplate(for language: String) -> String? {
|
|
switch language {
|
|
case "swift":
|
|
return "import Foundation\n\n// TODO: Add code here\n"
|
|
case "python":
|
|
return "def main():\n pass\n\n\nif __name__ == \"__main__\":\n main()\n"
|
|
case "javascript":
|
|
return "\"use strict\";\n\nfunction main() {\n // TODO: Add code here\n}\n\nmain();\n"
|
|
case "typescript":
|
|
return "function main(): void {\n // TODO: Add code here\n}\n\nmain();\n"
|
|
case "java":
|
|
return "public class Main {\n public static void main(String[] args) {\n // TODO: Add code here\n }\n}\n"
|
|
case "kotlin":
|
|
return "fun main() {\n // TODO: Add code here\n}\n"
|
|
case "go":
|
|
return "package main\n\nimport \"fmt\"\n\nfunc main() {\n fmt.Println(\"Hello\")\n}\n"
|
|
case "ruby":
|
|
return "def main\n # TODO: Add code here\nend\n\nmain\n"
|
|
case "rust":
|
|
return "fn main() {\n println!(\"Hello\");\n}\n"
|
|
case "c":
|
|
return "#include <stdio.h>\n\nint main(void) {\n printf(\"Hello\\n\");\n return 0;\n}\n"
|
|
case "cpp":
|
|
return "#include <iostream>\n\nint main() {\n std::cout << \"Hello\" << std::endl;\n return 0;\n}\n"
|
|
case "csharp":
|
|
return "using System;\n\nclass Program {\n static void Main() {\n Console.WriteLine(\"Hello\");\n }\n}\n"
|
|
case "objective-c":
|
|
return "#import <Foundation/Foundation.h>\n\nint main(int argc, const char * argv[]) {\n @autoreleasepool {\n NSLog(@\"Hello\");\n }\n return 0;\n}\n"
|
|
case "php":
|
|
return "<?php\n\nfunction main() {\n // TODO: Add code here\n}\n\nmain();\n"
|
|
case "html":
|
|
return "<!doctype html>\n<html>\n<head>\n <meta charset=\"utf-8\" />\n <title>Document</title>\n</head>\n<body>\n\n</body>\n</html>\n"
|
|
case "expressionengine":
|
|
return "{exp:channel:entries channel=\"news\" limit=\"10\"}\n <article>\n <h2>{title}</h2>\n <p>{summary}</p>\n </article>\n{/exp:channel:entries}\n"
|
|
case "css":
|
|
return "body {\n margin: 0;\n font-family: system-ui, sans-serif;\n}\n"
|
|
case "json":
|
|
return "{\n \"key\": \"value\"\n}\n"
|
|
case "yaml":
|
|
return "key: value\n"
|
|
case "toml":
|
|
return "key = \"value\"\n"
|
|
case "sql":
|
|
return "SELECT *\nFROM table_name;\n"
|
|
case "bash", "zsh":
|
|
return "#!/usr/bin/env \(language)\n\n"
|
|
case "markdown":
|
|
return "# Title\n\n"
|
|
case "tex":
|
|
return "\\documentclass{article}\n\\usepackage[utf8]{inputenc}\n\n\\begin{document}\n\\section{Title}\n\n\n\\end{document}\n"
|
|
case "plain":
|
|
return ""
|
|
default:
|
|
return "TODO\n"
|
|
}
|
|
}
|
|
|
|
private func hexBinding(_ hex: Binding<String>, fallback: Color) -> Binding<Color> {
|
|
Binding<Color>(
|
|
get: { colorFromHex(hex.wrappedValue, fallback: fallback) },
|
|
set: { newColor in hex.wrappedValue = colorToHex(newColor) }
|
|
)
|
|
}
|
|
|
|
private func themePreviewSnippet(previewTheme: EditorTheme) -> some View {
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
Text("Preview")
|
|
.font(.caption.weight(.semibold))
|
|
.foregroundStyle(.secondary)
|
|
VStack(alignment: .leading, spacing: 3) {
|
|
themePreviewLine(
|
|
"# Release Notes",
|
|
color: previewTheme.syntax.meta,
|
|
weight: previewTheme.boldMarkdownHeadings ? .bold : .regular
|
|
)
|
|
themePreviewLine(
|
|
"[docs](https://example.com/theme-guide)",
|
|
color: previewTheme.syntax.string,
|
|
underline: previewTheme.underlineLinks
|
|
)
|
|
themePreviewLine(
|
|
"func computeTotal(_ values: [Int]) -> Int {",
|
|
color: previewTheme.syntax.keyword,
|
|
weight: previewTheme.boldKeywords ? .bold : .regular
|
|
)
|
|
Text(" let sum = values.reduce(0, +)")
|
|
.foregroundStyle(previewTheme.text)
|
|
themePreviewLine(
|
|
" // tax adjustment",
|
|
color: previewTheme.syntax.comment,
|
|
italic: previewTheme.italicComments
|
|
)
|
|
Text(" return sum + 42")
|
|
.foregroundStyle(previewTheme.syntax.number)
|
|
themePreviewLine(
|
|
"}",
|
|
color: previewTheme.syntax.keyword,
|
|
weight: previewTheme.boldKeywords ? .bold : .regular
|
|
)
|
|
}
|
|
.font(.system(size: 12, weight: .regular, design: .monospaced))
|
|
.padding(UI.space10)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 10, style: .continuous)
|
|
.fill(previewTheme.background)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: 10, style: .continuous)
|
|
.stroke(previewTheme.selection.opacity(0.7), lineWidth: 1)
|
|
)
|
|
)
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private func themePreviewLine(
|
|
_ text: String,
|
|
color: Color,
|
|
weight: Font.Weight = .regular,
|
|
italic: Bool = false,
|
|
underline: Bool = false
|
|
) -> some View {
|
|
let line = Text(text)
|
|
.foregroundStyle(color)
|
|
.font(.system(size: 12, weight: weight, design: .monospaced))
|
|
let formattedLine = italic ? line.italic() : line
|
|
if underline {
|
|
formattedLine.underline()
|
|
} else {
|
|
formattedLine
|
|
}
|
|
}
|
|
}
|
|
|
|
#if os(macOS)
|
|
struct SettingsWindowConfigurator: NSViewRepresentable {
|
|
let minSize: NSSize
|
|
let idealSize: NSSize
|
|
let translucentEnabled: Bool
|
|
let translucencyModeRaw: String
|
|
let appearanceRaw: String
|
|
let effectiveColorScheme: ColorScheme
|
|
|
|
final class Coordinator {
|
|
var didInitialApply = false
|
|
var pendingApply: DispatchWorkItem?
|
|
var lastTranslucentEnabled: Bool?
|
|
var lastTranslucencyModeRaw: String?
|
|
var didConfigureWindowChrome = false
|
|
var observedWindowNumber: Int?
|
|
var didBecomeKeyObserver: NSObjectProtocol?
|
|
var willCloseObserver: NSObjectProtocol?
|
|
|
|
deinit {
|
|
if let observer = didBecomeKeyObserver {
|
|
NotificationCenter.default.removeObserver(observer)
|
|
}
|
|
if let observer = willCloseObserver {
|
|
NotificationCenter.default.removeObserver(observer)
|
|
}
|
|
}
|
|
}
|
|
|
|
func makeCoordinator() -> Coordinator {
|
|
Coordinator()
|
|
}
|
|
|
|
func makeNSView(context: Context) -> NSView {
|
|
let view = NSView(frame: .zero)
|
|
DispatchQueue.main.async {
|
|
scheduleApply(to: view.window, coordinator: context.coordinator)
|
|
}
|
|
return view
|
|
}
|
|
|
|
func updateNSView(_ nsView: NSView, context: Context) {
|
|
scheduleApply(to: nsView.window, coordinator: context.coordinator)
|
|
}
|
|
|
|
private func scheduleApply(to window: NSWindow?, coordinator: Coordinator) {
|
|
coordinator.pendingApply?.cancel()
|
|
if !coordinator.didInitialApply, let window {
|
|
apply(to: window, coordinator: coordinator)
|
|
return
|
|
}
|
|
let work = DispatchWorkItem {
|
|
apply(to: window, coordinator: coordinator)
|
|
}
|
|
coordinator.pendingApply = work
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 0.03, execute: work)
|
|
}
|
|
|
|
private func apply(to window: NSWindow?, coordinator: Coordinator) {
|
|
guard let window else { return }
|
|
ensureObservers(for: window, coordinator: coordinator)
|
|
let isFirstApply = !coordinator.didInitialApply
|
|
coordinator.lastTranslucentEnabled = translucentEnabled
|
|
coordinator.lastTranslucencyModeRaw = translucencyModeRaw
|
|
window.minSize = minSize
|
|
|
|
// Always enforce native macOS Settings toolbar chrome; other window updaters may have changed it.
|
|
window.toolbarStyle = .preference
|
|
window.titleVisibility = .hidden
|
|
window.title = ""
|
|
if isFirstApply {
|
|
let targetWidth = max(minSize.width, idealSize.width)
|
|
let targetHeight = max(minSize.height, idealSize.height)
|
|
if abs(targetWidth - window.frame.size.width) > 1 || abs(targetHeight - window.frame.size.height) > 1 {
|
|
// Apply initial geometry once; avoid frame churn during tab/content updates.
|
|
var frame = window.frame
|
|
let oldHeight = frame.size.height
|
|
frame.size = NSSize(width: targetWidth, height: targetHeight)
|
|
frame.origin.y += oldHeight - targetHeight
|
|
window.setFrame(frame, display: true, animate: false)
|
|
}
|
|
centerSettingsWindow(window)
|
|
}
|
|
|
|
if !coordinator.didConfigureWindowChrome {
|
|
// Keep settings chrome stable for the lifetime of this window.
|
|
window.isOpaque = false
|
|
window.titlebarAppearsTransparent = true
|
|
window.styleMask.insert(.fullSizeContentView)
|
|
if #available(macOS 13.0, *) {
|
|
window.titlebarSeparatorStyle = .none
|
|
}
|
|
coordinator.didConfigureWindowChrome = true
|
|
}
|
|
// Keep a non-clear background to avoid fully transparent titlebar artifacts.
|
|
window.backgroundColor = translucencyEnabledColor(enabled: translucentEnabled, window: window)
|
|
// Some macOS states restore the title from the selected settings tab.
|
|
// Force an empty, hidden title for native Settings appearance.
|
|
window.title = ""
|
|
window.titleVisibility = .hidden
|
|
window.representedURL = nil
|
|
coordinator.didInitialApply = true
|
|
}
|
|
|
|
private func translucencyEnabledColor(enabled: Bool, window: NSWindow) -> NSColor {
|
|
guard enabled else { return NSColor.windowBackgroundColor }
|
|
let isDark: Bool
|
|
switch appearanceRaw {
|
|
case "light":
|
|
isDark = false
|
|
case "dark":
|
|
isDark = true
|
|
default:
|
|
isDark = effectiveColorScheme == .dark
|
|
}
|
|
let whiteLevel: CGFloat
|
|
let alpha: CGFloat
|
|
switch translucencyModeRaw {
|
|
case "subtle":
|
|
whiteLevel = isDark ? 0.18 : 0.90
|
|
alpha = 0.98
|
|
case "vibrant":
|
|
whiteLevel = isDark ? 0.12 : 0.82
|
|
alpha = 0.98
|
|
default:
|
|
whiteLevel = isDark ? 0.15 : 0.86
|
|
alpha = 0.98
|
|
}
|
|
// Keep settings tint almost opaque to avoid "more transparent" appearance.
|
|
return NSColor(calibratedWhite: whiteLevel, alpha: alpha)
|
|
}
|
|
|
|
private func centerSettingsWindow(_ settingsWindow: NSWindow) {
|
|
let referenceWindow = preferredReferenceWindow(excluding: settingsWindow)
|
|
let size = settingsWindow.frame.size
|
|
let referenceFrame = referenceWindow?.frame ?? settingsWindow.frame
|
|
var origin = NSPoint(
|
|
x: round(referenceFrame.midX - size.width / 2),
|
|
y: round(referenceFrame.midY - size.height / 2)
|
|
)
|
|
if let visibleFrame = referenceWindow?.screen?.visibleFrame ?? settingsWindow.screen?.visibleFrame {
|
|
origin.x = min(max(origin.x, visibleFrame.minX), visibleFrame.maxX - size.width)
|
|
origin.y = min(max(origin.y, visibleFrame.minY), visibleFrame.maxY - size.height)
|
|
}
|
|
settingsWindow.setFrameOrigin(origin)
|
|
}
|
|
|
|
private func ensureObservers(for window: NSWindow, coordinator: Coordinator) {
|
|
let windowNumber = window.windowNumber
|
|
if coordinator.observedWindowNumber == windowNumber {
|
|
return
|
|
}
|
|
if let observer = coordinator.didBecomeKeyObserver {
|
|
NotificationCenter.default.removeObserver(observer)
|
|
coordinator.didBecomeKeyObserver = nil
|
|
}
|
|
if let observer = coordinator.willCloseObserver {
|
|
NotificationCenter.default.removeObserver(observer)
|
|
coordinator.willCloseObserver = nil
|
|
}
|
|
coordinator.observedWindowNumber = windowNumber
|
|
|
|
coordinator.didBecomeKeyObserver = NotificationCenter.default.addObserver(
|
|
forName: NSWindow.didBecomeKeyNotification,
|
|
object: window,
|
|
queue: .main
|
|
) { [weak coordinator] _ in
|
|
UserDefaults.standard.set(NeonSettingsView.defaultSettingsTab, forKey: "SettingsActiveTab")
|
|
centerSettingsWindow(window)
|
|
coordinator?.didInitialApply = true
|
|
}
|
|
|
|
coordinator.willCloseObserver = NotificationCenter.default.addObserver(
|
|
forName: NSWindow.willCloseNotification,
|
|
object: window,
|
|
queue: .main
|
|
) { [weak coordinator] _ in
|
|
coordinator?.didInitialApply = false
|
|
}
|
|
}
|
|
|
|
private func preferredReferenceWindow(excluding settingsWindow: NSWindow) -> NSWindow? {
|
|
if let key = NSApp.keyWindow, key !== settingsWindow, key.isVisible {
|
|
return key
|
|
}
|
|
if let main = NSApp.mainWindow, main !== settingsWindow, main.isVisible {
|
|
return main
|
|
}
|
|
return NSApp.windows.first(where: { window in
|
|
window !== settingsWindow && window.isVisible && window.level == .normal
|
|
})
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#if DEBUG && canImport(SwiftUI) && canImport(PreviewsMacros)
|
|
#Preview {
|
|
NeonSettingsView(
|
|
supportsOpenInTabs: true,
|
|
supportsTranslucency: true
|
|
)
|
|
}
|
|
#endif
|