diff --git a/docs/runtime/index.md b/docs/runtime/index.md index e7faf3f4..71614b69 100644 --- a/docs/runtime/index.md +++ b/docs/runtime/index.md @@ -16,6 +16,8 @@ Nucleus provides runtime libraries for use in your application code. All are pub | Notification (Linux) | `io.github.kdroidfilter:nucleus.notification-linux` | Freedesktop Desktop Notifications API via JNI (D-Bus) | | Launcher (Linux) | `io.github.kdroidfilter:nucleus.launcher-linux` | Unity Launcher API — badge, progress, urgency, quicklist via JNI (D-Bus) | | Launcher (macOS) | `io.github.kdroidfilter:nucleus.launcher-macos` | macOS dock context menu — custom items, submenus, click callbacks via JNI | +| Menu (macOS) | `io.github.kdroidfilter:nucleus.menu-macos` | Complete NSMenu mapping — application menu bar, items, badges, delegates, SF Symbols via JNI | +| SF Symbols | `io.github.kdroidfilter:nucleus.sf-symbols` | Type-safe Apple SF Symbols constants (6 195 symbols, 21 categories) | | Freedesktop Icons | `io.github.kdroidfilter:nucleus.freedesktop-icons` | Type-safe freedesktop Icon Naming Specification constants | | Decorated Window | `io.github.kdroidfilter:nucleus.decorated-window` | Custom window decorations with native title bar | | Decorated Window — Jewel | `io.github.kdroidfilter:nucleus.decorated-window-jewel` | Jewel (IntelliJ theme) color mapping for decorated windows | @@ -44,6 +46,8 @@ dependencies { implementation("io.github.kdroidfilter:nucleus.notification-linux:") implementation("io.github.kdroidfilter:nucleus.launcher-linux:") implementation("io.github.kdroidfilter:nucleus.launcher-macos:") + implementation("io.github.kdroidfilter:nucleus.menu-macos:") + implementation("io.github.kdroidfilter:nucleus.sf-symbols:") implementation("io.github.kdroidfilter:nucleus.freedesktop-icons:") implementation("io.github.kdroidfilter:nucleus.decorated-window:") implementation("io.github.kdroidfilter:nucleus.decorated-window-jewel:") diff --git a/docs/runtime/menu-macos.md b/docs/runtime/menu-macos.md new file mode 100644 index 00000000..8dddf33d --- /dev/null +++ b/docs/runtime/menu-macos.md @@ -0,0 +1,496 @@ +# Menu (macOS) + +Declarative, Compose-reactive macOS application menu bar via JNI. Build a fully native menu bar with SF Symbols, keyboard shortcuts, badges, submenus, checkboxes, radio buttons, and more — all driven by Compose state. + +## Installation + +```kotlin +dependencies { + implementation("io.github.kdroidfilter:nucleus.menu-macos:") + implementation("io.github.kdroidfilter:nucleus.sf-symbols:") // optional — type-safe SF Symbol constants +} +``` + +Requires Compose Desktop on the classpath. Depends on `core-runtime` (compile-only) for `NativeLibraryLoader`. The `sf-symbols` module is optional but recommended for type-safe icon references. + +## Quick Start + +```kotlin +import io.github.kdroidfilter.nucleus.menu.macos.* +import io.github.kdroidfilter.nucleus.sfsymbols.* + +@Composable +fun App() { + NativeMenuBar { + Menu("File") { + Item("New", shortcut = NativeKeyShortcut("n"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolObjectsAndTools.DOCUMENT_BADGE_PLUS)) { println("New") } + Item("Open...", shortcut = NativeKeyShortcut("o"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolObjectsAndTools.FOLDER)) { println("Open") } + Separator() + Item("Quit", shortcut = NativeKeyShortcut("q"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolPower.POWER)) { exitProcess(0) } + } + } + // ... your window content +} +``` + +The menu bar is installed when `NativeMenuBar` enters the composition and the original is restored when it leaves. + +--- + +## NativeMenuBar + +```kotlin +@Composable +fun NativeMenuBar(content: @Composable NativeMenuBarScope.() -> Unit) +``` + +Top-level composable that replaces the application menu bar. **Reactive** — any Compose state read inside `content` triggers a rebuild of the native menu bar. + +The **first** `Menu` call produces the application menu (the bold entry whose title is the app name). + +!!! info "App name in the menu bar" + The Nucleus Gradle plugin automatically sets the app name from `appName` (fallback: `packageName`) in the DSL — both for `./gradlew run` (`-Dapple.awt.application.name`) and for packaged `.app` distributions (`CFBundleName` in Info.plist). + +--- + +## Menu + +```kotlin +// Top-level menu (in NativeMenuBarScope) +@Composable +fun Menu(text: String, enabled: Boolean = true, mnemonic: Char? = null, + content: @Composable NativeMenuScope.() -> Unit) + +// Nested submenu (in NativeMenuScope) +@Composable +fun Menu(text: String, enabled: Boolean = true, mnemonic: Char? = null, + icon: NsMenuItemImage? = null, + content: @Composable NativeMenuScope.() -> Unit) +``` + +Can be nested to arbitrary depth: + +```kotlin +Menu("File") { + Menu("Open Recent", icon = NsMenuItemImage.SystemSymbol("clock.arrow.circlepath")) { + Item("project.kt") { } + Item("build.gradle.kts") { } + Separator() + Item("Clear Menu") { } + } +} +``` + +--- + +## Item + +```kotlin +fun Item( + text: String, + enabled: Boolean = true, + shortcut: NativeKeyShortcut? = null, + icon: NsMenuItemImage? = null, + state: NsMenuItemState = NsMenuItemState.OFF, + tag: Int = 0, + badge: NsMenuItemBadge? = null, + subtitle: String? = null, + toolTip: String? = null, + indentationLevel: Int = 0, + isAlternate: Boolean = false, + isHidden: Boolean = false, + onStateImage: NsMenuItemImage? = null, + offStateImage: NsMenuItemImage? = null, + mixedStateImage: NsMenuItemImage? = null, + onClick: () -> Unit = {}, +) +``` + +Full-featured menu item. `onClick` is a trailing lambda: + +```kotlin +Item("Save", shortcut = NativeKeyShortcut("s"), icon = NsMenuItemImage.SystemSymbol("square.and.arrow.down")) { + println("Saved!") +} +``` + +!!! info "Thread safety" + `onClick` callbacks are dispatched on the Swing EDT via `SwingUtilities.invokeLater`. + +### Keyboard Shortcuts + +```kotlin +Item("Save", shortcut = NativeKeyShortcut("s")) { } // ⌘S +Item("Save As...", shortcut = NativeKeyShortcut("s", shift = true)) { } // ⇧⌘S +Item("Find...", shortcut = NativeKeyShortcut("f", option = true)) { } // ⌥⌘F +Item("Full Screen", shortcut = NativeKeyShortcut("f", control = true)) { } // ⌃⌘F +``` + +`NativeKeyShortcut` parameters: + +| Parameter | Modifier | Default | +|---|---|---| +| `command` | ⌘ Command | `true` | +| `shift` | ⇧ Shift | `false` | +| `option` | ⌥ Option | `false` | +| `control` | ⌃ Control | `false` | +| `function` | Fn | `false` | + +For special keys, use `NativeKey` constants: + +```kotlin +Item("Exit", shortcut = NativeKeyShortcut(NativeKey.Escape, command = false)) { } +Item("Help", shortcut = NativeKeyShortcut("?")) { } +``` + +Available constants: `NativeKey.Escape`, `Return`, `Tab`, `Delete`, `Backspace`, `Up`, `Down`, `Left`, `Right`, `F1`–`F12`, `Home`, `End`, `PageUp`, `PageDown`. + +### Images (SF Symbols) + +With the `sf-symbols` module (type-safe): + +```kotlin +import io.github.kdroidfilter.nucleus.sfsymbols.* + +Item("Cut", icon = NsMenuItemImage.SystemSymbol(SFSymbolObjectsAndTools.SCISSORS)) { } +Item("Inbox", icon = NsMenuItemImage.SystemSymbol(SFSymbolGeneral.TRAY_FILL)) { } +Item("Undo", icon = NsMenuItemImage.SystemSymbol(SFSymbolArrows.ARROW_UTURN_BACKWARD)) { } +``` + +With raw strings (no extra dependency): + +```kotlin +Item("Cut", icon = NsMenuItemImage.SystemSymbol("scissors")) { } +``` + +Other image sources: + +```kotlin +Item("Info", icon = NsMenuItemImage.Named("NSActionTemplate")) { } // AppKit named image +Item("Icon", icon = NsMenuItemImage.File("/path/to/icon.png")) { } // file path +``` + +State-specific images: + +```kotlin +Item("Sync", + state = NsMenuItemState.ON, + onStateImage = NsMenuItemImage.SystemSymbol(SFSymbolStatus.CHECKMARK_CIRCLE_FILL), + offStateImage = NsMenuItemImage.SystemSymbol(SFSymbolShapes.CIRCLE), + mixedStateImage = NsMenuItemImage.SystemSymbol(SFSymbolStatus.MINUS_CIRCLE), +) { } +``` + +### Badges (macOS 14+) + +```kotlin +Item("Inbox", badge = NsMenuItemBadge.Count(42)) { } +Item("Updates", badge = NsMenuItemBadge.updates(3)) { } +Item("Alerts", badge = NsMenuItemBadge.alerts(1)) { } +Item("New", badge = NsMenuItemBadge.newItems(7)) { } +Item("Build", badge = NsMenuItemBadge.Text("PASS")) { } +``` + +Predefined types (`alerts`, `updates`, `newItems`) are automatically localized by macOS. Custom string badges must be localized by the caller. + +### Subtitle (macOS 14.4+) + +```kotlin +Item("Main Title", subtitle = "Secondary description text") { } +``` + +### Other Properties + +```kotlin +Item("Disabled", enabled = false) { } +Item("Hidden (shortcut still works)", isHidden = true, shortcut = NativeKeyShortcut("h", shift = true, option = true)) { } +Item("Indented", indentationLevel = 2) { } +Item("With Tooltip", toolTip = "Hover to see this") { } +Item("Tagged", tag = 42) { } +``` + +--- + +## Alternate Items + +Alternate items appear when the user holds Option. They must immediately follow the base item and share the same key equivalent with a different modifier: + +```kotlin +Item("Paste", shortcut = NativeKeyShortcut("v")) { } +Item("Paste and Match Style", + shortcut = NativeKeyShortcut("v", option = true, shift = true), + isAlternate = true, +) { } +``` + +--- + +## CheckboxItem + +Toggles between checked (✓) and unchecked: + +```kotlin +var showToolbar by remember { mutableStateOf(true) } + +CheckboxItem("Show Toolbar", checked = showToolbar, + icon = NsMenuItemImage.SystemSymbol("sidebar.left"), + onCheckedChange = { showToolbar = it }, +) +``` + +Supports all the same optional parameters as `Item` (shortcut, badge, subtitle, etc.) except `state`, `isAlternate`, `isHidden`, and state images. + +--- + +## RadioButtonItem + +Mutually exclusive selection — manage state externally: + +```kotlin +var theme by remember { mutableStateOf("System") } + +RadioButtonItem("System", selected = theme == "System", onClick = { theme = "System" }) +RadioButtonItem("Light", selected = theme == "Light", onClick = { theme = "Light" }) +RadioButtonItem("Dark", selected = theme == "Dark", onClick = { theme = "Dark" }) +``` + +--- + +## Separator + +```kotlin +Separator() +``` + +--- + +## SectionHeader (macOS 14+) + +Non-clickable section label. Falls back to a disabled item on older macOS versions. + +```kotlin +SectionHeader("View Options") +CheckboxItem("Show Toolbar", ...) +CheckboxItem("Show Status Bar", ...) +``` + +--- + +## Conditional Menus + +Because the content is `@Composable`, you can use standard Compose control flow: + +```kotlin +var advanced by remember { mutableStateOf(false) } + +Menu("Advanced") { + CheckboxItem("Enable Advanced", checked = advanced, onCheckedChange = { advanced = it }) + if (advanced) { + Separator() + Menu("Settings") { + Item("Setting 1") { } + Item("Setting 2") { } + } + } +} +``` + +The menu bar rebuilds automatically when `advanced` changes — the "Settings" submenu appears or disappears. + +--- + +## Well-Known Menus + +When the menu bar is installed, submenus with specific titles are automatically registered with macOS: + +| Submenu title | Effect | +|---|---| +| `"Services"` | macOS populates with system services. | +| `"Window"` | macOS adds the window list and "Bring All to Front". | +| `"Help"` | macOS adds the search-in-menus field. | + +Detection is by **exact title**. To opt out, use a different title: + +```kotlin +Menu("Services") { /* macOS fills this */ } // ✓ auto-registered +Menu("App Services") { Item("Custom") { } } // ✗ fully yours +``` + +--- + +## Full Example + +```kotlin +import io.github.kdroidfilter.nucleus.sfsymbols.* + +@Composable +fun App() { + var showToolbar by remember { mutableStateOf(true) } + var theme by remember { mutableStateOf("System") } + var inboxCount by remember { mutableStateOf(42) } + + NativeMenuBar { + Menu("MyApp") { + Item("About MyApp", icon = NsMenuItemImage.SystemSymbol(SFSymbolStatus.INFO_CIRCLE)) { } + Separator() + Item("Settings...", shortcut = NativeKeyShortcut(","), + icon = NsMenuItemImage.SystemSymbol(SFSymbolGeneral.GEARSHAPE)) { } + Separator() + Menu("Services") { } + Separator() + Item("Quit", shortcut = NativeKeyShortcut("q"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolPower.POWER)) { exitProcess(0) } + } + Menu("File") { + Item("New", shortcut = NativeKeyShortcut("n"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolObjectsAndTools.DOCUMENT_BADGE_PLUS)) { } + Item("Open...", shortcut = NativeKeyShortcut("o"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolObjectsAndTools.FOLDER)) { } + Separator() + Item("Save", shortcut = NativeKeyShortcut("s"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolShapes.SQUARE_AND_ARROW_DOWN)) { } + } + Menu("View") { + CheckboxItem("Show Toolbar", checked = showToolbar, + icon = NsMenuItemImage.SystemSymbol(SFSymbolGeneral.SIDEBAR_LEFT), + onCheckedChange = { showToolbar = it }) + Separator() + SectionHeader("Theme") + RadioButtonItem("System", selected = theme == "System", + onClick = { theme = "System" }) + RadioButtonItem("Light", selected = theme == "Light", + onClick = { theme = "Light" }) + RadioButtonItem("Dark", selected = theme == "Dark", + onClick = { theme = "Dark" }) + } + Menu("Badges") { + Item("Inbox", badge = NsMenuItemBadge.Count(inboxCount), + icon = NsMenuItemImage.SystemSymbol(SFSymbolGeneral.TRAY_FILL)) { } + Item("Updates", badge = NsMenuItemBadge.updates(3), + icon = NsMenuItemImage.SystemSymbol(SFSymbolArrows.ARROW_DOWN_CIRCLE)) { } + } + Menu("Window") { } + Menu("Help") { + Item("MyApp Help", shortcut = NativeKeyShortcut("?"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolStatus.QUESTIONMARK_CIRCLE)) { } + } + } + + // Window content... +} +``` + +--- + +## API Reference + +### Composable + +| Function | Scope | Description | +|---|---|---| +| `NativeMenuBar { }` | — | Installs a native menu bar. Restores original on disposal. | + +### NativeMenuBarScope + +| Function | Description | +|---|---| +| `Menu(text, enabled, mnemonic, content)` | Top-level menu. | + +### NativeMenuScope + +| Function | Description | +|---|---| +| `Item(text, ..., onClick)` | Regular item with all NSMenuItem properties. Trailing lambda. | +| `CheckboxItem(text, checked, onCheckedChange, ...)` | Toggle item. | +| `RadioButtonItem(text, selected, onClick, ...)` | Radio selection item. | +| `Separator()` | Separator line. | +| `SectionHeader(title)` | Section header (macOS 14+). | +| `Menu(text, enabled, icon, content)` | Nested submenu. | + +### NativeKeyShortcut + +```kotlin +data class NativeKeyShortcut( + val key: String, + val command: Boolean = true, + val shift: Boolean = false, + val option: Boolean = false, + val control: Boolean = false, + val function: Boolean = false, +) +``` + +### NativeKey + +Special key constants: `Escape`, `Return`, `Tab`, `Delete`, `Backspace`, `Up`, `Down`, `Left`, `Right`, `F1`–`F12`, `Home`, `End`, `PageUp`, `PageDown`. + +### NsMenuItemImage + +| Variant | Description | +|---|---| +| `NsMenuItemImage.SystemSymbol(symbol)` | Type-safe SF Symbol from the `sf-symbols` module (macOS 11+). | +| `NsMenuItemImage.SystemSymbol(name)` | SF Symbol by raw string name (macOS 11+). | +| `NsMenuItemImage.Named(name)` | AppKit named image. | +| `NsMenuItemImage.File(path)` | Image from file path. | + +The `sf-symbols` module provides **6 195** type-safe constants across 21 categories: `SFSymbolArrows`, `SFSymbolMedia`, `SFSymbolObjectsAndTools`, `SFSymbolStatus`, `SFSymbolGeneral`, `SFSymbolDevices`, `SFSymbolShapes`, etc. + +### NsMenuItemBadge + +| Factory | Description | +|---|---| +| `NsMenuItemBadge.Count(n)` | Numeric badge. | +| `NsMenuItemBadge.Text(s)` | Custom string. | +| `NsMenuItemBadge.alerts(n)` | System-localized alerts. | +| `NsMenuItemBadge.updates(n)` | System-localized updates. | +| `NsMenuItemBadge.newItems(n)` | System-localized new items. | + +### NsMenuItemState + +| Value | Description | +|---|---| +| `OFF` | No mark. | +| `ON` | Checkmark (✓). | +| `MIXED` | Dash (—). | + +--- + +## Native Library + +Ships pre-built macOS dylibs (arm64 + x86_64). `NativeMenuBar` is a no-op on non-macOS platforms. + +- `libnucleus_menu_macos.dylib` — linked against `Cocoa.framework` +- Minimum deployment target: macOS 10.13 +- Newer APIs (badges, section headers, subtitles) degrade gracefully on older systems +- All mutations dispatched on the main thread +- Action callbacks routed back to Kotlin via JNI, then to Swing EDT + +## ProGuard + +```proguard +-keep class io.github.kdroidfilter.nucleus.menu.macos.NativeNsMenuBridge { + native ; + static ** on*(...); +} +``` + +## GraalVM + +```json +[ + { + "type": "io.github.kdroidfilter.nucleus.menu.macos.NativeNsMenuBridge", + "methods": [ + { "name": "onMenuItemAction", "parameterTypes": ["long"] }, + { "name": "onMenuWillOpen", "parameterTypes": ["long"] }, + { "name": "onMenuDidClose", "parameterTypes": ["long"] }, + { "name": "onMenuNeedsUpdate", "parameterTypes": ["long"] }, + { "name": "onMenuWillHighlightItem", "parameterTypes": ["long", "long"] }, + { "name": "onNumberOfItemsInMenu", "parameterTypes": ["long"] } + ] + } +] +``` diff --git a/example/build.gradle.kts b/example/build.gradle.kts index 4a925f1e..49b71462 100644 --- a/example/build.gradle.kts +++ b/example/build.gradle.kts @@ -36,6 +36,8 @@ dependencies { implementation(project(":launcher-linux")) implementation(project(":launcher-macos")) implementation(project(":global-hotkey")) + implementation(project(":menu-macos")) + implementation(project(":sf-symbols")) implementation(libs.coroutines.swing) implementation(project(":graalvm-runtime")) implementation(libs.reorderable) @@ -96,7 +98,7 @@ nucleus.application { nativeDistributions { targetFormats(*TargetFormat.entries.toTypedArray()) appResourcesRootDir.set(project.layout.projectDirectory.dir("resources")) - appName = "NucleusDemo" + appName = "Nucleus Demo" packageName = "io.github.kdroidfilter.NucleusDemo" packageVersion = releaseVersion @@ -110,7 +112,7 @@ nucleus.application { // --- Native libs handling --- cleanupNativeLibs = true // Auto cleanup native libraries - enableAotCache = true // Enable AOT compilation cache + enableAotCache = System.getenv("GITHUB_REF") != null // splashImage = "splash.png" // Splash screen image file homepage = "https://github.com/KdroidFilter/NucleusDemo" diff --git a/example/src/main/kotlin/com/example/demo/MacOsMenuScreen.kt b/example/src/main/kotlin/com/example/demo/MacOsMenuScreen.kt new file mode 100644 index 00000000..1ada036b --- /dev/null +++ b/example/src/main/kotlin/com/example/demo/MacOsMenuScreen.kt @@ -0,0 +1,572 @@ +package com.example.demo + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.ExperimentalLayoutApi +import androidx.compose.foundation.layout.FlowRow +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.Button +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.Checkbox +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Slider +import androidx.compose.material3.Surface +import androidx.compose.material3.Switch +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateListOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import io.github.kdroidfilter.nucleus.menu.macos.NativeKeyShortcut +import io.github.kdroidfilter.nucleus.menu.macos.NativeMenuBar +import io.github.kdroidfilter.nucleus.menu.macos.NsMenuItemBadge +import io.github.kdroidfilter.nucleus.menu.macos.NsMenuItemImage +import io.github.kdroidfilter.nucleus.sfsymbols.SFSymbolArrows +import io.github.kdroidfilter.nucleus.sfsymbols.SFSymbolDevices +import io.github.kdroidfilter.nucleus.sfsymbols.SFSymbolGeneral +import io.github.kdroidfilter.nucleus.sfsymbols.SFSymbolMedia +import io.github.kdroidfilter.nucleus.sfsymbols.SFSymbolObjectsAndTools +import io.github.kdroidfilter.nucleus.sfsymbols.SFSymbolPower +import io.github.kdroidfilter.nucleus.sfsymbols.SFSymbolShapes +import io.github.kdroidfilter.nucleus.sfsymbols.SFSymbolStatus +import io.github.kdroidfilter.nucleus.sfsymbols.SFSymbolTextFormatting + +private const val EVENT_LOG_MAX = 40 + +@OptIn(ExperimentalLayoutApi::class) +@Suppress("FunctionNaming", "LongMethod") +@Composable +fun MacOsMenuScreen() { + val events = remember { mutableStateListOf() } + + fun log(msg: String) { + events.add(0, msg) + if (events.size > EVENT_LOG_MAX) events.removeRange(EVENT_LOG_MAX, events.size) + } + + // Reactive state driving the menu bar — changes here recompose the menu bar instantly + var menuBarActive by remember { mutableStateOf(false) } + var showToolbar by remember { mutableStateOf(true) } + var showStatusBar by remember { mutableStateOf(false) } + var showNavigator by remember { mutableStateOf(true) } + var advancedEnabled by remember { mutableStateOf(false) } + var selectedTheme by remember { mutableStateOf("System") } + var inboxCount by remember { mutableStateOf(42) } + var customMenuTitle by remember { mutableStateOf("File") } + var fileMenuItemCount by remember { mutableStateOf(3) } + var showBadgesMenu by remember { mutableStateOf(true) } + + // ── Native Menu Bar (reactive — rebuilds when state changes) ── + if (menuBarActive) { + NativeMenuBar { + // ── App menu ── + Menu("Nucleus Demo") { + Item( + "About Nucleus Demo", + icon = NsMenuItemImage.SystemSymbol(SFSymbolStatus.INFO_CIRCLE), + ) { log("About") } + Separator() + Item( + "Settings...", + shortcut = NativeKeyShortcut(","), + icon = NsMenuItemImage.SystemSymbol(SFSymbolGeneral.GEARSHAPE), + ) { + log("Settings") + } + Separator() + Menu("Services") { /* macOS auto-populates */ } + Separator() + Item("Hide Nucleus Demo", shortcut = NativeKeyShortcut("h")) { log("Hide") } + Item( + "Hide Others", + shortcut = NativeKeyShortcut("h", option = true), + ) { log("Hide Others") } + Item("Show All") { log("Show All") } + Separator() + Item( + "Quit Nucleus Demo", + shortcut = NativeKeyShortcut("q"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolPower.POWER), + ) { + log("Quit") + } + } + + // ── File (title + item count driven by UI controls) ── + Menu(customMenuTitle) { + Item("New", shortcut = NativeKeyShortcut("n"), icon = NsMenuItemImage.SystemSymbol("doc.badge.plus")) { + log("$customMenuTitle > New") + } + if (fileMenuItemCount >= 2) { + Item( + "Open...", + shortcut = NativeKeyShortcut("o"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolObjectsAndTools.FOLDER), + ) { + log("$customMenuTitle > Open") + } + } + if (fileMenuItemCount >= 3) { + Menu("Open Recent", icon = NsMenuItemImage.SystemSymbol("clock.arrow.circlepath")) { + Item( + "project.kt", + icon = NsMenuItemImage.SystemSymbol("doc.text"), + ) { log("$customMenuTitle > Recent > project.kt") } + Item( + "build.gradle.kts", + icon = NsMenuItemImage.SystemSymbol("doc.text"), + ) { log("$customMenuTitle > Recent > build.gradle.kts") } + Separator() + Item( + "Clear Menu", + icon = NsMenuItemImage.SystemSymbol(SFSymbolStatus.XMARK_CIRCLE), + ) { log("$customMenuTitle > Clear Recent") } + } + } + if (fileMenuItemCount >= 4) { + Separator() + Item( + "Save", + shortcut = NativeKeyShortcut("s"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolShapes.SQUARE_AND_ARROW_DOWN), + ) { + log("$customMenuTitle > Save") + } + } + if (fileMenuItemCount >= 5) { + Item( + "Save As...", + shortcut = NativeKeyShortcut("s", shift = true), + icon = NsMenuItemImage.SystemSymbol(SFSymbolShapes.SQUARE_AND_ARROW_DOWN_ON_SQUARE), + ) { log("$customMenuTitle > Save As") } + Separator() + Item( + "Print...", + shortcut = NativeKeyShortcut("p"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolDevices.PRINTER), + ) { + log("$customMenuTitle > Print") + } + } + } + + // ── Edit ── + Menu("Edit") { + Item( + "Undo", + shortcut = NativeKeyShortcut("z"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolArrows.ARROW_UTURN_BACKWARD), + ) { + log("Edit > Undo") + } + Item( + "Redo", + shortcut = NativeKeyShortcut("z", shift = true), + icon = NsMenuItemImage.SystemSymbol(SFSymbolArrows.ARROW_UTURN_FORWARD), + ) { log("Edit > Redo") } + Separator() + Item( + "Cut", + shortcut = NativeKeyShortcut("x"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolObjectsAndTools.SCISSORS), + ) { + log("Edit > Cut") + } + Item("Copy", shortcut = NativeKeyShortcut("c"), icon = NsMenuItemImage.SystemSymbol("doc.on.doc")) { + log("Edit > Copy") + } + Item( + "Paste", + shortcut = NativeKeyShortcut("v"), + icon = NsMenuItemImage.SystemSymbol("doc.on.clipboard"), + ) { + log("Edit > Paste") + } + // Alternate item — shown when Option is held + Item( + "Paste and Match Style", + shortcut = NativeKeyShortcut("v", option = true, shift = true), + isAlternate = true, + ) { log("Edit > Paste & Match Style") } + Item( + "Delete", + icon = NsMenuItemImage.SystemSymbol(SFSymbolGeneral.DELETE_LEFT), + ) { log("Edit > Delete") } + Item("Select All", shortcut = NativeKeyShortcut("a")) { log("Edit > Select All") } + Separator() + Menu("Find", icon = NsMenuItemImage.SystemSymbol(SFSymbolObjectsAndTools.MAGNIFYINGGLASS)) { + Item("Find...", shortcut = NativeKeyShortcut("f")) { log("Edit > Find") } + Item("Find and Replace...", shortcut = NativeKeyShortcut("f", option = true)) { + log("Edit > Find & Replace") + } + Item("Find Next", shortcut = NativeKeyShortcut("g")) { + log("Edit > Find Next") + } + Item( + "Find Previous", + shortcut = NativeKeyShortcut("g", shift = true), + ) { log("Edit > Find Previous") } + } + Menu("Transform", icon = NsMenuItemImage.SystemSymbol(SFSymbolTextFormatting.TEXTFORMAT)) { + Item("Make Uppercase", shortcut = NativeKeyShortcut("u", shift = true)) { log("Edit > Uppercase") } + Item("Make Lowercase") { log("Edit > Lowercase") } + Item("Capitalize") { log("Edit > Capitalize") } + } + } + + // ── View (reactive checkboxes + radio + indentation) ── + Menu("View") { + SectionHeader("Panels") + CheckboxItem( + "Show Toolbar", + checked = showToolbar, + icon = NsMenuItemImage.SystemSymbol(SFSymbolGeneral.SIDEBAR_LEFT), + onCheckedChange = { + showToolbar = it + log("View > Toolbar = $it") + }, + ) + CheckboxItem( + "Show Status Bar", + checked = showStatusBar, + icon = NsMenuItemImage.SystemSymbol("rectangle.bottomhalf.inset.filled"), + onCheckedChange = { + showStatusBar = it + log("View > Status Bar = $it") + }, + ) + CheckboxItem( + "Show Navigator", + checked = showNavigator, + icon = NsMenuItemImage.SystemSymbol(SFSymbolGeneral.SIDEBAR_LEADING), + toolTip = "Toggle the navigator panel", + onCheckedChange = { + showNavigator = it + log("View > Navigator = $it") + }, + ) + + Separator() + SectionHeader("Theme") + RadioButtonItem( + "System", + selected = selectedTheme == "System", + onClick = { + selectedTheme = "System" + log("View > Theme = System") + }, + ) + RadioButtonItem( + "Light", + selected = selectedTheme == "Light", + onClick = { + selectedTheme = "Light" + log("View > Theme = Light") + }, + ) + RadioButtonItem( + "Dark", + selected = selectedTheme == "Dark", + onClick = { + selectedTheme = "Dark" + log("View > Theme = Dark") + }, + ) + + Separator() + SectionHeader("Indentation") + Item( + "Project", + indentationLevel = 0, + icon = NsMenuItemImage.SystemSymbol(SFSymbolObjectsAndTools.FOLDER), + ) { log("View > Project") } + Item("Source Files", indentationLevel = 1, icon = NsMenuItemImage.SystemSymbol("doc.text")) { + log("View > Source") + } + Item("Resources", indentationLevel = 1, icon = NsMenuItemImage.SystemSymbol(SFSymbolMedia.PHOTO)) { + log("View > Resources") + } + Item( + "Tests", + indentationLevel = 2, + icon = NsMenuItemImage.SystemSymbol(SFSymbolStatus.CHECKMARK_CIRCLE), + ) { + log("View > Tests") + } + + Separator() + Item( + "Enter Full Screen", + shortcut = NativeKeyShortcut("f", control = true), + icon = NsMenuItemImage.SystemSymbol(SFSymbolArrows.ARROW_UP_BACKWARD_AND_ARROW_DOWN_FORWARD), + ) { log("View > Full Screen") } + } + + // ── Badges (conditionally shown) ── + if (showBadgesMenu) { + Menu("Badges") { + Item( + "Inbox", + icon = NsMenuItemImage.SystemSymbol(SFSymbolGeneral.TRAY_FILL), + badge = NsMenuItemBadge.Count(inboxCount), + ) { log("Badges > Inbox ($inboxCount)") } + Item( + "Software Update", + icon = NsMenuItemImage.SystemSymbol(SFSymbolArrows.ARROW_DOWN_CIRCLE), + badge = NsMenuItemBadge.updates(3), + ) { log("Badges > Update") } + Item( + "Security Alerts", + icon = NsMenuItemImage.SystemSymbol(SFSymbolStatus.EXCLAMATIONMARK_TRIANGLE), + badge = NsMenuItemBadge.alerts(1), + ) { log("Badges > Alerts") } + Item( + "Downloads", + icon = NsMenuItemImage.SystemSymbol(SFSymbolArrows.ARROW_DOWN_TO_LINE), + badge = NsMenuItemBadge.newItems(7), + ) { log("Badges > Downloads") } + Item( + "Build Status", + icon = NsMenuItemImage.SystemSymbol(SFSymbolObjectsAndTools.HAMMER), + badge = NsMenuItemBadge.Text("PASS"), + ) { log("Badges > Build") } + Separator() + Item("Disabled Entry", enabled = false, icon = NsMenuItemImage.SystemSymbol(SFSymbolGeneral.NOSIGN)) + Item( + "With Subtitle", + icon = NsMenuItemImage.SystemSymbol(SFSymbolTextFormatting.TEXT_ALIGNLEFT), + subtitle = "This is a subtitle (macOS 14.4+)", + ) { log("Badges > Subtitle") } + Item( + "With Tooltip (hover me)", + icon = NsMenuItemImage.SystemSymbol(SFSymbolStatus.QUESTIONMARK_CIRCLE), + toolTip = "Tooltip on hover!", + ) { log("Badges > Tooltip") } + Item( + "Multi-Modifier", + shortcut = NativeKeyShortcut("k", shift = true, option = true), + icon = NsMenuItemImage.SystemSymbol(SFSymbolGeneral.COMMAND), + ) { log("Badges > Multi-Modifier") } + Item( + "Hidden (has shortcut)", + shortcut = NativeKeyShortcut("h", shift = true, option = true), + isHidden = true, + ) { log("Badges > Hidden shortcut triggered") } + } + } + + // ── Advanced (conditional submenu driven by state) ── + Menu("Advanced") { + CheckboxItem( + "Enable Advanced", + checked = advancedEnabled, + onCheckedChange = { + advancedEnabled = it + log("Advanced > Enabled = $it") + }, + ) + if (advancedEnabled) { + Separator() + Menu("Settings") { + Item("Setting 1") { log("Advanced > Setting 1") } + Item("Setting 2") { log("Advanced > Setting 2") } + Item("Setting 3") { log("Advanced > Setting 3") } + } + Item("Reset All", icon = NsMenuItemImage.SystemSymbol(SFSymbolArrows.ARROW_COUNTERCLOCKWISE)) { + log("Advanced > Reset All") + } + } + } + + // ── Window ── + Menu("Window") { + Item("Minimize", shortcut = NativeKeyShortcut("m")) { log("Window > Minimize") } + Item("Zoom") { log("Window > Zoom") } + Separator() + Item("Bring All to Front") { log("Window > Bring All to Front") } + } + + // ── Help ── + Menu("Help") { + Item( + "Nucleus Demo Help", + shortcut = NativeKeyShortcut("?"), + icon = NsMenuItemImage.SystemSymbol(SFSymbolStatus.QUESTIONMARK_CIRCLE), + ) { log("Help") } + Separator() + Item( + "Documentation", + icon = NsMenuItemImage.SystemSymbol(SFSymbolObjectsAndTools.BOOK), + ) { log("Help > Docs") } + Item( + "Release Notes", + icon = NsMenuItemImage.SystemSymbol("doc.plaintext"), + ) { log("Help > Release Notes") } + Item("Report an Issue...", icon = NsMenuItemImage.SystemSymbol(SFSymbolStatus.EXCLAMATIONMARK_BUBBLE)) { + log("Help > Report") + } + } + } + } + + // ── UI ── + Surface(modifier = Modifier.fillMaxSize()) { + Column( + modifier = + Modifier + .fillMaxSize() + .verticalScroll(rememberScrollState()) + .padding(24.dp), + verticalArrangement = Arrangement.spacedBy(16.dp), + ) { + Text("NSMenu — Compose API", style = MaterialTheme.typography.headlineSmall) + + // Controls + MenuCard("Menu Bar") { + Text( + "All controls below modify Compose state that the menu bar reads. " + + "The native menu bar recomposes instantly.", + style = MaterialTheme.typography.bodySmall, + ) + Spacer(Modifier.height(8.dp)) + FlowRow( + horizontalArrangement = Arrangement.spacedBy(8.dp), + verticalArrangement = Arrangement.spacedBy(8.dp), + ) { + Button(onClick = { + menuBarActive = true + log("Menu bar installed") + }, enabled = !menuBarActive) { Text("Install") } + + OutlinedButton(onClick = { + menuBarActive = false + log("Menu bar restored to original") + }, enabled = menuBarActive) { Text("Restore Original") } + } + } + + if (menuBarActive) { + MenuCard("Live Recomposition") { + // Menu title + OutlinedTextField( + value = customMenuTitle, + onValueChange = { customMenuTitle = it }, + label = { Text("Second menu title (try typing)") }, + singleLine = true, + modifier = Modifier.fillMaxWidth(), + ) + Spacer(Modifier.height(8.dp)) + + // Item count slider + Text("Items in \"$customMenuTitle\" menu: $fileMenuItemCount") + Slider( + value = fileMenuItemCount.toFloat(), + onValueChange = { fileMenuItemCount = it.toInt() }, + valueRange = 1f..5f, + steps = 3, + ) + Spacer(Modifier.height(8.dp)) + + // Inbox badge + Text("Inbox badge count: $inboxCount") + Slider( + value = inboxCount.toFloat(), + onValueChange = { inboxCount = it.toInt() }, + valueRange = 0f..99f, + ) + Spacer(Modifier.height(8.dp)) + + // Toggle entire menus + Row(verticalAlignment = Alignment.CenterVertically) { + Checkbox(checked = showBadgesMenu, onCheckedChange = { showBadgesMenu = it }) + Spacer(Modifier.width(4.dp)) + Text("Show Badges menu") + } + + // View checkboxes (also editable from here) + Row(verticalAlignment = Alignment.CenterVertically) { + Checkbox(checked = showToolbar, onCheckedChange = { showToolbar = it }) + Spacer(Modifier.width(4.dp)) + Text("View > Show Toolbar") + } + Row(verticalAlignment = Alignment.CenterVertically) { + Checkbox(checked = showStatusBar, onCheckedChange = { showStatusBar = it }) + Spacer(Modifier.width(4.dp)) + Text("View > Show Status Bar") + } + Row(verticalAlignment = Alignment.CenterVertically) { + Switch(checked = advancedEnabled, onCheckedChange = { advancedEnabled = it }) + Spacer(Modifier.width(8.dp)) + Text("Advanced > Enable (adds Settings submenu)") + } + } + } + + // Event Log + Card( + modifier = Modifier.fillMaxWidth(), + colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainer), + ) { + Column(modifier = Modifier.padding(16.dp)) { + androidx.compose.foundation.layout.Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically, + ) { + Text("Event Log", style = MaterialTheme.typography.titleMedium) + if (events.isNotEmpty()) { + OutlinedButton(onClick = { events.clear() }) { Text("Clear") } + } + } + Spacer(Modifier.height(8.dp)) + if (events.isEmpty()) { + Text("No events yet.", style = MaterialTheme.typography.bodySmall) + } else { + events.forEachIndexed { index, event -> + Text(event, style = MaterialTheme.typography.bodySmall, fontFamily = FontFamily.Monospace) + if (index < events.lastIndex) { + HorizontalDivider(modifier = Modifier.padding(vertical = 2.dp)) + } + } + } + } + } + } + } +} + +@Composable +private fun MenuCard( + title: String, + content: @Composable () -> Unit, +) { + Card( + modifier = Modifier.fillMaxWidth(), + colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceContainer), + ) { + Column(modifier = Modifier.padding(16.dp)) { + Text(title, style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold) + Spacer(Modifier.height(4.dp)) + content() + } + } +} diff --git a/example/src/main/kotlin/com/example/demo/Main.kt b/example/src/main/kotlin/com/example/demo/Main.kt index 9bce32e3..6aa83a7c 100644 --- a/example/src/main/kotlin/com/example/demo/Main.kt +++ b/example/src/main/kotlin/com/example/demo/Main.kt @@ -195,6 +195,9 @@ fun main(args: Array) { add("Launcher") } add("Hotkeys") + if (Platform.Current == Platform.MacOS) { + add("Menu") + } } var selectedTab by remember { mutableStateOf("Nucleus") } @@ -337,6 +340,7 @@ fun main(args: Array) { } } "Hotkeys" -> GlobalHotKeyScreen() + "Menu" -> MacOsMenuScreen() } if (showInfoDialog) { diff --git a/menu-macos/build.gradle.kts b/menu-macos/build.gradle.kts new file mode 100644 index 00000000..243e90c8 --- /dev/null +++ b/menu-macos/build.gradle.kts @@ -0,0 +1,99 @@ +import org.apache.tools.ant.taskdefs.condition.Os +import org.jetbrains.kotlin.gradle.dsl.JvmTarget + +plugins { + kotlin("jvm") + alias(libs.plugins.kotlinComposePlugin) + alias(libs.plugins.jetbrainsCompose) + alias(libs.plugins.vanniktechMavenPublish) +} + +val publishVersion = + providers + .environmentVariable("GITHUB_REF") + .orNull + ?.removePrefix("refs/tags/v") + ?: "1.0.0" + +dependencies { + compileOnly(project(":core-runtime")) + compileOnly(project(":sf-symbols")) + compileOnly(libs.compose.desktop.common) +} + +java { + sourceCompatibility = JavaVersion.VERSION_11 + targetCompatibility = JavaVersion.VERSION_11 +} + +kotlin { + compilerOptions { + jvmTarget.set(JvmTarget.JVM_11) + } +} + +val nativeResourceDir = layout.projectDirectory.dir("src/main/resources/nucleus/native") + +val buildNativeMacOs by tasks.registering(Exec::class) { + description = "Compiles the Objective-C JNI bridge into macOS dylibs (arm64 + x64)" + group = "build" + val hasPrebuilt = + nativeResourceDir + .dir("darwin-aarch64") + .file("libnucleus_menu_macos.dylib") + .asFile + .exists() + enabled = Os.isFamily(Os.FAMILY_MAC) && !hasPrebuilt + + val nativeDir = layout.projectDirectory.dir("src/main/native/macos") + inputs.dir(nativeDir) + outputs.dir(nativeResourceDir) + workingDir(nativeDir) + commandLine("bash", "build.sh") +} + +tasks.processResources { + dependsOn(buildNativeMacOs) +} + +tasks.configureEach { + if (name == "sourcesJar") { + dependsOn(buildNativeMacOs) + } +} + +mavenPublishing { + coordinates("io.github.kdroidfilter", "nucleus.menu-macos", publishVersion) + + pom { + name.set("Nucleus Menu macOS") + description.set("Complete NSMenu / NSMenuItem / NSMenuItemBadge / NSMenuDelegate mapping for JVM desktop applications via JNI") + url.set("https://github.com/kdroidFilter/Nucleus") + + licenses { + license { + name.set("MIT License") + url.set("https://opensource.org/licenses/MIT") + } + } + + developers { + developer { + id.set("kdroidfilter") + name.set("kdroidFilter") + url.set("https://github.com/kdroidFilter") + } + } + + scm { + url.set("https://github.com/kdroidFilter/Nucleus") + connection.set("scm:git:git://github.com/kdroidFilter/Nucleus.git") + developerConnection.set("scm:git:ssh://git@github.com/kdroidFilter/Nucleus.git") + } + } + + publishToMavenCentral() + if (project.hasProperty("signingInMemoryKey")) { + signAllPublications() + } +} diff --git a/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NativeMenuBar.kt b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NativeMenuBar.kt new file mode 100644 index 00000000..3b69e7a1 --- /dev/null +++ b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NativeMenuBar.kt @@ -0,0 +1,447 @@ +package io.github.kdroidfilter.nucleus.menu.macos + +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.SideEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue + +// ─── Public composable ─────────────────────────────────────────────────────── + +/** + * Installs a native macOS application menu bar that reacts to Compose state. + * + * The menu bar is rebuilt whenever a state read inside [content] changes. + * The original menu bar is saved on first composition and restored on disposal. + * + * The **first** [NativeMenuBarScope.Menu] call produces the application menu + * (the bold entry in the menu bar whose title is the app name). + * + * Submenus titled exactly `"Services"`, `"Window"`, or `"Help"` are + * automatically registered with macOS so the system can populate them + * (see module documentation for details). + * + * ```kotlin + * NativeMenuBar { + * Menu("MyApp") { + * Item("About MyApp", icon = NsMenuItemImage.SystemSymbol("info.circle")) { } + * Separator() + * Item("Quit", shortcut = NativeKeyShortcut("q")) { exitProcess(0) } + * } + * Menu("File") { + * Item("New", shortcut = NativeKeyShortcut("n")) { println("New") } + * } + * } + * ``` + * + * @param content Builder lambda executed in [NativeMenuBarScope]. + */ +@Composable +fun NativeMenuBar(content: NativeMenuBarScope.() -> Unit) { + if (!NsMenu.isAvailable) return + + val savedMenu = remember { NsMenu.mainMenu } + var currentMenu by remember { mutableStateOf(null) } + + val scope = NativeMenuBarScope() + scope.content() + + SideEffect { + currentMenu?.close() + NativeNsMenuBridge.clearAllActions() + val menu = materializeMenuBar(scope.entries) + currentMenu = menu + NsMenu.setMainMenu(menu) + } + + DisposableEffect(Unit) { + onDispose { + currentMenu?.close() + NativeNsMenuBridge.clearAllActions() + savedMenu?.let { NsMenu.setMainMenu(it); it.close() } + } + } +} + +// ─── Scopes ────────────────────────────────────────────────────────────────── + +/** Receiver scope for [NativeMenuBar]. Use [Menu] to add top-level menus. */ +class NativeMenuBarScope internal constructor() { + @PublishedApi internal val entries = mutableListOf() + + /** + * Adds a top-level menu to the menu bar. + * + * @param text Title shown in the menu bar. + * @param enabled Whether the menu is clickable. + * @param mnemonic Ignored on macOS (accepted for API compatibility). + * @param content Items inside this menu. + */ + fun Menu( + text: String, + enabled: Boolean = true, + mnemonic: Char? = null, + content: NativeMenuScope.() -> Unit, + ) { + val scope = NativeMenuScope() + scope.content() + entries += MenuBarEntry(text, enabled, scope.entries.toList()) + } +} + +/** + * Receiver scope for menu content. Provides [Item], [CheckboxItem], + * [RadioButtonItem], [Separator], [SectionHeader], and nested [Menu]. + */ +class NativeMenuScope internal constructor() { + @PublishedApi internal val entries = mutableListOf() + + // ── Item ───────────────────────────────────────────────────────────── + + /** + * Adds a regular menu item. + * + * @param text Item title. + * @param enabled Whether the item is clickable. + * @param mnemonic Ignored on macOS. + * @param shortcut Keyboard shortcut (e.g. `NativeKeyShortcut("s")` for ⌘S). + * @param icon Native image (SF Symbol, named image, or file path). + * @param state Checkmark state ([NsMenuItemState.OFF], [NsMenuItemState.ON], [NsMenuItemState.MIXED]). + * @param tag Numeric identifier for programmatic lookup. + * @param badge Badge displayed to the right of the item (macOS 14+). + * @param subtitle Secondary text below the title (macOS 14.4+). + * @param toolTip Tooltip shown on hover. + * @param indentationLevel Visual indentation (0–15). + * @param isAlternate If true, this item is an alternate shown when Option is held. + * Must immediately follow the base item and share the same key equivalent. + * @param isHidden If true, the item is invisible but shortcuts still work. + * @param onStateImage Image shown when state is ON. + * @param offStateImage Image shown when state is OFF. + * @param mixedStateImage Image shown when state is MIXED. + * @param onClick Callback when clicked (dispatched on Swing EDT). Trailing lambda. + */ + fun Item( + text: String, + enabled: Boolean = true, + mnemonic: Char? = null, + shortcut: NativeKeyShortcut? = null, + icon: NsMenuItemImage? = null, + state: NsMenuItemState = NsMenuItemState.OFF, + tag: Int = 0, + badge: NsMenuItemBadge? = null, + subtitle: String? = null, + toolTip: String? = null, + indentationLevel: Int = 0, + isAlternate: Boolean = false, + isHidden: Boolean = false, + onStateImage: NsMenuItemImage? = null, + offStateImage: NsMenuItemImage? = null, + mixedStateImage: NsMenuItemImage? = null, + onClick: () -> Unit = {}, + ) { + entries += MenuItemEntry.Regular( + text = text, + onClick = onClick, + enabled = enabled, + shortcut = shortcut, + icon = icon, + state = state, + tag = tag, + badge = badge, + subtitle = subtitle, + toolTip = toolTip, + indentationLevel = indentationLevel, + isAlternate = isAlternate, + isHidden = isHidden, + onStateImage = onStateImage, + offStateImage = offStateImage, + mixedStateImage = mixedStateImage, + ) + } + + // ── CheckboxItem ───────────────────────────────────────────────────── + + /** + * Adds a menu item that toggles between checked (✓) and unchecked states. + * + * Convenience wrapper around [Item] with automatic [NsMenuItemState] mapping. + */ + fun CheckboxItem( + text: String, + checked: Boolean, + onCheckedChange: (Boolean) -> Unit, + enabled: Boolean = true, + mnemonic: Char? = null, + shortcut: NativeKeyShortcut? = null, + icon: NsMenuItemImage? = null, + tag: Int = 0, + badge: NsMenuItemBadge? = null, + subtitle: String? = null, + toolTip: String? = null, + indentationLevel: Int = 0, + ) { + Item( + text = text, + onClick = { onCheckedChange(!checked) }, + enabled = enabled, + shortcut = shortcut, + icon = icon, + state = if (checked) NsMenuItemState.ON else NsMenuItemState.OFF, + tag = tag, + badge = badge, + subtitle = subtitle, + toolTip = toolTip, + indentationLevel = indentationLevel, + ) + } + + // ── RadioButtonItem ────────────────────────────────────────────────── + + /** + * Adds a menu item that represents a radio selection (● when selected). + * + * Uses [NsMenuItemState.ON] when [selected] and [NsMenuItemState.OFF] otherwise. + * Group your radio items together and manage selection state externally. + */ + fun RadioButtonItem( + text: String, + selected: Boolean, + onClick: () -> Unit, + enabled: Boolean = true, + mnemonic: Char? = null, + shortcut: NativeKeyShortcut? = null, + icon: NsMenuItemImage? = null, + tag: Int = 0, + badge: NsMenuItemBadge? = null, + subtitle: String? = null, + toolTip: String? = null, + indentationLevel: Int = 0, + ) { + Item( + text = text, + onClick = onClick, + enabled = enabled, + shortcut = shortcut, + icon = icon, + state = if (selected) NsMenuItemState.ON else NsMenuItemState.OFF, + tag = tag, + badge = badge, + subtitle = subtitle, + toolTip = toolTip, + indentationLevel = indentationLevel, + ) + } + + // ── Separator ──────────────────────────────────────────────────────── + + /** Adds a horizontal separator line. */ + fun Separator() { + entries += MenuItemEntry.SeparatorEntry + } + + // ── SectionHeader ──────────────────────────────────────────────────── + + /** Adds a non-clickable section header (macOS 14+). Falls back to a disabled item on older systems. */ + fun SectionHeader(title: String) { + entries += MenuItemEntry.SectionHeaderEntry(title) + } + + // ── Nested Menu ────────────────────────────────────────────────────── + + /** + * Adds a submenu. Can be nested to arbitrary depth. + * + * @param text Title of the submenu item. + * @param enabled Whether the submenu is clickable. + * @param icon Native image for the submenu item. + * @param content Items inside this submenu. + */ + fun Menu( + text: String, + enabled: Boolean = true, + mnemonic: Char? = null, + icon: NsMenuItemImage? = null, + content: NativeMenuScope.() -> Unit, + ) { + val scope = NativeMenuScope() + scope.content() + entries += MenuItemEntry.SubmenuEntry(text, enabled, icon, scope.entries.toList()) + } +} + +// ─── Description types (internal) ──────────────────────────────────────────── + +@PublishedApi +internal data class MenuBarEntry( + val text: String, + val enabled: Boolean, + val items: List, +) + +@PublishedApi +internal sealed class MenuItemEntry { + data class Regular( + val text: String, + val onClick: () -> Unit, + val enabled: Boolean, + val shortcut: NativeKeyShortcut?, + val icon: NsMenuItemImage?, + val state: NsMenuItemState, + val tag: Int, + val badge: NsMenuItemBadge?, + val subtitle: String?, + val toolTip: String?, + val indentationLevel: Int, + val isAlternate: Boolean, + val isHidden: Boolean, + val onStateImage: NsMenuItemImage?, + val offStateImage: NsMenuItemImage?, + val mixedStateImage: NsMenuItemImage?, + ) : MenuItemEntry() + + data class SubmenuEntry( + val text: String, + val enabled: Boolean, + val icon: NsMenuItemImage?, + val items: List, + ) : MenuItemEntry() + + object SeparatorEntry : MenuItemEntry() + + data class SectionHeaderEntry(val title: String) : MenuItemEntry() +} + +// ─── Materialization (description → native NSMenu tree) ────────────────────── + +private fun materializeMenuBar(entries: List): NsMenu { + val menuBar = NsMenu("MainMenu") + for (entry in entries) { + val menuItem = NsMenuItem(entry.text) + if (!entry.enabled) menuItem.isEnabled = false + val submenu = NsMenu(entry.text) + submenu.autoenablesItems = false + materializeItems(submenu, entry.items) + menuItem.submenu = submenu + menuBar.addItem(menuItem) + menuItem.close() + submenu.close() + } + return menuBar +} + +private fun materializeItems(menu: NsMenu, entries: List) { + for (entry in entries) { + when (entry) { + is MenuItemEntry.SeparatorEntry -> { + val sep = NsMenuItem.separator() + menu.addItem(sep) + sep.close() + } + is MenuItemEntry.SectionHeaderEntry -> { + val header = NsMenuItem.sectionHeader(entry.title) + menu.addItem(header) + header.close() + } + is MenuItemEntry.SubmenuEntry -> { + val menuItem = NsMenuItem(entry.text) + if (!entry.enabled) menuItem.isEnabled = false + entry.icon?.let { menuItem.image = it } + val submenu = NsMenu(entry.text) + submenu.autoenablesItems = false + materializeItems(submenu, entry.items) + menuItem.submenu = submenu + menu.addItem(menuItem) + menuItem.close() + submenu.close() + } + is MenuItemEntry.Regular -> { + val (keyEq, modMask) = mapShortcut(entry.shortcut) + val item = NsMenuItem(entry.text, keyEquivalent = keyEq) + if (keyEq.isNotEmpty()) item.keyEquivalentModifierMask = modMask + if (!entry.enabled) item.isEnabled = false + if (entry.isHidden) item.isHidden = true + if (entry.isAlternate) item.isAlternate = true + if (entry.state != NsMenuItemState.OFF) item.state = entry.state + if (entry.tag != 0) item.tag = entry.tag + if (entry.indentationLevel > 0) item.indentationLevel = entry.indentationLevel + entry.icon?.let { item.image = it } + entry.badge?.let { item.badge = it } + entry.subtitle?.let { item.subtitle = it } + entry.toolTip?.let { item.toolTip = it } + entry.onStateImage?.let { item.onStateImage = it } + entry.offStateImage?.let { item.offStateImage = it } + entry.mixedStateImage?.let { item.mixedStateImage = it } + item.onAction = entry.onClick + menu.addItem(item) + item.close() + } + } + } +} + +// ─── NativeKeyShortcut ─────────────────────────────────────────────────────── + +/** + * Describes a keyboard shortcut for a native macOS menu item. + * + * @param key The key equivalent character (e.g. `"c"`, `","`, `"?"`, [NativeKey.Escape]). + * @param command Command (⌘) modifier. **Tip:** this is the macOS equivalent of `ctrl` on other platforms. + * @param shift Shift (⇧) modifier. + * @param option Option (⌥) modifier. + * @param control Control (⌃) modifier. Rarely used — prefer [command]. + * @param function Function (Fn) modifier. + */ +data class NativeKeyShortcut( + val key: String, + val command: Boolean = true, + val shift: Boolean = false, + val option: Boolean = false, + val control: Boolean = false, + val function: Boolean = false, +) + +/** Well-known non-printable key equivalent characters for [NativeKeyShortcut]. */ +object NativeKey { + const val Escape: String = "\u001B" + const val Return: String = "\r" + const val Tab: String = "\t" + const val Delete: String = "\u007F" + const val Backspace: String = "\u0008" + const val Up: String = "\uF700" + const val Down: String = "\uF701" + const val Left: String = "\uF702" + const val Right: String = "\uF703" + const val F1: String = "\uF704" + const val F2: String = "\uF705" + const val F3: String = "\uF706" + const val F4: String = "\uF707" + const val F5: String = "\uF708" + const val F6: String = "\uF709" + const val F7: String = "\uF70A" + const val F8: String = "\uF70B" + const val F9: String = "\uF70C" + const val F10: String = "\uF70D" + const val F11: String = "\uF70E" + const val F12: String = "\uF70F" + const val Home: String = "\uF729" + const val End: String = "\uF72B" + const val PageUp: String = "\uF72C" + const val PageDown: String = "\uF72D" +} + +// ─── Shortcut → NSMenu key equivalent mapping ─────────────────────────────── + +private fun mapShortcut(shortcut: NativeKeyShortcut?): Pair { + if (shortcut == null) return "" to 0 + val keyEq = shortcut.key + if (keyEq.isEmpty()) return "" to 0 + var modifiers = 0 + if (shortcut.command) modifiers = modifiers or NsEventModifierFlags.COMMAND + if (shortcut.shift) modifiers = modifiers or NsEventModifierFlags.SHIFT + if (shortcut.option) modifiers = modifiers or NsEventModifierFlags.OPTION + if (shortcut.control) modifiers = modifiers or NsEventModifierFlags.CONTROL + if (shortcut.function) modifiers = modifiers or NsEventModifierFlags.FUNCTION + return keyEq to modifiers +} diff --git a/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NativeNsMenuBridge.kt b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NativeNsMenuBridge.kt new file mode 100644 index 00000000..90a35c9d --- /dev/null +++ b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NativeNsMenuBridge.kt @@ -0,0 +1,204 @@ +package io.github.kdroidfilter.nucleus.menu.macos + +import io.github.kdroidfilter.nucleus.core.runtime.NativeLibraryLoader +import java.util.concurrent.ConcurrentHashMap +import javax.swing.SwingUtilities + +private const val LIBRARY_NAME = "nucleus_menu_macos" + +/** + * Internal JNI bridge for the menu-macos module. + * + * All native handles are `jlong` pointers to retained Objective-C objects. + * Callers must invoke [nativeRelease] when done with a handle. + */ +internal object NativeNsMenuBridge { + private val loaded = NativeLibraryLoader.load(LIBRARY_NAME, NativeNsMenuBridge::class.java) + + val isLoaded: Boolean get() = loaded + + // ---- Action callbacks (handle → callback) ---- + private val actionCallbacks = ConcurrentHashMap Unit>() + + fun setAction(handle: Long, action: (() -> Unit)?) { + if (action != null) { + actionCallbacks[handle] = action + } else { + actionCallbacks.remove(handle) + } + if (isLoaded) nativeItemSetHasAction(handle, action != null) + } + + fun getAction(handle: Long): (() -> Unit)? = actionCallbacks[handle] + + fun removeAction(handle: Long) { + actionCallbacks.remove(handle) + } + + fun clearAllActions() { + actionCallbacks.clear() + } + + @JvmStatic + fun onMenuItemAction(handle: Long) { + val callback = actionCallbacks[handle] ?: return + SwingUtilities.invokeLater { callback() } + } + + // ---- Delegate callbacks (menuHandle → delegate) ---- + internal val delegates = ConcurrentHashMap() + + fun setDelegateMapping(menuHandle: Long, delegate: NsMenuDelegate?) { + if (delegate != null) { + delegates[menuHandle] = delegate + } else { + delegates.remove(menuHandle) + } + } + + fun removeDelegateMapping(menuHandle: Long) { + delegates.remove(menuHandle) + } + + @JvmStatic + fun onMenuWillOpen(menuHandle: Long) { + val delegate = delegates[menuHandle] ?: return + val menu = NsMenu.borrowed(menuHandle) + SwingUtilities.invokeLater { delegate.menuWillOpen(menu) } + } + + @JvmStatic + fun onMenuDidClose(menuHandle: Long) { + val delegate = delegates[menuHandle] ?: return + val menu = NsMenu.borrowed(menuHandle) + SwingUtilities.invokeLater { delegate.menuDidClose(menu) } + } + + @JvmStatic + fun onMenuNeedsUpdate(menuHandle: Long) { + val delegate = delegates[menuHandle] ?: return + val menu = NsMenu.borrowed(menuHandle) + SwingUtilities.invokeLater { delegate.menuNeedsUpdate(menu) } + } + + @JvmStatic + fun onMenuWillHighlightItem(menuHandle: Long, itemHandle: Long) { + val delegate = delegates[menuHandle] ?: return + val menu = NsMenu.borrowed(menuHandle) + val item = if (itemHandle != 0L) NsMenuItem.borrowed(itemHandle) else null + SwingUtilities.invokeLater { delegate.menuWillHighlightItem(menu, item) } + } + + @JvmStatic + fun onNumberOfItemsInMenu(menuHandle: Long): Int { + val delegate = delegates[menuHandle] ?: return -1 + val menu = NsMenu.borrowed(menuHandle) + return delegate.numberOfItemsInMenu(menu) + } + + // ---- Lifecycle ---- + + @JvmStatic external fun nativeCreateMenu(title: String): Long + @JvmStatic external fun nativeCreateItem(title: String, keyEquivalent: String): Long + @JvmStatic external fun nativeCreateSeparatorItem(): Long + @JvmStatic external fun nativeCreateSectionHeader(title: String): Long + @JvmStatic external fun nativeRelease(handle: Long) + + // ---- Menu properties (consolidated by type) ---- + + @JvmStatic external fun nativeMenuGetString(handle: Long, propId: Int): String? + @JvmStatic external fun nativeMenuSetString(handle: Long, propId: Int, value: String) + @JvmStatic external fun nativeMenuGetBool(handle: Long, propId: Int): Boolean + @JvmStatic external fun nativeMenuSetBool(handle: Long, propId: Int, value: Boolean) + @JvmStatic external fun nativeMenuGetInt(handle: Long, propId: Int): Int + @JvmStatic external fun nativeMenuSetInt(handle: Long, propId: Int, value: Int) + @JvmStatic external fun nativeMenuGetFloat(handle: Long, propId: Int): Float + @JvmStatic external fun nativeMenuSetFloat(handle: Long, propId: Int, value: Float) + + // ---- Menu item management ---- + + @JvmStatic external fun nativeMenuAddItem(menuHandle: Long, itemHandle: Long) + @JvmStatic external fun nativeMenuAddItemWithTitle(menuHandle: Long, title: String, keyEquivalent: String): Long + @JvmStatic external fun nativeMenuInsertItem(menuHandle: Long, itemHandle: Long, index: Int) + @JvmStatic external fun nativeMenuInsertItemWithTitle(menuHandle: Long, title: String, keyEquivalent: String, index: Int): Long + @JvmStatic external fun nativeMenuRemoveItem(menuHandle: Long, itemHandle: Long) + @JvmStatic external fun nativeMenuRemoveItemAtIndex(menuHandle: Long, index: Int) + @JvmStatic external fun nativeMenuRemoveAllItems(menuHandle: Long) + @JvmStatic external fun nativeMenuItemChanged(menuHandle: Long, itemHandle: Long) + + // ---- Menu finding ---- + + @JvmStatic external fun nativeMenuItemWithTag(menuHandle: Long, tag: Int): Long + @JvmStatic external fun nativeMenuItemWithTitle(menuHandle: Long, title: String): Long + @JvmStatic external fun nativeMenuItemAtIndex(menuHandle: Long, index: Int): Long + @JvmStatic external fun nativeMenuGetNumberOfItems(menuHandle: Long): Int + @JvmStatic external fun nativeMenuGetItems(menuHandle: Long): LongArray + + // ---- Menu indices ---- + + @JvmStatic external fun nativeMenuIndexOfItem(menuHandle: Long, itemHandle: Long): Int + @JvmStatic external fun nativeMenuIndexOfItemWithTitle(menuHandle: Long, title: String): Int + @JvmStatic external fun nativeMenuIndexOfItemWithTag(menuHandle: Long, tag: Int): Int + @JvmStatic external fun nativeMenuIndexOfItemWithSubmenu(menuHandle: Long, submenuHandle: Long): Int + + // ---- Menu special read-only properties ---- + + @JvmStatic external fun nativeMenuGetSize(menuHandle: Long): FloatArray + @JvmStatic external fun nativeMenuGetHighlightedItem(menuHandle: Long): Long + @JvmStatic external fun nativeMenuGetSupermenu(menuHandle: Long): Long + @JvmStatic external fun nativeMenuGetSelectedItems(menuHandle: Long): LongArray + + // ---- Menu methods ---- + + @JvmStatic external fun nativeMenuUpdate(menuHandle: Long) + @JvmStatic external fun nativeMenuSizeToFit(menuHandle: Long) + @JvmStatic external fun nativeMenuCancelTracking(menuHandle: Long) + @JvmStatic external fun nativeMenuCancelTrackingWithoutAnimation(menuHandle: Long) + @JvmStatic external fun nativeMenuPerformActionForItemAtIndex(menuHandle: Long, index: Int) + @JvmStatic external fun nativeMenuPopUp(menuHandle: Long, itemHandle: Long, x: Float, y: Float): Boolean + + // ---- Menu bar ---- + + @JvmStatic external fun nativeMenuBarIsVisible(): Boolean + @JvmStatic external fun nativeMenuBarSetVisible(visible: Boolean) + @JvmStatic external fun nativeMenuBarGetHeight(): Float + @JvmStatic external fun nativeGetMainMenu(): Long + @JvmStatic external fun nativeSetMainMenu(menuHandle: Long) + + // ---- Menu submenu ---- + + @JvmStatic external fun nativeMenuSetSubmenuForItem(menuHandle: Long, submenuHandle: Long, itemHandle: Long) + + // ---- Menu delegate ---- + + @JvmStatic external fun nativeMenuSetDelegate(menuHandle: Long, enabled: Boolean) + + // ---- Item properties (consolidated by type) ---- + + @JvmStatic external fun nativeItemGetString(handle: Long, propId: Int): String? + @JvmStatic external fun nativeItemSetString(handle: Long, propId: Int, value: String?) + @JvmStatic external fun nativeItemGetBool(handle: Long, propId: Int): Boolean + @JvmStatic external fun nativeItemSetBool(handle: Long, propId: Int, value: Boolean) + @JvmStatic external fun nativeItemGetInt(handle: Long, propId: Int): Int + @JvmStatic external fun nativeItemSetInt(handle: Long, propId: Int, value: Int) + + // ---- Item navigation ---- + + @JvmStatic external fun nativeItemGetSubmenu(handle: Long): Long + @JvmStatic external fun nativeItemSetSubmenu(handle: Long, submenuHandle: Long) + @JvmStatic external fun nativeItemGetParentItem(handle: Long): Long + @JvmStatic external fun nativeItemGetMenu(handle: Long): Long + + // ---- Item image ---- + + @JvmStatic external fun nativeItemSetImage(handle: Long, imageType: Int, value: String?, accessibilityDesc: String?) + @JvmStatic external fun nativeItemSetStateImage(handle: Long, stateTarget: Int, imageType: Int, value: String?, accessibilityDesc: String?) + + // ---- Item badge ---- + + @JvmStatic external fun nativeItemSetBadge(handle: Long, badgeType: Int, count: Int, string: String?) + + // ---- Item action ---- + + @JvmStatic external fun nativeItemSetHasAction(handle: Long, enabled: Boolean) +} diff --git a/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenu.kt b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenu.kt new file mode 100644 index 00000000..81b8e2b2 --- /dev/null +++ b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenu.kt @@ -0,0 +1,270 @@ +package io.github.kdroidfilter.nucleus.menu.macos + +import java.util.concurrent.atomic.AtomicBoolean + +/** + * Kotlin wrapper for AppKit NSMenu. + * + * Each instance holds a retained native handle. Call [close] when done to + * release the native reference. Implements [AutoCloseable] for use with + * Kotlin's `use {}` pattern. + * + * Objects returned by query methods (e.g. [itemAtIndex], [supermenu]) are + * also retained and must be closed independently. + */ +internal class NsMenu internal constructor( + internal val handle: Long, + private val owned: Boolean = true, +) : AutoCloseable { + + private val closed = AtomicBoolean(false) + + /** Creates a new NSMenu with the given title. */ + constructor(title: String = "") : this(NativeNsMenuBridge.nativeCreateMenu(title)) + + override fun close() { + if (owned && closed.compareAndSet(false, true)) { + delegate = null + NativeNsMenuBridge.nativeRelease(handle) + } + } + + // ---- Menu bar (static) ---- + + companion object { + /** Whether the native library is loaded and the module is functional. */ + val isAvailable: Boolean get() = NativeNsMenuBridge.isLoaded + + /** Whether the menu bar is visible and selectable by the user. */ + var isMenuBarVisible: Boolean + get() = NativeNsMenuBridge.nativeMenuBarIsVisible() + set(value) = NativeNsMenuBridge.nativeMenuBarSetVisible(value) + + /** The menu bar height for the main menu in pixels. */ + val menuBarHeight: Float + get() = NativeNsMenuBridge.nativeMenuBarGetHeight() + + /** + * Returns the application's main menu (the menu bar). + * The returned [NsMenu] is a retained reference that must be closed when no longer needed. + * Returns null if no main menu is set. + */ + val mainMenu: NsMenu? + get() { + val h = NativeNsMenuBridge.nativeGetMainMenu() + return if (h != 0L) NsMenu(h) else null + } + + /** + * Sets the application's main menu (the menu bar). + * The menu should contain items, each with a submenu that represents + * a top-level menu (File, Edit, View, etc.). + */ + fun setMainMenu(menu: NsMenu) { + NativeNsMenuBridge.nativeSetMainMenu(menu.handle) + } + + + /** Creates a non-owning wrapper for use in callbacks. */ + internal fun borrowed(handle: Long): NsMenu = NsMenu(handle, owned = false) + } + + // ---- Properties ---- + + var title: String + get() = NativeNsMenuBridge.nativeMenuGetString(handle, MenuStringProp.TITLE) ?: "" + set(value) = NativeNsMenuBridge.nativeMenuSetString(handle, MenuStringProp.TITLE, value) + + var autoenablesItems: Boolean + get() = NativeNsMenuBridge.nativeMenuGetBool(handle, MenuBoolProp.AUTO_ENABLES_ITEMS) + set(value) = NativeNsMenuBridge.nativeMenuSetBool(handle, MenuBoolProp.AUTO_ENABLES_ITEMS, value) + + var minimumWidth: Float + get() = NativeNsMenuBridge.nativeMenuGetFloat(handle, MenuFloatProp.MINIMUM_WIDTH) + set(value) = NativeNsMenuBridge.nativeMenuSetFloat(handle, MenuFloatProp.MINIMUM_WIDTH, value) + + /** The size of the menu in screen coordinates (width, height). */ + val size: Pair + get() { + val arr = NativeNsMenuBridge.nativeMenuGetSize(handle) + return arr[0] to arr[1] + } + + var showsStateColumn: Boolean + get() = NativeNsMenuBridge.nativeMenuGetBool(handle, MenuBoolProp.SHOWS_STATE_COLUMN) + set(value) = NativeNsMenuBridge.nativeMenuSetBool(handle, MenuBoolProp.SHOWS_STATE_COLUMN, value) + + var allowsContextMenuPlugIns: Boolean + get() = NativeNsMenuBridge.nativeMenuGetBool(handle, MenuBoolProp.ALLOWS_CONTEXT_MENU_PLUGINS) + set(value) = NativeNsMenuBridge.nativeMenuSetBool(handle, MenuBoolProp.ALLOWS_CONTEXT_MENU_PLUGINS, value) + + var userInterfaceLayoutDirection: NsUserInterfaceLayoutDirection + get() = NsUserInterfaceLayoutDirection.fromNative( + NativeNsMenuBridge.nativeMenuGetInt(handle, MenuIntProp.LAYOUT_DIRECTION), + ) + set(value) = NativeNsMenuBridge.nativeMenuSetInt(handle, MenuIntProp.LAYOUT_DIRECTION, value.nativeValue) + + /** NSMenuPresentationStyle (macOS 14+). Returns [NsMenuPresentationStyle.REGULAR] on older systems. */ + var presentationStyle: NsMenuPresentationStyle + get() = NsMenuPresentationStyle.fromNative( + NativeNsMenuBridge.nativeMenuGetInt(handle, MenuIntProp.PRESENTATION_STYLE), + ) + set(value) = NativeNsMenuBridge.nativeMenuSetInt(handle, MenuIntProp.PRESENTATION_STYLE, value.nativeValue) + + /** NSMenuSelectionMode (macOS 14+). Returns [NsMenuSelectionMode.AUTOMATIC] on older systems. */ + var selectionMode: NsMenuSelectionMode + get() = NsMenuSelectionMode.fromNative( + NativeNsMenuBridge.nativeMenuGetInt(handle, MenuIntProp.SELECTION_MODE), + ) + set(value) = NativeNsMenuBridge.nativeMenuSetInt(handle, MenuIntProp.SELECTION_MODE, value.nativeValue) + + /** The currently highlighted item, or null. The returned item must be closed. */ + val highlightedItem: NsMenuItem? + get() { + val h = NativeNsMenuBridge.nativeMenuGetHighlightedItem(handle) + return if (h != 0L) NsMenuItem(h) else null + } + + /** The parent menu, or null. The returned menu must be closed. */ + val supermenu: NsMenu? + get() { + val h = NativeNsMenuBridge.nativeMenuGetSupermenu(handle) + return if (h != 0L) NsMenu(h) else null + } + + /** The number of menu items, including separators. */ + val numberOfItems: Int + get() = NativeNsMenuBridge.nativeMenuGetNumberOfItems(handle) + + /** + * All menu items. Each returned [NsMenuItem] is a retained reference + * that must be closed when no longer needed. + */ + val items: List + get() = NativeNsMenuBridge.nativeMenuGetItems(handle).map { NsMenuItem(it) } + + /** + * The currently selected items (macOS 14+). + * Each returned [NsMenuItem] must be closed. + */ + val selectedItems: List + get() = NativeNsMenuBridge.nativeMenuGetSelectedItems(handle).map { NsMenuItem(it) } + + // ---- Adding and removing items ---- + + fun addItem(item: NsMenuItem) { + NativeNsMenuBridge.nativeMenuAddItem(handle, item.handle) + } + + /** Creates a new item, adds it to the end, and returns it. The caller owns the returned handle. */ + fun addItem(title: String, keyEquivalent: String = ""): NsMenuItem { + val h = NativeNsMenuBridge.nativeMenuAddItemWithTitle(handle, title, keyEquivalent) + return NsMenuItem(h) + } + + fun insertItem(item: NsMenuItem, atIndex: Int) { + NativeNsMenuBridge.nativeMenuInsertItem(handle, item.handle, atIndex) + } + + /** Creates a new item, inserts it at [atIndex], and returns it. The caller owns the returned handle. */ + fun insertItem(title: String, keyEquivalent: String = "", atIndex: Int): NsMenuItem { + val h = NativeNsMenuBridge.nativeMenuInsertItemWithTitle(handle, title, keyEquivalent, atIndex) + return NsMenuItem(h) + } + + fun removeItem(item: NsMenuItem) { + NativeNsMenuBridge.nativeMenuRemoveItem(handle, item.handle) + } + + fun removeItemAtIndex(index: Int) { + NativeNsMenuBridge.nativeMenuRemoveItemAtIndex(handle, index) + } + + fun removeAllItems() { + NativeNsMenuBridge.nativeMenuRemoveAllItems(handle) + } + + /** Notifies the menu that the given item has been modified visually. */ + fun itemChanged(item: NsMenuItem) { + NativeNsMenuBridge.nativeMenuItemChanged(handle, item.handle) + } + + // ---- Finding items ---- + + /** Returns the first item with the given tag, or null. The returned item must be closed. */ + fun itemWithTag(tag: Int): NsMenuItem? { + val h = NativeNsMenuBridge.nativeMenuItemWithTag(handle, tag) + return if (h != 0L) NsMenuItem(h) else null + } + + /** Returns the first item with the given title, or null. The returned item must be closed. */ + fun itemWithTitle(title: String): NsMenuItem? { + val h = NativeNsMenuBridge.nativeMenuItemWithTitle(handle, title) + return if (h != 0L) NsMenuItem(h) else null + } + + /** Returns the item at the given index, or null. The returned item must be closed. */ + fun itemAtIndex(index: Int): NsMenuItem? { + val h = NativeNsMenuBridge.nativeMenuItemAtIndex(handle, index) + return if (h != 0L) NsMenuItem(h) else null + } + + // ---- Finding indices ---- + + fun indexOfItem(item: NsMenuItem): Int = + NativeNsMenuBridge.nativeMenuIndexOfItem(handle, item.handle) + + fun indexOfItemWithTitle(title: String): Int = + NativeNsMenuBridge.nativeMenuIndexOfItemWithTitle(handle, title) + + fun indexOfItemWithTag(tag: Int): Int = + NativeNsMenuBridge.nativeMenuIndexOfItemWithTag(handle, tag) + + fun indexOfItemWithSubmenu(submenu: NsMenu): Int = + NativeNsMenuBridge.nativeMenuIndexOfItemWithSubmenu(handle, submenu.handle) + + // ---- Submenu ---- + + /** Assigns [submenu] as the submenu of [item]. Pass null to remove a submenu. */ + fun setSubmenu(submenu: NsMenu?, forItem: NsMenuItem) { + NativeNsMenuBridge.nativeMenuSetSubmenuForItem(handle, submenu?.handle ?: 0L, forItem.handle) + } + + // ---- Methods ---- + + /** Validates and sizes menu items via the NSMenuValidation protocol. */ + fun update() = NativeNsMenuBridge.nativeMenuUpdate(handle) + + /** Resizes the menu to exactly fit its items. */ + fun sizeToFit() = NativeNsMenuBridge.nativeMenuSizeToFit(handle) + + /** Dismisses the menu and ends all menu tracking. */ + fun cancelTracking() = NativeNsMenuBridge.nativeMenuCancelTracking(handle) + + /** Dismisses the menu without animation. */ + fun cancelTrackingWithoutAnimation() = NativeNsMenuBridge.nativeMenuCancelTrackingWithoutAnimation(handle) + + /** Sends the action of the item at the given index to its target. */ + fun performActionForItemAtIndex(index: Int) = + NativeNsMenuBridge.nativeMenuPerformActionForItemAtIndex(handle, index) + + /** + * Pops up the menu at the given screen coordinates. + * + * @param positioningItem Optional item to position at the location, or null for the first item. + * @param atX X coordinate in screen space. + * @param atY Y coordinate in screen space. + * @return true if the user selected an item, false if the menu was dismissed. + */ + fun popUp(positioningItem: NsMenuItem? = null, atX: Float, atY: Float): Boolean = + NativeNsMenuBridge.nativeMenuPopUp(handle, positioningItem?.handle ?: 0L, atX, atY) + + // ---- Delegate ---- + + var delegate: NsMenuDelegate? + get() = NativeNsMenuBridge.delegates[handle] + set(value) { + NativeNsMenuBridge.setDelegateMapping(handle, value) + NativeNsMenuBridge.nativeMenuSetDelegate(handle, value != null) + } +} diff --git a/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenuDelegate.kt b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenuDelegate.kt new file mode 100644 index 00000000..4b2b70ae --- /dev/null +++ b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenuDelegate.kt @@ -0,0 +1,28 @@ +package io.github.kdroidfilter.nucleus.menu.macos + +/** + * Kotlin mapping of NSMenuDelegate. + * + * Implement this interface to receive callbacks about menu lifecycle events. + * All callbacks are dispatched on the JVM thread that the native menu system + * uses (typically the AppKit main thread via JNI). + */ +internal interface NsMenuDelegate { + /** Invoked when the menu is about to be displayed. */ + fun menuWillOpen(menu: NsMenu) {} + + /** Invoked after the menu has been closed. */ + fun menuDidClose(menu: NsMenu) {} + + /** Invoked when the menu needs to update its items before display. */ + fun menuNeedsUpdate(menu: NsMenu) {} + + /** Invoked when a menu item is about to be highlighted. [item] is null when no item is highlighted. */ + fun menuWillHighlightItem(menu: NsMenu, item: NsMenuItem?) {} + + /** + * Return the number of items in a lazily-populated menu. + * Return `-1` to use the existing [NsMenu.items] array instead. + */ + fun numberOfItemsInMenu(menu: NsMenu): Int = -1 +} diff --git a/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenuItem.kt b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenuItem.kt new file mode 100644 index 00000000..8d7e1aea --- /dev/null +++ b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenuItem.kt @@ -0,0 +1,207 @@ +package io.github.kdroidfilter.nucleus.menu.macos + +import java.util.concurrent.atomic.AtomicBoolean + +/** + * Kotlin wrapper for AppKit NSMenuItem. + * + * Each instance holds a retained native handle. Call [close] when done. + * Implements [AutoCloseable] for use with Kotlin's `use {}` pattern. + */ +internal class NsMenuItem internal constructor( + internal val handle: Long, + private val owned: Boolean = true, +) : AutoCloseable { + + private val closed = AtomicBoolean(false) + + /** Creates a new NSMenuItem with the given title and optional key equivalent. */ + constructor(title: String, keyEquivalent: String = "") : this( + NativeNsMenuBridge.nativeCreateItem(title, keyEquivalent), + ) + + override fun close() { + if (owned && closed.compareAndSet(false, true)) { + NativeNsMenuBridge.nativeRelease(handle) + } + } + + companion object { + /** Creates a separator menu item. */ + fun separator(): NsMenuItem = NsMenuItem(NativeNsMenuBridge.nativeCreateSeparatorItem()) + + /** Creates a section header item (macOS 14+). */ + fun sectionHeader(title: String): NsMenuItem = NsMenuItem(NativeNsMenuBridge.nativeCreateSectionHeader(title)) + + /** Creates a non-owning wrapper for use in callbacks. */ + internal fun borrowed(handle: Long): NsMenuItem = NsMenuItem(handle, owned = false) + } + + // ---- String properties ---- + + var title: String + get() = NativeNsMenuBridge.nativeItemGetString(handle, ItemStringProp.TITLE) ?: "" + set(value) = NativeNsMenuBridge.nativeItemSetString(handle, ItemStringProp.TITLE, value) + + var keyEquivalent: String + get() = NativeNsMenuBridge.nativeItemGetString(handle, ItemStringProp.KEY_EQUIVALENT) ?: "" + set(value) = NativeNsMenuBridge.nativeItemSetString(handle, ItemStringProp.KEY_EQUIVALENT, value) + + var toolTip: String? + get() = NativeNsMenuBridge.nativeItemGetString(handle, ItemStringProp.TOOLTIP) + set(value) = NativeNsMenuBridge.nativeItemSetString(handle, ItemStringProp.TOOLTIP, value) + + /** Subtitle text displayed below the title (macOS 14+). */ + var subtitle: String? + get() = NativeNsMenuBridge.nativeItemGetString(handle, ItemStringProp.SUBTITLE) + set(value) = NativeNsMenuBridge.nativeItemSetString(handle, ItemStringProp.SUBTITLE, value) + + // ---- Bool properties ---- + + var isEnabled: Boolean + get() = NativeNsMenuBridge.nativeItemGetBool(handle, ItemBoolProp.ENABLED) + set(value) = NativeNsMenuBridge.nativeItemSetBool(handle, ItemBoolProp.ENABLED, value) + + var isHidden: Boolean + get() = NativeNsMenuBridge.nativeItemGetBool(handle, ItemBoolProp.HIDDEN) + set(value) = NativeNsMenuBridge.nativeItemSetBool(handle, ItemBoolProp.HIDDEN, value) + + val isHiddenOrHasHiddenAncestor: Boolean + get() = NativeNsMenuBridge.nativeItemGetBool(handle, ItemBoolProp.HIDDEN_OR_HAS_HIDDEN_ANCESTOR) + + var isAlternate: Boolean + get() = NativeNsMenuBridge.nativeItemGetBool(handle, ItemBoolProp.ALTERNATE) + set(value) = NativeNsMenuBridge.nativeItemSetBool(handle, ItemBoolProp.ALTERNATE, value) + + val isSeparatorItem: Boolean + get() = NativeNsMenuBridge.nativeItemGetBool(handle, ItemBoolProp.IS_SEPARATOR) + + val isHighlighted: Boolean + get() = NativeNsMenuBridge.nativeItemGetBool(handle, ItemBoolProp.IS_HIGHLIGHTED) + + val hasSubmenu: Boolean + get() = NativeNsMenuBridge.nativeItemGetBool(handle, ItemBoolProp.HAS_SUBMENU) + + /** Whether this item is a section header (macOS 14+). */ + val isSectionHeader: Boolean + get() = NativeNsMenuBridge.nativeItemGetBool(handle, ItemBoolProp.IS_SECTION_HEADER) + + var allowsAutomaticKeyEquivalentLocalization: Boolean + get() = NativeNsMenuBridge.nativeItemGetBool(handle, ItemBoolProp.ALLOWS_KEY_EQ_LOCALIZATION) + set(value) = NativeNsMenuBridge.nativeItemSetBool(handle, ItemBoolProp.ALLOWS_KEY_EQ_LOCALIZATION, value) + + var allowsAutomaticKeyEquivalentMirroring: Boolean + get() = NativeNsMenuBridge.nativeItemGetBool(handle, ItemBoolProp.ALLOWS_KEY_EQ_MIRRORING) + set(value) = NativeNsMenuBridge.nativeItemSetBool(handle, ItemBoolProp.ALLOWS_KEY_EQ_MIRRORING, value) + + var allowsKeyEquivalentWhenHidden: Boolean + get() = NativeNsMenuBridge.nativeItemGetBool(handle, ItemBoolProp.ALLOWS_KEY_EQ_WHEN_HIDDEN) + set(value) = NativeNsMenuBridge.nativeItemSetBool(handle, ItemBoolProp.ALLOWS_KEY_EQ_WHEN_HIDDEN, value) + + // ---- Int properties ---- + + var tag: Int + get() = NativeNsMenuBridge.nativeItemGetInt(handle, ItemIntProp.TAG) + set(value) = NativeNsMenuBridge.nativeItemSetInt(handle, ItemIntProp.TAG, value) + + var state: NsMenuItemState + get() = NsMenuItemState.fromNative(NativeNsMenuBridge.nativeItemGetInt(handle, ItemIntProp.STATE)) + set(value) = NativeNsMenuBridge.nativeItemSetInt(handle, ItemIntProp.STATE, value.nativeValue) + + var indentationLevel: Int + get() = NativeNsMenuBridge.nativeItemGetInt(handle, ItemIntProp.INDENTATION_LEVEL) + set(value) = NativeNsMenuBridge.nativeItemSetInt(handle, ItemIntProp.INDENTATION_LEVEL, value) + + /** Key equivalent modifier mask. Combine values from [NsEventModifierFlags]. */ + var keyEquivalentModifierMask: Int + get() = NativeNsMenuBridge.nativeItemGetInt(handle, ItemIntProp.KEY_EQUIVALENT_MODIFIER_MASK) + set(value) = NativeNsMenuBridge.nativeItemSetInt(handle, ItemIntProp.KEY_EQUIVALENT_MODIFIER_MASK, value) + + // ---- Action callback ---- + + /** Callback invoked when the user clicks this item. Dispatched on the Swing EDT. */ + var onAction: (() -> Unit)? + get() = NativeNsMenuBridge.getAction(handle) + set(value) = NativeNsMenuBridge.setAction(handle, value) + + // ---- Submenu / navigation ---- + + /** The item's submenu. Setting to null removes the submenu. Returned menu must be closed. */ + var submenu: NsMenu? + get() { + val h = NativeNsMenuBridge.nativeItemGetSubmenu(handle) + return if (h != 0L) NsMenu(h) else null + } + set(value) = NativeNsMenuBridge.nativeItemSetSubmenu(handle, value?.handle ?: 0L) + + /** The parent item (if this item is in a submenu). Returned item must be closed. */ + val parentItem: NsMenuItem? + get() { + val h = NativeNsMenuBridge.nativeItemGetParentItem(handle) + return if (h != 0L) NsMenuItem(h) else null + } + + /** The menu that contains this item. Returned menu must be closed. */ + val menu: NsMenu? + get() { + val h = NativeNsMenuBridge.nativeItemGetMenu(handle) + return if (h != 0L) NsMenu(h) else null + } + + // ---- Image ---- + + /** The menu item's image. Set to null to clear. */ + var image: NsMenuItemImage? + @Deprecated("Write-only from Kotlin. Use the setter.", level = DeprecationLevel.HIDDEN) + get() = null + set(value) = setImageNative(value, -1) + + /** Image displayed when state is ON. */ + var onStateImage: NsMenuItemImage? + @Deprecated("Write-only from Kotlin.", level = DeprecationLevel.HIDDEN) + get() = null + set(value) = setImageNative(value, StateImageTarget.ON) + + /** Image displayed when state is OFF. */ + var offStateImage: NsMenuItemImage? + @Deprecated("Write-only from Kotlin.", level = DeprecationLevel.HIDDEN) + get() = null + set(value) = setImageNative(value, StateImageTarget.OFF) + + /** Image displayed when state is MIXED. */ + var mixedStateImage: NsMenuItemImage? + @Deprecated("Write-only from Kotlin.", level = DeprecationLevel.HIDDEN) + get() = null + set(value) = setImageNative(value, StateImageTarget.MIXED) + + private fun setImageNative(image: NsMenuItemImage?, stateTarget: Int) { + val (type, value, desc) = when (image) { + null -> Triple(ImageType.CLEAR, null, null) + is NsMenuItemImage.Named -> Triple(ImageType.NAMED, image.name, null) + is NsMenuItemImage.SystemSymbol -> Triple(ImageType.SYSTEM_SYMBOL, image.name, image.accessibilityDescription) + is NsMenuItemImage.File -> Triple(ImageType.FILE, image.path, null) + } + if (stateTarget < 0) { + NativeNsMenuBridge.nativeItemSetImage(handle, type, value, desc) + } else { + NativeNsMenuBridge.nativeItemSetStateImage(handle, stateTarget, type, value, desc) + } + } + + // ---- Badge (macOS 14+) ---- + + /** The badge displayed on this menu item. Set to null to clear. */ + var badge: NsMenuItemBadge? + @Deprecated("Write-only from Kotlin.", level = DeprecationLevel.HIDDEN) + get() = null + set(value) { + when (value) { + null -> NativeNsMenuBridge.nativeItemSetBadge(handle, BadgeType.CLEAR, 0, null) + is NsMenuItemBadge.Count -> NativeNsMenuBridge.nativeItemSetBadge(handle, BadgeType.COUNT, value.count, null) + is NsMenuItemBadge.Text -> NativeNsMenuBridge.nativeItemSetBadge(handle, BadgeType.STRING, 0, value.string) + is NsMenuItemBadge.Alerts -> NativeNsMenuBridge.nativeItemSetBadge(handle, BadgeType.ALERTS, value.count, null) + is NsMenuItemBadge.NewItems -> NativeNsMenuBridge.nativeItemSetBadge(handle, BadgeType.NEW_ITEMS, value.count, null) + is NsMenuItemBadge.Updates -> NativeNsMenuBridge.nativeItemSetBadge(handle, BadgeType.UPDATES, value.count, null) + } + } +} diff --git a/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenuItemBadge.kt b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenuItemBadge.kt new file mode 100644 index 00000000..4c791a05 --- /dev/null +++ b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenuItemBadge.kt @@ -0,0 +1,31 @@ +package io.github.kdroidfilter.nucleus.menu.macos + +/** + * Represents an NSMenuItemBadge (macOS 14+). + * + * Badges provide additional quantitative information on menu items. + * Use the factory methods for predefined badge types that the system + * automatically localizes and pluralizes. + */ +sealed class NsMenuItemBadge { + /** Badge displaying a numeric count. */ + data class Count(val count: Int) : NsMenuItemBadge() + + /** Badge displaying a custom string. Must be localized by the caller. */ + data class Text(val string: String) : NsMenuItemBadge() + + /** Alert-style badge with a predefined, system-localized label. */ + data class Alerts(val count: Int) : NsMenuItemBadge() + + /** New-items-style badge with a predefined, system-localized label. */ + data class NewItems(val count: Int) : NsMenuItemBadge() + + /** Updates-style badge with a predefined, system-localized label. */ + data class Updates(val count: Int) : NsMenuItemBadge() + + companion object { + fun alerts(count: Int): NsMenuItemBadge = Alerts(count) + fun newItems(count: Int): NsMenuItemBadge = NewItems(count) + fun updates(count: Int): NsMenuItemBadge = Updates(count) + } +} diff --git a/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenuTypes.kt b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenuTypes.kt new file mode 100644 index 00000000..e8aa02fe --- /dev/null +++ b/menu-macos/src/main/kotlin/io/github/kdroidfilter/nucleus/menu/macos/NsMenuTypes.kt @@ -0,0 +1,183 @@ +package io.github.kdroidfilter.nucleus.menu.macos + +/** NSControlStateValue used by NSMenuItem.state. */ +enum class NsMenuItemState(val nativeValue: Int) { + OFF(0), + ON(1), + MIXED(-1), + ; + + companion object { + fun fromNative(value: Int): NsMenuItemState = entries.firstOrNull { it.nativeValue == value } ?: OFF + } +} + +/** NSEventModifierFlags bitmask constants for key equivalent modifiers. */ +internal object NsEventModifierFlags { + const val CAPS_LOCK: Int = 1 shl 16 + const val SHIFT: Int = 1 shl 17 + const val CONTROL: Int = 1 shl 18 + const val OPTION: Int = 1 shl 19 + const val COMMAND: Int = 1 shl 20 + const val FUNCTION: Int = 1 shl 23 +} + +/** NSUserInterfaceLayoutDirection. */ +internal enum class NsUserInterfaceLayoutDirection(val nativeValue: Int) { + LEFT_TO_RIGHT(0), + RIGHT_TO_LEFT(1), + ; + + companion object { + fun fromNative(value: Int): NsUserInterfaceLayoutDirection = + entries.firstOrNull { it.nativeValue == value } ?: LEFT_TO_RIGHT + } +} + +/** NSMenuPresentationStyle (macOS 14+). */ +internal enum class NsMenuPresentationStyle(val nativeValue: Int) { + REGULAR(0), + PALETTE(1), + ; + + companion object { + fun fromNative(value: Int): NsMenuPresentationStyle = + entries.firstOrNull { it.nativeValue == value } ?: REGULAR + } +} + +/** NSMenuSelectionMode (macOS 14+). */ +internal enum class NsMenuSelectionMode(val nativeValue: Int) { + AUTOMATIC(0), + SELECT_ANY(1), + SELECT_ONE(2), + ; + + companion object { + fun fromNative(value: Int): NsMenuSelectionMode = + entries.firstOrNull { it.nativeValue == value } ?: AUTOMATIC + } +} + +/** NSMenuItemBadgeType (macOS 14+). */ +internal enum class NsMenuItemBadgeType(val nativeValue: Int) { + NONE(0), + UPDATES(1), + NEW_ITEMS(2), + ALERTS(3), + ; + + companion object { + fun fromNative(value: Int): NsMenuItemBadgeType = + entries.firstOrNull { it.nativeValue == value } ?: NONE + } +} + +/** Image source for NSMenuItem image properties. */ +sealed class NsMenuItemImage { + /** Named image from the app bundle or AppKit constants (e.g. "NSActionTemplate"). */ + data class Named(val name: String) : NsMenuItemImage() + + /** + * SF Symbol image (macOS 11+). + * + * Accepts a raw symbol name string or a type-safe [SFSymbol][io.github.kdroidfilter.nucleus.sfsymbols.SFSymbol] + * constant from the `sf-symbols` module. + * + * ```kotlin + * // With sf-symbols (type-safe): + * NsMenuItemImage.SystemSymbol(SFSymbolObjectsAndTools.SCISSORS) + * + * // With a raw string: + * NsMenuItemImage.SystemSymbol("scissors") + * ``` + */ + data class SystemSymbol( + val name: String, + val accessibilityDescription: String? = null, + ) : NsMenuItemImage() { + /** Creates an image from a type-safe [SFSymbol][io.github.kdroidfilter.nucleus.sfsymbols.SFSymbol] constant. */ + constructor( + symbol: io.github.kdroidfilter.nucleus.sfsymbols.SFSymbol, + accessibilityDescription: String? = null, + ) : this(symbol.symbolName, accessibilityDescription) + } + + /** Image loaded from a file path. */ + data class File(val path: String) : NsMenuItemImage() +} + +// Property ID constants used internally between Kotlin and native code. + +internal object MenuStringProp { + const val TITLE = 1 +} + +internal object MenuBoolProp { + const val AUTO_ENABLES_ITEMS = 1 + const val SHOWS_STATE_COLUMN = 2 + const val ALLOWS_CONTEXT_MENU_PLUGINS = 3 +} + +internal object MenuIntProp { + const val PRESENTATION_STYLE = 1 + const val SELECTION_MODE = 2 + const val LAYOUT_DIRECTION = 3 +} + +internal object MenuFloatProp { + const val MINIMUM_WIDTH = 1 +} + +internal object ItemStringProp { + const val TITLE = 1 + const val KEY_EQUIVALENT = 2 + const val TOOLTIP = 3 + const val SUBTITLE = 4 +} + +internal object ItemBoolProp { + const val ENABLED = 1 + const val HIDDEN = 2 + const val ALTERNATE = 3 + const val HIDDEN_OR_HAS_HIDDEN_ANCESTOR = 4 + const val IS_SEPARATOR = 5 + const val IS_HIGHLIGHTED = 6 + const val HAS_SUBMENU = 7 + const val IS_SECTION_HEADER = 8 + const val ALLOWS_KEY_EQ_LOCALIZATION = 9 + const val ALLOWS_KEY_EQ_MIRRORING = 10 + const val ALLOWS_KEY_EQ_WHEN_HIDDEN = 11 +} + +internal object ItemIntProp { + const val TAG = 1 + const val STATE = 2 + const val INDENTATION_LEVEL = 3 + const val KEY_EQUIVALENT_MODIFIER_MASK = 4 +} + +// Image type discriminators +internal object ImageType { + const val CLEAR = 0 + const val NAMED = 1 + const val SYSTEM_SYMBOL = 2 + const val FILE = 3 +} + +// State image target discriminators +internal object StateImageTarget { + const val ON = 0 + const val OFF = 1 + const val MIXED = 2 +} + +// Badge type discriminators +internal object BadgeType { + const val CLEAR = 0 + const val COUNT = 1 + const val STRING = 2 + const val ALERTS = 3 + const val NEW_ITEMS = 4 + const val UPDATES = 5 +} diff --git a/menu-macos/src/main/native/macos/build.sh b/menu-macos/src/main/native/macos/build.sh new file mode 100755 index 00000000..a23b1668 --- /dev/null +++ b/menu-macos/src/main/native/macos/build.sh @@ -0,0 +1,59 @@ +#!/bin/bash +# Compiles nucleus_menu_macos.m into per-architecture dylibs (arm64 + x86_64). +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +SRC="$SCRIPT_DIR/nucleus_menu_macos.m" +RESOURCE_DIR="$SCRIPT_DIR/../../resources/nucleus/native" +OUT_DIR_ARM64="$RESOURCE_DIR/darwin-aarch64" +OUT_DIR_X64="$RESOURCE_DIR/darwin-x64" + +if [ -z "${JAVA_HOME:-}" ]; then + JAVA_HOME=$(/usr/libexec/java_home 2>/dev/null || true) +fi +if [ -z "${JAVA_HOME:-}" ]; then + echo "ERROR: JAVA_HOME not set and /usr/libexec/java_home failed." >&2 + exit 1 +fi + +JNI_INCLUDE="$JAVA_HOME/include" +JNI_INCLUDE_DARWIN="$JAVA_HOME/include/darwin" + +if [ ! -d "$JNI_INCLUDE" ]; then + echo "ERROR: JNI headers not found at $JNI_INCLUDE" >&2 + exit 1 +fi + +mkdir -p "$OUT_DIR_ARM64" "$OUT_DIR_X64" + +COMMON_FLAGS=( + -dynamiclib + -I"$JNI_INCLUDE" -I"$JNI_INCLUDE_DARWIN" + -framework Cocoa + -mmacosx-version-min=10.13 + -fobjc-arc + -Oz -flto + -fvisibility=hidden + -Wl,-dead_strip -Wl,-x +) + +LIB_NAME="libnucleus_menu_macos.dylib" + +clang -arch arm64 "${COMMON_FLAGS[@]}" -o "$OUT_DIR_ARM64/$LIB_NAME" "$SRC" +strip -x "$OUT_DIR_ARM64/$LIB_NAME" + +clang -arch x86_64 "${COMMON_FLAGS[@]}" -o "$OUT_DIR_X64/$LIB_NAME" "$SRC" +strip -x "$OUT_DIR_X64/$LIB_NAME" + +echo "Built per-architecture dylibs:" +ls -lh "$OUT_DIR_ARM64/$LIB_NAME" +ls -lh "$OUT_DIR_X64/$LIB_NAME" + +CACHE_BASE="$HOME/Library/Caches/nucleus/native" +for arch in darwin-aarch64 darwin-x64; do + CACHED="$CACHE_BASE/$arch/$LIB_NAME" + if [ -f "$CACHED" ]; then + rm -f "$CACHED" + echo "Cleared cache: $CACHED" + fi +done diff --git a/menu-macos/src/main/native/macos/nucleus_menu_macos.m b/menu-macos/src/main/native/macos/nucleus_menu_macos.m new file mode 100644 index 00000000..4901209a --- /dev/null +++ b/menu-macos/src/main/native/macos/nucleus_menu_macos.m @@ -0,0 +1,1130 @@ +/** + * nucleus_menu_macos.m + * + * Complete JNI bridge for macOS NSMenu / NSMenuItem / NSMenuItemBadge / + * NSMenuDelegate. All handles exchanged with Kotlin are CFBridgingRetain'd + * pointers that must be CFBridgingRelease'd via nativeRelease(). + * + * Frameworks: Cocoa + */ + +#import +#import +#include + +// ============================================================================ +// JNI function name macro +// ============================================================================ + +#define JNI_FN(name) \ + Java_io_github_kdroidfilter_nucleus_menu_macos_NativeNsMenuBridge_##name + +#define BRIDGE_CLASS "io/github/kdroidfilter/nucleus/menu/macos/NativeNsMenuBridge" + +// ============================================================================ +// Handle helpers +// ============================================================================ + +#define HANDLE_TO_OBJ(h, type) ((__bridge type *)(void *)(h)) +#define HANDLE_TO_MENU(h) HANDLE_TO_OBJ(h, NSMenu) +#define HANDLE_TO_ITEM(h) HANDLE_TO_OBJ(h, NSMenuItem) + +static inline jlong retainToHandle(id obj) { + if (obj == nil) return 0; + return (jlong)CFBridgingRetain(obj); +} + +static inline void releaseHandle(jlong handle) { + if (handle != 0) { + CFBridgingRelease((void *)handle); + } +} + +// ============================================================================ +// Property ID constants (must match Kotlin *Prop objects) +// ============================================================================ + +// MenuStringProp +enum { MENU_STR_TITLE = 1 }; + +// MenuBoolProp +enum { + MENU_BOOL_AUTO_ENABLES = 1, + MENU_BOOL_SHOWS_STATE = 2, + MENU_BOOL_ALLOWS_PLUGINS = 3, +}; + +// MenuIntProp +enum { + MENU_INT_PRESENTATION = 1, + MENU_INT_SELECTION = 2, + MENU_INT_LAYOUT_DIR = 3, +}; + +// MenuFloatProp +enum { MENU_FLOAT_MIN_WIDTH = 1 }; + +// ItemStringProp +enum { + ITEM_STR_TITLE = 1, + ITEM_STR_KEY_EQ = 2, + ITEM_STR_TOOLTIP = 3, + ITEM_STR_SUBTITLE = 4, +}; + +// ItemBoolProp +enum { + ITEM_BOOL_ENABLED = 1, + ITEM_BOOL_HIDDEN = 2, + ITEM_BOOL_ALTERNATE = 3, + ITEM_BOOL_HIDDEN_OR_ANCESTOR = 4, + ITEM_BOOL_IS_SEPARATOR = 5, + ITEM_BOOL_IS_HIGHLIGHTED = 6, + ITEM_BOOL_HAS_SUBMENU = 7, + ITEM_BOOL_IS_SECTION_HEADER = 8, + ITEM_BOOL_KEY_EQ_LOCALIZATION = 9, + ITEM_BOOL_KEY_EQ_MIRRORING = 10, + ITEM_BOOL_KEY_EQ_WHEN_HIDDEN = 11, +}; + +// ItemIntProp +enum { + ITEM_INT_TAG = 1, + ITEM_INT_STATE = 2, + ITEM_INT_INDENT = 3, + ITEM_INT_KEY_EQ_MASK = 4, +}; + +// Image types +enum { IMG_CLEAR = 0, IMG_NAMED = 1, IMG_SYMBOL = 2, IMG_FILE = 3 }; + +// State image targets +enum { STATE_IMG_ON = 0, STATE_IMG_OFF = 1, STATE_IMG_MIXED = 2 }; + +// Badge types +enum { + BADGE_CLEAR = 0, + BADGE_COUNT = 1, + BADGE_STRING = 2, + BADGE_ALERTS = 3, + BADGE_NEW_ITEMS = 4, + BADGE_UPDATES = 5, +}; + +// ============================================================================ +// Globals +// ============================================================================ + +static JavaVM *g_jvm = NULL; + +JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) { + (void)reserved; + g_jvm = vm; + return JNI_VERSION_1_8; +} + +// ============================================================================ +// JNI helpers +// ============================================================================ + +static JNIEnv *getEnv(BOOL *didAttach) { + *didAttach = NO; + if (g_jvm == NULL) return NULL; + JNIEnv *env = NULL; + jint st = (*g_jvm)->GetEnv(g_jvm, (void **)&env, JNI_VERSION_1_8); + if (st == JNI_EDETACHED) { + if ((*g_jvm)->AttachCurrentThreadAsDaemon(g_jvm, (void **)&env, NULL) != JNI_OK) + return NULL; + *didAttach = YES; + } else if (st != JNI_OK) { + return NULL; + } + return env; +} + +static void releaseEnv(BOOL didAttach) { + if (didAttach && g_jvm) (*g_jvm)->DetachCurrentThread(g_jvm); +} + +static void clearException(JNIEnv *env) { + if ((*env)->ExceptionCheck(env)) (*env)->ExceptionClear(env); +} + +static NSString *toNSString(JNIEnv *env, jstring jstr) { + if (jstr == NULL) return nil; + const char *utf = (*env)->GetStringUTFChars(env, jstr, NULL); + if (utf == NULL) return nil; + NSString *s = [NSString stringWithUTF8String:utf]; + (*env)->ReleaseStringUTFChars(env, jstr, utf); + return s; +} + +static jstring toJString(JNIEnv *env, NSString *s) { + if (s == nil) return NULL; + return (*env)->NewStringUTF(env, [s UTF8String]); +} + +static void runOnMain(void (^block)(void)) { + if ([NSThread isMainThread]) { + block(); + } else { + dispatch_sync(dispatch_get_main_queue(), block); + } +} + +// ============================================================================ +// Action Target — routes NSMenuItem actions back to Kotlin +// ============================================================================ + +@interface NucleusMenuActionTarget : NSObject ++ (instancetype)shared; +- (void)menuItemAction:(NSMenuItem *)sender; +@end + +@implementation NucleusMenuActionTarget + ++ (instancetype)shared { + static NucleusMenuActionTarget *instance = nil; + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ instance = [[NucleusMenuActionTarget alloc] init]; }); + return instance; +} + +- (void)menuItemAction:(NSMenuItem *)sender { + jlong handle = (jlong)(void *)(__bridge void *)sender; + + BOOL didAttach = NO; + JNIEnv *env = getEnv(&didAttach); + if (env == NULL) return; + + jclass cls = (*env)->FindClass(env, BRIDGE_CLASS); + if (cls) { + jmethodID mid = (*env)->GetStaticMethodID(env, cls, "onMenuItemAction", "(J)V"); + if (mid) (*env)->CallStaticVoidMethod(env, cls, mid, handle); + } + clearException(env); + releaseEnv(didAttach); +} + +@end + +// ============================================================================ +// Delegate Proxy — forwards NSMenuDelegate to Kotlin +// ============================================================================ + +@interface NucleusMenuDelegateProxy : NSObject +@end + +@implementation NucleusMenuDelegateProxy + +static void callDelegateVoid(NSMenu *menu, const char *methodName, const char *sig) { + jlong menuHandle = (jlong)(void *)(__bridge void *)menu; + BOOL didAttach = NO; + JNIEnv *env = getEnv(&didAttach); + if (!env) return; + jclass cls = (*env)->FindClass(env, BRIDGE_CLASS); + if (cls) { + jmethodID mid = (*env)->GetStaticMethodID(env, cls, methodName, sig); + if (mid) (*env)->CallStaticVoidMethod(env, cls, mid, menuHandle); + } + clearException(env); + releaseEnv(didAttach); +} + +- (void)menuWillOpen:(NSMenu *)menu { + callDelegateVoid(menu, "onMenuWillOpen", "(J)V"); +} + +- (void)menuDidClose:(NSMenu *)menu { + callDelegateVoid(menu, "onMenuDidClose", "(J)V"); +} + +- (void)menuNeedsUpdate:(NSMenu *)menu { + callDelegateVoid(menu, "onMenuNeedsUpdate", "(J)V"); +} + +- (void)menu:(NSMenu *)menu willHighlightItem:(NSMenuItem *)item { + jlong menuHandle = (jlong)(void *)(__bridge void *)menu; + jlong itemHandle = item ? (jlong)(void *)(__bridge void *)item : 0; + BOOL didAttach = NO; + JNIEnv *env = getEnv(&didAttach); + if (!env) return; + jclass cls = (*env)->FindClass(env, BRIDGE_CLASS); + if (cls) { + jmethodID mid = (*env)->GetStaticMethodID(env, cls, "onMenuWillHighlightItem", "(JJ)V"); + if (mid) (*env)->CallStaticVoidMethod(env, cls, mid, menuHandle, itemHandle); + } + clearException(env); + releaseEnv(didAttach); +} + +- (NSInteger)numberOfItemsInMenu:(NSMenu *)menu { + jlong menuHandle = (jlong)(void *)(__bridge void *)menu; + BOOL didAttach = NO; + JNIEnv *env = getEnv(&didAttach); + if (!env) return -1; + jint result = -1; + jclass cls = (*env)->FindClass(env, BRIDGE_CLASS); + if (cls) { + jmethodID mid = (*env)->GetStaticMethodID(env, cls, "onNumberOfItemsInMenu", "(J)I"); + if (mid) result = (*env)->CallStaticIntMethod(env, cls, mid, menuHandle); + } + clearException(env); + releaseEnv(didAttach); + return (NSInteger)result; +} + +@end + +// Global proxy storage (one per menu, keyed by menu pointer) +static NSMutableDictionary *g_delegateProxies = nil; + +static void ensureDelegateStorage(void) { + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ + g_delegateProxies = [NSMutableDictionary new]; + }); +} + +// ============================================================================ +// Image helper +// ============================================================================ + +static NSImage *makeImage(JNIEnv *env, jint imageType, jstring jValue, jstring jAccessDesc) { + if (imageType == IMG_CLEAR) return nil; + + NSString *value = toNSString(env, jValue); + if (value == nil) return nil; + + switch (imageType) { + case IMG_NAMED: + return [NSImage imageNamed:value]; + case IMG_SYMBOL: + if (@available(macOS 11.0, *)) { + NSString *desc = toNSString(env, jAccessDesc); + return [NSImage imageWithSystemSymbolName:value accessibilityDescription:desc]; + } + return nil; + case IMG_FILE: + return [[NSImage alloc] initWithContentsOfFile:value]; + default: + return nil; + } +} + +// ============================================================================ +// SECTION: Lifecycle +// ============================================================================ + +JNIEXPORT jlong JNICALL JNI_FN(nativeCreateMenu)(JNIEnv *env, jclass clazz, jstring jTitle) { + (void)clazz; + @autoreleasepool { + NSString *title = toNSString(env, jTitle) ?: @""; + __block jlong result = 0; + runOnMain(^{ + NSMenu *menu = [[NSMenu alloc] initWithTitle:title]; + result = retainToHandle(menu); + }); + return result; + } +} + +JNIEXPORT jlong JNICALL JNI_FN(nativeCreateItem)(JNIEnv *env, jclass clazz, + jstring jTitle, jstring jKeyEq) { + (void)clazz; + @autoreleasepool { + NSString *title = toNSString(env, jTitle) ?: @""; + NSString *keyEq = toNSString(env, jKeyEq) ?: @""; + __block jlong result = 0; + runOnMain(^{ + NSMenuItem *item = [[NSMenuItem alloc] initWithTitle:title + action:nil + keyEquivalent:keyEq]; + result = retainToHandle(item); + }); + return result; + } +} + +JNIEXPORT jlong JNICALL JNI_FN(nativeCreateSeparatorItem)(JNIEnv *env, jclass clazz) { + (void)env; (void)clazz; + __block jlong result = 0; + runOnMain(^{ + result = retainToHandle([NSMenuItem separatorItem]); + }); + return result; +} + +JNIEXPORT jlong JNICALL JNI_FN(nativeCreateSectionHeader)(JNIEnv *env, jclass clazz, jstring jTitle) { + (void)clazz; + @autoreleasepool { + NSString *title = toNSString(env, jTitle) ?: @""; + __block jlong result = 0; + runOnMain(^{ + if (@available(macOS 14.0, *)) { + result = retainToHandle([NSMenuItem sectionHeaderWithTitle:title]); + } else { + // Fallback: create a disabled item as a section header + NSMenuItem *item = [[NSMenuItem alloc] initWithTitle:title action:nil keyEquivalent:@""]; + [item setEnabled:NO]; + result = retainToHandle(item); + } + }); + return result; + } +} + +JNIEXPORT void JNICALL JNI_FN(nativeRelease)(JNIEnv *env, jclass clazz, jlong handle) { + (void)env; (void)clazz; + releaseHandle(handle); +} + +// ============================================================================ +// SECTION: Menu properties (get/set by type + property ID) +// ============================================================================ + +JNIEXPORT jstring JNICALL JNI_FN(nativeMenuGetString)(JNIEnv *env, jclass clazz, + jlong handle, jint propId) { + (void)clazz; + @autoreleasepool { + NSMenu *menu = HANDLE_TO_MENU(handle); + NSString *value = nil; + switch (propId) { + case MENU_STR_TITLE: value = [menu title]; break; + } + return toJString(env, value); + } +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuSetString)(JNIEnv *env, jclass clazz, + jlong handle, jint propId, jstring jValue) { + (void)clazz; + @autoreleasepool { + NSMenu *menu = HANDLE_TO_MENU(handle); + NSString *value = toNSString(env, jValue) ?: @""; + runOnMain(^{ + switch (propId) { + case MENU_STR_TITLE: [menu setTitle:value]; break; + } + }); + } +} + +JNIEXPORT jboolean JNICALL JNI_FN(nativeMenuGetBool)(JNIEnv *env, jclass clazz, + jlong handle, jint propId) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(handle); + switch (propId) { + case MENU_BOOL_AUTO_ENABLES: return [menu autoenablesItems] ? JNI_TRUE : JNI_FALSE; + case MENU_BOOL_SHOWS_STATE: return [menu showsStateColumn] ? JNI_TRUE : JNI_FALSE; + case MENU_BOOL_ALLOWS_PLUGINS: return [menu allowsContextMenuPlugIns] ? JNI_TRUE : JNI_FALSE; + } + return JNI_FALSE; +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuSetBool)(JNIEnv *env, jclass clazz, + jlong handle, jint propId, jboolean value) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(handle); + BOOL val = value ? YES : NO; + runOnMain(^{ + switch (propId) { + case MENU_BOOL_AUTO_ENABLES: [menu setAutoenablesItems:val]; break; + case MENU_BOOL_SHOWS_STATE: [menu setShowsStateColumn:val]; break; + case MENU_BOOL_ALLOWS_PLUGINS: [menu setAllowsContextMenuPlugIns:val]; break; + } + }); +} + +JNIEXPORT jint JNICALL JNI_FN(nativeMenuGetInt)(JNIEnv *env, jclass clazz, + jlong handle, jint propId) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(handle); + switch (propId) { + case MENU_INT_PRESENTATION: + if (@available(macOS 15.0, *)) { + return (jint)[menu presentationStyle]; + } + return 0; + case MENU_INT_SELECTION: + if (@available(macOS 15.0, *)) { + return (jint)[menu selectionMode]; + } + return 0; + case MENU_INT_LAYOUT_DIR: + return (jint)[menu userInterfaceLayoutDirection]; + } + return 0; +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuSetInt)(JNIEnv *env, jclass clazz, + jlong handle, jint propId, jint value) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(handle); + runOnMain(^{ + switch (propId) { + case MENU_INT_PRESENTATION: + if (@available(macOS 15.0, *)) { + [menu setPresentationStyle:(NSMenuPresentationStyle)value]; + } + break; + case MENU_INT_SELECTION: + if (@available(macOS 15.0, *)) { + [menu setSelectionMode:(NSMenuSelectionMode)value]; + } + break; + case MENU_INT_LAYOUT_DIR: + [menu setUserInterfaceLayoutDirection:(NSUserInterfaceLayoutDirection)value]; + break; + } + }); +} + +JNIEXPORT jfloat JNICALL JNI_FN(nativeMenuGetFloat)(JNIEnv *env, jclass clazz, + jlong handle, jint propId) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(handle); + switch (propId) { + case MENU_FLOAT_MIN_WIDTH: return (jfloat)[menu minimumWidth]; + } + return 0.0f; +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuSetFloat)(JNIEnv *env, jclass clazz, + jlong handle, jint propId, jfloat value) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(handle); + runOnMain(^{ + switch (propId) { + case MENU_FLOAT_MIN_WIDTH: [menu setMinimumWidth:(CGFloat)value]; break; + } + }); +} + +// ============================================================================ +// SECTION: Menu item management +// ============================================================================ + +JNIEXPORT void JNICALL JNI_FN(nativeMenuAddItem)(JNIEnv *env, jclass clazz, + jlong menuHandle, jlong itemHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSMenuItem *item = HANDLE_TO_ITEM(itemHandle); + runOnMain(^{ [menu addItem:item]; }); +} + +JNIEXPORT jlong JNICALL JNI_FN(nativeMenuAddItemWithTitle)(JNIEnv *env, jclass clazz, + jlong menuHandle, jstring jTitle, + jstring jKeyEq) { + (void)clazz; + @autoreleasepool { + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSString *title = toNSString(env, jTitle) ?: @""; + NSString *keyEq = toNSString(env, jKeyEq) ?: @""; + __block jlong result = 0; + runOnMain(^{ + NSMenuItem *item = [menu addItemWithTitle:title action:nil keyEquivalent:keyEq]; + result = retainToHandle(item); + }); + return result; + } +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuInsertItem)(JNIEnv *env, jclass clazz, + jlong menuHandle, jlong itemHandle, jint index) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSMenuItem *item = HANDLE_TO_ITEM(itemHandle); + runOnMain(^{ [menu insertItem:item atIndex:(NSInteger)index]; }); +} + +JNIEXPORT jlong JNICALL JNI_FN(nativeMenuInsertItemWithTitle)(JNIEnv *env, jclass clazz, + jlong menuHandle, jstring jTitle, + jstring jKeyEq, jint index) { + (void)clazz; + @autoreleasepool { + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSString *title = toNSString(env, jTitle) ?: @""; + NSString *keyEq = toNSString(env, jKeyEq) ?: @""; + __block jlong result = 0; + runOnMain(^{ + NSMenuItem *item = [menu insertItemWithTitle:title action:nil + keyEquivalent:keyEq atIndex:(NSInteger)index]; + result = retainToHandle(item); + }); + return result; + } +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuRemoveItem)(JNIEnv *env, jclass clazz, + jlong menuHandle, jlong itemHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSMenuItem *item = HANDLE_TO_ITEM(itemHandle); + runOnMain(^{ [menu removeItem:item]; }); +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuRemoveItemAtIndex)(JNIEnv *env, jclass clazz, + jlong menuHandle, jint index) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + runOnMain(^{ [menu removeItemAtIndex:(NSInteger)index]; }); +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuRemoveAllItems)(JNIEnv *env, jclass clazz, + jlong menuHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + runOnMain(^{ [menu removeAllItems]; }); +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuItemChanged)(JNIEnv *env, jclass clazz, + jlong menuHandle, jlong itemHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSMenuItem *item = HANDLE_TO_ITEM(itemHandle); + runOnMain(^{ [menu itemChanged:item]; }); +} + +// ============================================================================ +// SECTION: Menu finding +// ============================================================================ + +JNIEXPORT jlong JNICALL JNI_FN(nativeMenuItemWithTag)(JNIEnv *env, jclass clazz, + jlong menuHandle, jint tag) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSMenuItem *item = [menu itemWithTag:(NSInteger)tag]; + return retainToHandle(item); +} + +JNIEXPORT jlong JNICALL JNI_FN(nativeMenuItemWithTitle)(JNIEnv *env, jclass clazz, + jlong menuHandle, jstring jTitle) { + (void)clazz; + @autoreleasepool { + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSString *title = toNSString(env, jTitle); + NSMenuItem *item = [menu itemWithTitle:title]; + return retainToHandle(item); + } +} + +JNIEXPORT jlong JNICALL JNI_FN(nativeMenuItemAtIndex)(JNIEnv *env, jclass clazz, + jlong menuHandle, jint index) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSInteger count = [menu numberOfItems]; + if (index < 0 || index >= count) return 0; + NSMenuItem *item = [menu itemAtIndex:(NSInteger)index]; + return retainToHandle(item); +} + +JNIEXPORT jint JNICALL JNI_FN(nativeMenuGetNumberOfItems)(JNIEnv *env, jclass clazz, + jlong menuHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + return (jint)[menu numberOfItems]; +} + +JNIEXPORT jlongArray JNICALL JNI_FN(nativeMenuGetItems)(JNIEnv *env, jclass clazz, + jlong menuHandle) { + (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSArray *items = [menu itemArray]; + NSUInteger count = [items count]; + + jlongArray result = (*env)->NewLongArray(env, (jsize)count); + if (result == NULL) return NULL; + + jlong *buf = (*env)->GetLongArrayElements(env, result, NULL); + for (NSUInteger i = 0; i < count; i++) { + buf[i] = retainToHandle(items[i]); + } + (*env)->ReleaseLongArrayElements(env, result, buf, 0); + return result; +} + +// ============================================================================ +// SECTION: Menu indices +// ============================================================================ + +JNIEXPORT jint JNICALL JNI_FN(nativeMenuIndexOfItem)(JNIEnv *env, jclass clazz, + jlong menuHandle, jlong itemHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSMenuItem *item = HANDLE_TO_ITEM(itemHandle); + return (jint)[menu indexOfItem:item]; +} + +JNIEXPORT jint JNICALL JNI_FN(nativeMenuIndexOfItemWithTitle)(JNIEnv *env, jclass clazz, + jlong menuHandle, jstring jTitle) { + (void)clazz; + @autoreleasepool { + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSString *title = toNSString(env, jTitle); + return (jint)[menu indexOfItemWithTitle:title]; + } +} + +JNIEXPORT jint JNICALL JNI_FN(nativeMenuIndexOfItemWithTag)(JNIEnv *env, jclass clazz, + jlong menuHandle, jint tag) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + return (jint)[menu indexOfItemWithTag:(NSInteger)tag]; +} + +JNIEXPORT jint JNICALL JNI_FN(nativeMenuIndexOfItemWithSubmenu)(JNIEnv *env, jclass clazz, + jlong menuHandle, jlong submenuHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSMenu *submenu = HANDLE_TO_MENU(submenuHandle); + return (jint)[menu indexOfItemWithSubmenu:submenu]; +} + +// ============================================================================ +// SECTION: Menu special read-only properties +// ============================================================================ + +JNIEXPORT jfloatArray JNICALL JNI_FN(nativeMenuGetSize)(JNIEnv *env, jclass clazz, + jlong menuHandle) { + (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSSize sz = [menu size]; + jfloatArray result = (*env)->NewFloatArray(env, 2); + if (result == NULL) return NULL; + jfloat buf[2] = { (jfloat)sz.width, (jfloat)sz.height }; + (*env)->SetFloatArrayRegion(env, result, 0, 2, buf); + return result; +} + +JNIEXPORT jlong JNICALL JNI_FN(nativeMenuGetHighlightedItem)(JNIEnv *env, jclass clazz, + jlong menuHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + return retainToHandle([menu highlightedItem]); +} + +JNIEXPORT jlong JNICALL JNI_FN(nativeMenuGetSupermenu)(JNIEnv *env, jclass clazz, + jlong menuHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + return retainToHandle([menu supermenu]); +} + +JNIEXPORT jlongArray JNICALL JNI_FN(nativeMenuGetSelectedItems)(JNIEnv *env, jclass clazz, + jlong menuHandle) { + (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + + NSArray *items = nil; + if (@available(macOS 15.0, *)) { + items = [menu selectedItems]; + } + if (items == nil) items = @[]; + + NSUInteger count = [items count]; + jlongArray result = (*env)->NewLongArray(env, (jsize)count); + if (result == NULL || count == 0) return result; + + jlong *buf = (*env)->GetLongArrayElements(env, result, NULL); + for (NSUInteger i = 0; i < count; i++) { + buf[i] = retainToHandle(items[i]); + } + (*env)->ReleaseLongArrayElements(env, result, buf, 0); + return result; +} + +// ============================================================================ +// SECTION: Menu methods +// ============================================================================ + +JNIEXPORT void JNICALL JNI_FN(nativeMenuUpdate)(JNIEnv *env, jclass clazz, jlong menuHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + runOnMain(^{ [menu update]; }); +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuSizeToFit)(JNIEnv *env, jclass clazz, jlong menuHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated-declarations" + runOnMain(^{ [menu sizeToFit]; }); +#pragma clang diagnostic pop +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuCancelTracking)(JNIEnv *env, jclass clazz, jlong menuHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + runOnMain(^{ [menu cancelTracking]; }); +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuCancelTrackingWithoutAnimation)(JNIEnv *env, jclass clazz, + jlong menuHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + runOnMain(^{ [menu cancelTrackingWithoutAnimation]; }); +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuPerformActionForItemAtIndex)(JNIEnv *env, jclass clazz, + jlong menuHandle, jint index) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + runOnMain(^{ [menu performActionForItemAtIndex:(NSInteger)index]; }); +} + +JNIEXPORT jboolean JNICALL JNI_FN(nativeMenuPopUp)(JNIEnv *env, jclass clazz, + jlong menuHandle, jlong itemHandle, + jfloat x, jfloat y) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSMenuItem *item = (itemHandle != 0) ? HANDLE_TO_ITEM(itemHandle) : nil; + NSPoint location = NSMakePoint((CGFloat)x, (CGFloat)y); + + __block BOOL result = NO; + runOnMain(^{ + result = [menu popUpMenuPositioningItem:item atLocation:location inView:nil]; + }); + return result ? JNI_TRUE : JNI_FALSE; +} + +// ============================================================================ +// SECTION: Menu bar +// ============================================================================ + +JNIEXPORT jboolean JNICALL JNI_FN(nativeMenuBarIsVisible)(JNIEnv *env, jclass clazz) { + (void)env; (void)clazz; + return [NSMenu menuBarVisible] ? JNI_TRUE : JNI_FALSE; +} + +JNIEXPORT void JNICALL JNI_FN(nativeMenuBarSetVisible)(JNIEnv *env, jclass clazz, jboolean visible) { + (void)env; (void)clazz; + BOOL val = visible ? YES : NO; + runOnMain(^{ [NSMenu setMenuBarVisible:val]; }); +} + +JNIEXPORT jfloat JNICALL JNI_FN(nativeMenuBarGetHeight)(JNIEnv *env, jclass clazz) { + (void)env; (void)clazz; + return (jfloat)[[NSApp mainMenu] menuBarHeight]; +} + +JNIEXPORT jlong JNICALL JNI_FN(nativeGetMainMenu)(JNIEnv *env, jclass clazz) { + (void)env; (void)clazz; + __block jlong result = 0; + runOnMain(^{ + result = retainToHandle([NSApp mainMenu]); + }); + return result; +} + +JNIEXPORT void JNICALL JNI_FN(nativeSetMainMenu)(JNIEnv *env, jclass clazz, jlong menuHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + runOnMain(^{ + [NSApp setMainMenu:menu]; + + // Register well-known menus so macOS populates them automatically. + for (NSMenuItem *item in [menu itemArray]) { + NSMenu *sub = [item submenu]; + if (sub == nil) continue; + NSString *title = [sub title]; + if ([title isEqualToString:@"Window"]) { + [NSApp setWindowsMenu:sub]; + } else if ([title isEqualToString:@"Help"]) { + [NSApp setHelpMenu:sub]; + } + // Services is nested inside the app menu (first item's submenu) + for (NSMenuItem *child in [sub itemArray]) { + NSMenu *childSub = [child submenu]; + if (childSub && [[childSub title] isEqualToString:@"Services"]) { + [NSApp setServicesMenu:childSub]; + } + } + } + }); +} + + +// ============================================================================ +// SECTION: Menu submenu +// ============================================================================ + +JNIEXPORT void JNICALL JNI_FN(nativeMenuSetSubmenuForItem)(JNIEnv *env, jclass clazz, + jlong menuHandle, jlong submenuHandle, + jlong itemHandle) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + NSMenu *submenu = (submenuHandle != 0) ? HANDLE_TO_MENU(submenuHandle) : nil; + NSMenuItem *item = HANDLE_TO_ITEM(itemHandle); + runOnMain(^{ [menu setSubmenu:submenu forItem:item]; }); +} + +// ============================================================================ +// SECTION: Menu delegate +// ============================================================================ + +JNIEXPORT void JNICALL JNI_FN(nativeMenuSetDelegate)(JNIEnv *env, jclass clazz, + jlong menuHandle, jboolean enabled) { + (void)env; (void)clazz; + NSMenu *menu = HANDLE_TO_MENU(menuHandle); + ensureDelegateStorage(); + + runOnMain(^{ + NSValue *key = [NSValue valueWithPointer:(__bridge void *)menu]; + if (enabled) { + NucleusMenuDelegateProxy *proxy = g_delegateProxies[key]; + if (proxy == nil) { + proxy = [[NucleusMenuDelegateProxy alloc] init]; + g_delegateProxies[key] = proxy; + } + [menu setDelegate:proxy]; + } else { + [menu setDelegate:nil]; + [g_delegateProxies removeObjectForKey:key]; + } + }); +} + +// ============================================================================ +// SECTION: Item properties (get/set by type + property ID) +// ============================================================================ + +JNIEXPORT jstring JNICALL JNI_FN(nativeItemGetString)(JNIEnv *env, jclass clazz, + jlong handle, jint propId) { + (void)clazz; + @autoreleasepool { + NSMenuItem *item = HANDLE_TO_ITEM(handle); + NSString *value = nil; + switch (propId) { + case ITEM_STR_TITLE: value = [item title]; break; + case ITEM_STR_KEY_EQ: value = [item keyEquivalent]; break; + case ITEM_STR_TOOLTIP: value = [item toolTip]; break; + case ITEM_STR_SUBTITLE: + if (@available(macOS 14.4, *)) { + value = [item subtitle]; + } + break; + } + return toJString(env, value); + } +} + +JNIEXPORT void JNICALL JNI_FN(nativeItemSetString)(JNIEnv *env, jclass clazz, + jlong handle, jint propId, jstring jValue) { + (void)clazz; + @autoreleasepool { + NSMenuItem *item = HANDLE_TO_ITEM(handle); + NSString *value = toNSString(env, jValue); + runOnMain(^{ + switch (propId) { + case ITEM_STR_TITLE: [item setTitle:value ?: @""]; break; + case ITEM_STR_KEY_EQ: [item setKeyEquivalent:value ?: @""]; break; + case ITEM_STR_TOOLTIP: [item setToolTip:value]; break; + case ITEM_STR_SUBTITLE: + if (@available(macOS 14.4, *)) { + [item setSubtitle:value]; + } + break; + } + }); + } +} + +JNIEXPORT jboolean JNICALL JNI_FN(nativeItemGetBool)(JNIEnv *env, jclass clazz, + jlong handle, jint propId) { + (void)env; (void)clazz; + NSMenuItem *item = HANDLE_TO_ITEM(handle); + switch (propId) { + case ITEM_BOOL_ENABLED: return [item isEnabled] ? JNI_TRUE : JNI_FALSE; + case ITEM_BOOL_HIDDEN: return [item isHidden] ? JNI_TRUE : JNI_FALSE; + case ITEM_BOOL_ALTERNATE: return [item isAlternate] ? JNI_TRUE : JNI_FALSE; + case ITEM_BOOL_HIDDEN_OR_ANCESTOR: return [item isHiddenOrHasHiddenAncestor] ? JNI_TRUE : JNI_FALSE; + case ITEM_BOOL_IS_SEPARATOR: return [item isSeparatorItem] ? JNI_TRUE : JNI_FALSE; + case ITEM_BOOL_IS_HIGHLIGHTED: return [item isHighlighted] ? JNI_TRUE : JNI_FALSE; + case ITEM_BOOL_HAS_SUBMENU: return [item hasSubmenu] ? JNI_TRUE : JNI_FALSE; + case ITEM_BOOL_IS_SECTION_HEADER: + if (@available(macOS 14.0, *)) { + return [item isSectionHeader] ? JNI_TRUE : JNI_FALSE; + } + return JNI_FALSE; + case ITEM_BOOL_KEY_EQ_LOCALIZATION: + if (@available(macOS 12.0, *)) { + return [item allowsAutomaticKeyEquivalentLocalization] ? JNI_TRUE : JNI_FALSE; + } + return JNI_TRUE; + case ITEM_BOOL_KEY_EQ_MIRRORING: + if (@available(macOS 12.0, *)) { + return [item allowsAutomaticKeyEquivalentMirroring] ? JNI_TRUE : JNI_FALSE; + } + return JNI_TRUE; + case ITEM_BOOL_KEY_EQ_WHEN_HIDDEN: + return [item allowsKeyEquivalentWhenHidden] ? JNI_TRUE : JNI_FALSE; + } + return JNI_FALSE; +} + +JNIEXPORT void JNICALL JNI_FN(nativeItemSetBool)(JNIEnv *env, jclass clazz, + jlong handle, jint propId, jboolean value) { + (void)env; (void)clazz; + NSMenuItem *item = HANDLE_TO_ITEM(handle); + BOOL val = value ? YES : NO; + runOnMain(^{ + switch (propId) { + case ITEM_BOOL_ENABLED: [item setEnabled:val]; break; + case ITEM_BOOL_HIDDEN: [item setHidden:val]; break; + case ITEM_BOOL_ALTERNATE: [item setAlternate:val]; break; + case ITEM_BOOL_KEY_EQ_LOCALIZATION: + if (@available(macOS 12.0, *)) { + [item setAllowsAutomaticKeyEquivalentLocalization:val]; + } + break; + case ITEM_BOOL_KEY_EQ_MIRRORING: + if (@available(macOS 12.0, *)) { + [item setAllowsAutomaticKeyEquivalentMirroring:val]; + } + break; + case ITEM_BOOL_KEY_EQ_WHEN_HIDDEN: + [item setAllowsKeyEquivalentWhenHidden:val]; + break; + // Read-only properties are silently ignored + } + }); +} + +JNIEXPORT jint JNICALL JNI_FN(nativeItemGetInt)(JNIEnv *env, jclass clazz, + jlong handle, jint propId) { + (void)env; (void)clazz; + NSMenuItem *item = HANDLE_TO_ITEM(handle); + switch (propId) { + case ITEM_INT_TAG: return (jint)[item tag]; + case ITEM_INT_STATE: return (jint)[item state]; + case ITEM_INT_INDENT: return (jint)[item indentationLevel]; + case ITEM_INT_KEY_EQ_MASK: return (jint)[item keyEquivalentModifierMask]; + } + return 0; +} + +JNIEXPORT void JNICALL JNI_FN(nativeItemSetInt)(JNIEnv *env, jclass clazz, + jlong handle, jint propId, jint value) { + (void)env; (void)clazz; + NSMenuItem *item = HANDLE_TO_ITEM(handle); + runOnMain(^{ + switch (propId) { + case ITEM_INT_TAG: [item setTag:(NSInteger)value]; break; + case ITEM_INT_STATE: [item setState:(NSControlStateValue)value]; break; + case ITEM_INT_INDENT: [item setIndentationLevel:(NSInteger)value]; break; + case ITEM_INT_KEY_EQ_MASK: [item setKeyEquivalentModifierMask:(NSEventModifierFlags)value]; break; + } + }); +} + +// ============================================================================ +// SECTION: Item navigation +// ============================================================================ + +JNIEXPORT jlong JNICALL JNI_FN(nativeItemGetSubmenu)(JNIEnv *env, jclass clazz, jlong handle) { + (void)env; (void)clazz; + NSMenuItem *item = HANDLE_TO_ITEM(handle); + return retainToHandle([item submenu]); +} + +JNIEXPORT void JNICALL JNI_FN(nativeItemSetSubmenu)(JNIEnv *env, jclass clazz, + jlong handle, jlong submenuHandle) { + (void)env; (void)clazz; + NSMenuItem *item = HANDLE_TO_ITEM(handle); + NSMenu *submenu = (submenuHandle != 0) ? HANDLE_TO_MENU(submenuHandle) : nil; + runOnMain(^{ [item setSubmenu:submenu]; }); +} + +JNIEXPORT jlong JNICALL JNI_FN(nativeItemGetParentItem)(JNIEnv *env, jclass clazz, jlong handle) { + (void)env; (void)clazz; + NSMenuItem *item = HANDLE_TO_ITEM(handle); + return retainToHandle([item parentItem]); +} + +JNIEXPORT jlong JNICALL JNI_FN(nativeItemGetMenu)(JNIEnv *env, jclass clazz, jlong handle) { + (void)env; (void)clazz; + NSMenuItem *item = HANDLE_TO_ITEM(handle); + return retainToHandle([item menu]); +} + +// ============================================================================ +// SECTION: Item image +// ============================================================================ + +JNIEXPORT void JNICALL JNI_FN(nativeItemSetImage)(JNIEnv *env, jclass clazz, + jlong handle, jint imageType, + jstring jValue, jstring jAccessDesc) { + (void)clazz; + @autoreleasepool { + NSMenuItem *item = HANDLE_TO_ITEM(handle); + NSImage *img = makeImage(env, imageType, jValue, jAccessDesc); + runOnMain(^{ [item setImage:img]; }); + } +} + +JNIEXPORT void JNICALL JNI_FN(nativeItemSetStateImage)(JNIEnv *env, jclass clazz, + jlong handle, jint stateTarget, + jint imageType, jstring jValue, + jstring jAccessDesc) { + (void)clazz; + @autoreleasepool { + NSMenuItem *item = HANDLE_TO_ITEM(handle); + NSImage *img = makeImage(env, imageType, jValue, jAccessDesc); + runOnMain(^{ + switch (stateTarget) { + case STATE_IMG_ON: [item setOnStateImage:img]; break; + case STATE_IMG_OFF: [item setOffStateImage:img]; break; + case STATE_IMG_MIXED: [item setMixedStateImage:img]; break; + } + }); + } +} + +// ============================================================================ +// SECTION: Item badge (macOS 14+) +// ============================================================================ + +JNIEXPORT void JNICALL JNI_FN(nativeItemSetBadge)(JNIEnv *env, jclass clazz, + jlong handle, jint badgeType, + jint count, jstring jString) { + (void)clazz; + @autoreleasepool { + if (@available(macOS 14.0, *)) { + NSMenuItem *item = HANDLE_TO_ITEM(handle); + NSString *str = toNSString(env, jString); + + runOnMain(^{ + NSMenuItemBadge *badge = nil; + switch (badgeType) { + case BADGE_CLEAR: break; + case BADGE_COUNT: badge = [[NSMenuItemBadge alloc] initWithCount:(NSInteger)count]; break; + case BADGE_STRING: badge = [[NSMenuItemBadge alloc] initWithString:str ?: @""]; break; + case BADGE_ALERTS: badge = [NSMenuItemBadge alertsWithCount:(NSInteger)count]; break; + case BADGE_NEW_ITEMS: badge = [NSMenuItemBadge newItemsWithCount:(NSInteger)count]; break; + case BADGE_UPDATES: badge = [NSMenuItemBadge updatesWithCount:(NSInteger)count]; break; + } + [item setBadge:badge]; + }); + } + } +} + +// ============================================================================ +// SECTION: Item action +// ============================================================================ + +JNIEXPORT void JNICALL JNI_FN(nativeItemSetHasAction)(JNIEnv *env, jclass clazz, + jlong handle, jboolean enabled) { + (void)env; (void)clazz; + NSMenuItem *item = HANDLE_TO_ITEM(handle); + runOnMain(^{ + if (enabled) { + [item setTarget:[NucleusMenuActionTarget shared]]; + [item setAction:@selector(menuItemAction:)]; + } else { + [item setTarget:nil]; + [item setAction:nil]; + } + }); +} diff --git a/menu-macos/src/main/resources/META-INF/native-image/io.github.kdroidfilter/nucleus.menu-macos/reachability-metadata.json b/menu-macos/src/main/resources/META-INF/native-image/io.github.kdroidfilter/nucleus.menu-macos/reachability-metadata.json new file mode 100644 index 00000000..0a0fd287 --- /dev/null +++ b/menu-macos/src/main/resources/META-INF/native-image/io.github.kdroidfilter/nucleus.menu-macos/reachability-metadata.json @@ -0,0 +1,34 @@ +{ + "reflection": [ + { + "type": "io.github.kdroidfilter.nucleus.menu.macos.NativeNsMenuBridge", + "jniAccessible": true, + "methods": [ + { + "name": "onMenuItemAction", + "parameterTypes": ["long"] + }, + { + "name": "onMenuWillOpen", + "parameterTypes": ["long"] + }, + { + "name": "onMenuDidClose", + "parameterTypes": ["long"] + }, + { + "name": "onMenuNeedsUpdate", + "parameterTypes": ["long"] + }, + { + "name": "onMenuWillHighlightItem", + "parameterTypes": ["long", "long"] + }, + { + "name": "onNumberOfItemsInMenu", + "parameterTypes": ["long"] + } + ] + } + ] +} diff --git a/mkdocs.yml b/mkdocs.yml index 93bea7c8..7c6ac7e5 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -81,6 +81,7 @@ nav: - Notification (Linux): runtime/notification-linux.md - Launcher (Linux): runtime/launcher-linux.md - Launcher (macOS): runtime/launcher-macos.md + - Menu (macOS): runtime/menu-macos.md - Freedesktop Icons: runtime/freedesktop-icons.md - Energy Manager: runtime/energy-manager.md - Linux HiDPI: runtime/linux-hidpi.md diff --git a/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/internal/InfoPlistBuilder.kt b/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/internal/InfoPlistBuilder.kt index 30bd1cbc..0dd78f74 100644 --- a/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/internal/InfoPlistBuilder.kt +++ b/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/internal/InfoPlistBuilder.kt @@ -160,6 +160,7 @@ internal object PlistKeys { val CFBundleIdentifier by this val CFBundleInfoDictionaryVersion by this val CFBundleName by this + val CFBundleDisplayName by this val CFBundlePackageType by this val CFBundleShortVersionString by this val CFBundleSignature by this diff --git a/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/internal/configureGraalvmApplication.kt b/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/internal/configureGraalvmApplication.kt index c32d837d..a883cc46 100644 --- a/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/internal/configureGraalvmApplication.kt +++ b/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/internal/configureGraalvmApplication.kt @@ -101,6 +101,14 @@ internal fun JvmApplicationContext.configureGraalvmApplication() { }, ) + if (currentOS == OS.MacOS) { + val dockName = + app.nativeDistributions.appName + ?: app.nativeDistributions.packageName + ?: project.name + add("-Dapple.awt.application.name=$dockName") + } + val tempDir = agentTempDir .get() @@ -939,7 +947,7 @@ private fun JvmApplicationContext.configureMacOsGraalvmPackaging( // Generate Info.plist — all DSL values are captured at configuration time // to avoid serializing Project/SourceSet references into the configuration cache. - val plistBundleName: String = app.nativeDistributions.packageName ?: project.name + val plistBundleName: String = app.nativeDistributions.appName ?: app.nativeDistributions.packageName ?: project.name val plistBundleID: String? = app.nativeDistributions.macOS.bundleID val plistVersion: String = app.nativeDistributions.packageVersion @@ -1013,6 +1021,7 @@ private fun JvmApplicationContext.configureMacOsGraalvmPackaging( doLast { val plist = InfoPlistBuilder() plist[PlistKeys.CFBundleName] = plistBundleName + plist[PlistKeys.CFBundleDisplayName] = plistBundleName plist[PlistKeys.CFBundleIdentifier] = plistBundleID plist[PlistKeys.CFBundleVersion] = plistVersion plist[PlistKeys.CFBundleShortVersionString] = plistVersion diff --git a/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/internal/configureJvmApplication.kt b/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/internal/configureJvmApplication.kt index 85163720..68a3cca1 100644 --- a/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/internal/configureJvmApplication.kt +++ b/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/internal/configureJvmApplication.kt @@ -672,6 +672,7 @@ private fun JvmApplicationContext.configurePackageTask( app.nativeDistributions.let { executables -> packageTask.packageName.set(packageNameProvider) + packageTask.appName.set(project.provider { executables.appName }) packageTask.packageDescription.set(executables.description) packageTask.packageCopyright.set(executables.copyright) packageTask.packageVendor.set(executables.vendor) @@ -984,6 +985,11 @@ private fun JvmApplicationContext.configureRunTask( add("-D$APP_ID=${resolvedAppIdProvider().get()}") if (currentOS == OS.MacOS) { + val dockName = + app.nativeDistributions.appName + ?: app.nativeDistributions.packageName + ?: project.name + add("-Dapple.awt.application.name=$dockName") val file = app.nativeDistributions.macOS.iconFile.ioFileOrNull if (file != null) add("-Xdock:icon=$file") } diff --git a/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/tasks/AbstractJPackageTask.kt b/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/tasks/AbstractJPackageTask.kt index 1ee71cae..18af6060 100644 --- a/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/tasks/AbstractJPackageTask.kt +++ b/plugin-build/plugin/src/main/kotlin/io/github/kdroidfilter/nucleus/desktop/application/tasks/AbstractJPackageTask.kt @@ -161,6 +161,10 @@ abstract class AbstractJPackageTask @get:Input val packageName: Property = objects.notNullProperty() + @get:Input + @get:Optional + val appName: Property = objects.nullableProperty() + @get:Input @get:Optional val packageDescription: Property = objects.nullableProperty() @@ -748,7 +752,9 @@ abstract class AbstractJPackageTask ?: launcherMainClass.get().substringBeforeLast(".") plist[PlistKeys.CFBundleIdentifier] = bundleId plist[PlistKeys.CFBundleInfoDictionaryVersion] = "6.0" - plist[PlistKeys.CFBundleName] = packageName + val displayName = appName.orNull ?: packageName + plist[PlistKeys.CFBundleName] = displayName + plist[PlistKeys.CFBundleDisplayName] = displayName plist[PlistKeys.CFBundlePackageType] = "APPL" val packageVersion = packageVersion.get() plist[PlistKeys.CFBundleShortVersionString] = packageVersion diff --git a/settings.gradle.kts b/settings.gradle.kts index 37e7670e..26f5ca13 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -57,7 +57,9 @@ include(":launcher-windows") include(":launcher-linux") include(":global-hotkey") include(":launcher-macos") +include(":menu-macos") include(":freedesktop-icons") +include(":sf-symbols") include(":jewel-sample") include(":sample-cmp") includeBuild("plugin-build") diff --git a/sf-symbols/build.gradle.kts b/sf-symbols/build.gradle.kts new file mode 100644 index 00000000..8408c41d --- /dev/null +++ b/sf-symbols/build.gradle.kts @@ -0,0 +1,60 @@ +import org.jetbrains.kotlin.gradle.dsl.JvmTarget + +plugins { + kotlin("jvm") + alias(libs.plugins.vanniktechMavenPublish) +} + +val publishVersion = + providers + .environmentVariable("GITHUB_REF") + .orNull + ?.removePrefix("refs/tags/v") + ?: "1.0.0" + +java { + sourceCompatibility = JavaVersion.VERSION_11 + targetCompatibility = JavaVersion.VERSION_11 +} + +kotlin { + compilerOptions { + jvmTarget.set(JvmTarget.JVM_11) + } +} + +mavenPublishing { + coordinates("io.github.kdroidfilter", "nucleus.sf-symbols", publishVersion) + + pom { + name.set("Nucleus SF Symbols") + description.set("Type-safe Apple SF Symbols constants for JVM desktop applications (macOS 11+)") + url.set("https://github.com/kdroidFilter/Nucleus") + + licenses { + license { + name.set("MIT License") + url.set("https://opensource.org/licenses/MIT") + } + } + + developers { + developer { + id.set("kdroidfilter") + name.set("kdroidFilter") + url.set("https://github.com/kdroidFilter") + } + } + + scm { + url.set("https://github.com/kdroidFilter/Nucleus") + connection.set("scm:git:git://github.com/kdroidFilter/Nucleus.git") + developerConnection.set("scm:git:ssh://git@github.com/kdroidFilter/Nucleus.git") + } + } + + publishToMavenCentral() + if (project.hasProperty("signingInMemoryKey")) { + signAllPublications() + } +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbol.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbol.kt new file mode 100644 index 00000000..beb7d88b --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbol.kt @@ -0,0 +1,24 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** + * Type-safe representation of an Apple SF Symbol name. + * + * Symbol names are grouped by category. Use [Custom] for symbols not + * listed here or for forward-compatibility with newer SF Symbols versions. + * + * @see Apple SF Symbols + */ +sealed interface SFSymbol { + /** The symbol name string passed to `NSImage.imageWithSystemSymbolName`. */ + val symbolName: String + + /** + * A custom symbol name for symbols not covered by the predefined constants. + * + * ```kotlin + * SFSymbol.Custom("my.custom.symbol") + * ``` + */ + @JvmInline + value class Custom(override val symbolName: String) : SFSymbol +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolArrows.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolArrows.kt new file mode 100644 index 00000000..5d6e92c2 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolArrows.kt @@ -0,0 +1,542 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Arrows (535 symbols). */ +enum class SFSymbolArrows( + override val symbolName: String, +) : SFSymbol { + ARROW_2_SQUAREPATH("arrow.2.squarepath"), + ARROW_3_TRIANGLEPATH("arrow.3.trianglepath"), + ARROW_BACKWARD("arrow.backward"), + ARROW_BACKWARD_CIRCLE("arrow.backward.circle"), + ARROW_BACKWARD_CIRCLE_DOTTED("arrow.backward.circle.dotted"), + ARROW_BACKWARD_CIRCLE_FILL("arrow.backward.circle.fill"), + ARROW_BACKWARD_SQUARE("arrow.backward.square"), + ARROW_BACKWARD_SQUARE_FILL("arrow.backward.square.fill"), + ARROW_BACKWARD_TO_LINE("arrow.backward.to.line"), + ARROW_BACKWARD_TO_LINE_CIRCLE("arrow.backward.to.line.circle"), + ARROW_BACKWARD_TO_LINE_CIRCLE_FILL("arrow.backward.to.line.circle.fill"), + ARROW_BACKWARD_TO_LINE_SQUARE("arrow.backward.to.line.square"), + ARROW_BACKWARD_TO_LINE_SQUARE_FILL("arrow.backward.to.line.square.fill"), + ARROW_CLOCKWISE("arrow.clockwise"), + ARROW_CLOCKWISE_CIRCLE("arrow.clockwise.circle"), + ARROW_CLOCKWISE_CIRCLE_FILL("arrow.clockwise.circle.fill"), + ARROW_CLOCKWISE_SQUARE("arrow.clockwise.square"), + ARROW_CLOCKWISE_SQUARE_FILL("arrow.clockwise.square.fill"), + ARROW_COUNTERCLOCKWISE("arrow.counterclockwise"), + ARROW_COUNTERCLOCKWISE_CIRCLE("arrow.counterclockwise.circle"), + ARROW_COUNTERCLOCKWISE_CIRCLE_FILL("arrow.counterclockwise.circle.fill"), + ARROW_COUNTERCLOCKWISE_SQUARE("arrow.counterclockwise.square"), + ARROW_COUNTERCLOCKWISE_SQUARE_FILL("arrow.counterclockwise.square.fill"), + ARROW_DOWN("arrow.down"), + ARROW_DOWN_AND_LINE_HORIZONTAL_AND_ARROW_UP("arrow.down.and.line.horizontal.and.arrow.up"), + ARROW_DOWN_APP("arrow.down.app"), + ARROW_DOWN_APP_DASHED("arrow.down.app.dashed"), + ARROW_DOWN_APP_DASHED_TRIANGLEBADGE_EXCLAMATIONMARK("arrow.down.app.dashed.trianglebadge.exclamationmark"), + ARROW_DOWN_APP_FILL("arrow.down.app.fill"), + ARROW_DOWN_APPLEWATCH("arrow.down.applewatch"), + ARROW_DOWN_BACKWARD("arrow.down.backward"), + ARROW_DOWN_BACKWARD_AND_ARROW_UP_FORWARD("arrow.down.backward.and.arrow.up.forward"), + ARROW_DOWN_BACKWARD_AND_ARROW_UP_FORWARD_CIRCLE("arrow.down.backward.and.arrow.up.forward.circle"), + ARROW_DOWN_BACKWARD_AND_ARROW_UP_FORWARD_CIRCLE_FILL("arrow.down.backward.and.arrow.up.forward.circle.fill"), + ARROW_DOWN_BACKWARD_AND_ARROW_UP_FORWARD_RECTANGLE("arrow.down.backward.and.arrow.up.forward.rectangle"), + ARROW_DOWN_BACKWARD_AND_ARROW_UP_FORWARD_RECTANGLE_FILL("arrow.down.backward.and.arrow.up.forward.rectangle.fill"), + ARROW_DOWN_BACKWARD_AND_ARROW_UP_FORWARD_SQUARE("arrow.down.backward.and.arrow.up.forward.square"), + ARROW_DOWN_BACKWARD_AND_ARROW_UP_FORWARD_SQUARE_FILL("arrow.down.backward.and.arrow.up.forward.square.fill"), + ARROW_DOWN_BACKWARD_CIRCLE("arrow.down.backward.circle"), + ARROW_DOWN_BACKWARD_CIRCLE_DOTTED("arrow.down.backward.circle.dotted"), + ARROW_DOWN_BACKWARD_CIRCLE_FILL("arrow.down.backward.circle.fill"), + ARROW_DOWN_BACKWARD_SQUARE("arrow.down.backward.square"), + ARROW_DOWN_BACKWARD_SQUARE_FILL("arrow.down.backward.square.fill"), + ARROW_DOWN_BACKWARD_TOPTRAILING_RECTANGLE("arrow.down.backward.toptrailing.rectangle"), + ARROW_DOWN_BACKWARD_TOPTRAILING_RECTANGLE_FILL("arrow.down.backward.toptrailing.rectangle.fill"), + ARROW_DOWN_CIRCLE("arrow.down.circle"), + ARROW_DOWN_CIRCLE_DOTTED("arrow.down.circle.dotted"), + ARROW_DOWN_CIRCLE_FILL("arrow.down.circle.fill"), + ARROW_DOWN_DOCUMENT("arrow.down.document"), + ARROW_DOWN_DOCUMENT_FILL("arrow.down.document.fill"), + ARROW_DOWN_FORWARD("arrow.down.forward"), + ARROW_DOWN_FORWARD_AND_ARROW_UP_BACKWARD("arrow.down.forward.and.arrow.up.backward"), + ARROW_DOWN_FORWARD_AND_ARROW_UP_BACKWARD_CIRCLE("arrow.down.forward.and.arrow.up.backward.circle"), + ARROW_DOWN_FORWARD_AND_ARROW_UP_BACKWARD_CIRCLE_FILL("arrow.down.forward.and.arrow.up.backward.circle.fill"), + ARROW_DOWN_FORWARD_AND_ARROW_UP_BACKWARD_RECTANGLE("arrow.down.forward.and.arrow.up.backward.rectangle"), + ARROW_DOWN_FORWARD_AND_ARROW_UP_BACKWARD_RECTANGLE_FILL("arrow.down.forward.and.arrow.up.backward.rectangle.fill"), + ARROW_DOWN_FORWARD_AND_ARROW_UP_BACKWARD_SQUARE("arrow.down.forward.and.arrow.up.backward.square"), + ARROW_DOWN_FORWARD_AND_ARROW_UP_BACKWARD_SQUARE_FILL("arrow.down.forward.and.arrow.up.backward.square.fill"), + ARROW_DOWN_FORWARD_CIRCLE("arrow.down.forward.circle"), + ARROW_DOWN_FORWARD_CIRCLE_DOTTED("arrow.down.forward.circle.dotted"), + ARROW_DOWN_FORWARD_CIRCLE_FILL("arrow.down.forward.circle.fill"), + ARROW_DOWN_FORWARD_SQUARE("arrow.down.forward.square"), + ARROW_DOWN_FORWARD_SQUARE_FILL("arrow.down.forward.square.fill"), + ARROW_DOWN_FORWARD_TOPLEADING_RECTANGLE("arrow.down.forward.topleading.rectangle"), + ARROW_DOWN_FORWARD_TOPLEADING_RECTANGLE_FILL("arrow.down.forward.topleading.rectangle.fill"), + ARROW_DOWN_HEART("arrow.down.heart"), + ARROW_DOWN_HEART_FILL("arrow.down.heart.fill"), + ARROW_DOWN_LEFT("arrow.down.left"), + ARROW_DOWN_LEFT_AND_ARROW_UP_RIGHT("arrow.down.left.and.arrow.up.right"), + ARROW_DOWN_LEFT_AND_ARROW_UP_RIGHT_CIRCLE("arrow.down.left.and.arrow.up.right.circle"), + ARROW_DOWN_LEFT_AND_ARROW_UP_RIGHT_CIRCLE_FILL("arrow.down.left.and.arrow.up.right.circle.fill"), + ARROW_DOWN_LEFT_AND_ARROW_UP_RIGHT_RECTANGLE("arrow.down.left.and.arrow.up.right.rectangle"), + ARROW_DOWN_LEFT_AND_ARROW_UP_RIGHT_RECTANGLE_FILL("arrow.down.left.and.arrow.up.right.rectangle.fill"), + ARROW_DOWN_LEFT_AND_ARROW_UP_RIGHT_SQUARE("arrow.down.left.and.arrow.up.right.square"), + ARROW_DOWN_LEFT_AND_ARROW_UP_RIGHT_SQUARE_FILL("arrow.down.left.and.arrow.up.right.square.fill"), + ARROW_DOWN_LEFT_ARROW_UP_RIGHT("arrow.down.left.arrow.up.right"), + ARROW_DOWN_LEFT_ARROW_UP_RIGHT_CIRCLE("arrow.down.left.arrow.up.right.circle"), + ARROW_DOWN_LEFT_ARROW_UP_RIGHT_CIRCLE_FILL("arrow.down.left.arrow.up.right.circle.fill"), + ARROW_DOWN_LEFT_ARROW_UP_RIGHT_SQUARE("arrow.down.left.arrow.up.right.square"), + ARROW_DOWN_LEFT_ARROW_UP_RIGHT_SQUARE_FILL("arrow.down.left.arrow.up.right.square.fill"), + ARROW_DOWN_LEFT_CIRCLE("arrow.down.left.circle"), + ARROW_DOWN_LEFT_CIRCLE_DOTTED("arrow.down.left.circle.dotted"), + ARROW_DOWN_LEFT_CIRCLE_FILL("arrow.down.left.circle.fill"), + ARROW_DOWN_LEFT_SQUARE("arrow.down.left.square"), + ARROW_DOWN_LEFT_SQUARE_FILL("arrow.down.left.square.fill"), + ARROW_DOWN_LEFT_TOPRIGHT_RECTANGLE("arrow.down.left.topright.rectangle"), + ARROW_DOWN_LEFT_TOPRIGHT_RECTANGLE_FILL("arrow.down.left.topright.rectangle.fill"), + ARROW_DOWN_LEFT_VIDEO("arrow.down.left.video"), + ARROW_DOWN_LEFT_VIDEO_FILL("arrow.down.left.video.fill"), + ARROW_DOWN_MESSAGE("arrow.down.message"), + ARROW_DOWN_MESSAGE_FILL("arrow.down.message.fill"), + ARROW_DOWN_RIGHT("arrow.down.right"), + ARROW_DOWN_RIGHT_AND_ARROW_UP_LEFT("arrow.down.right.and.arrow.up.left"), + ARROW_DOWN_RIGHT_AND_ARROW_UP_LEFT_CIRCLE("arrow.down.right.and.arrow.up.left.circle"), + ARROW_DOWN_RIGHT_AND_ARROW_UP_LEFT_CIRCLE_FILL("arrow.down.right.and.arrow.up.left.circle.fill"), + ARROW_DOWN_RIGHT_AND_ARROW_UP_LEFT_RECTANGLE("arrow.down.right.and.arrow.up.left.rectangle"), + ARROW_DOWN_RIGHT_AND_ARROW_UP_LEFT_RECTANGLE_FILL("arrow.down.right.and.arrow.up.left.rectangle.fill"), + ARROW_DOWN_RIGHT_AND_ARROW_UP_LEFT_SQUARE("arrow.down.right.and.arrow.up.left.square"), + ARROW_DOWN_RIGHT_AND_ARROW_UP_LEFT_SQUARE_FILL("arrow.down.right.and.arrow.up.left.square.fill"), + ARROW_DOWN_RIGHT_CIRCLE("arrow.down.right.circle"), + ARROW_DOWN_RIGHT_CIRCLE_DOTTED("arrow.down.right.circle.dotted"), + ARROW_DOWN_RIGHT_CIRCLE_FILL("arrow.down.right.circle.fill"), + ARROW_DOWN_RIGHT_SQUARE("arrow.down.right.square"), + ARROW_DOWN_RIGHT_SQUARE_FILL("arrow.down.right.square.fill"), + ARROW_DOWN_RIGHT_TOPLEFT_RECTANGLE("arrow.down.right.topleft.rectangle"), + ARROW_DOWN_RIGHT_TOPLEFT_RECTANGLE_FILL("arrow.down.right.topleft.rectangle.fill"), + ARROW_DOWN_SQUARE("arrow.down.square"), + ARROW_DOWN_SQUARE_FILL("arrow.down.square.fill"), + ARROW_DOWN_TO_LINE("arrow.down.to.line"), + ARROW_DOWN_TO_LINE_CIRCLE("arrow.down.to.line.circle"), + ARROW_DOWN_TO_LINE_CIRCLE_FILL("arrow.down.to.line.circle.fill"), + ARROW_DOWN_TO_LINE_COMPACT("arrow.down.to.line.compact"), + ARROW_DOWN_TO_LINE_SQUARE("arrow.down.to.line.square"), + ARROW_DOWN_TO_LINE_SQUARE_FILL("arrow.down.to.line.square.fill"), + ARROW_FORWARD("arrow.forward"), + ARROW_FORWARD_CIRCLE("arrow.forward.circle"), + ARROW_FORWARD_CIRCLE_DOTTED("arrow.forward.circle.dotted"), + ARROW_FORWARD_CIRCLE_FILL("arrow.forward.circle.fill"), + ARROW_FORWARD_SQUARE("arrow.forward.square"), + ARROW_FORWARD_SQUARE_FILL("arrow.forward.square.fill"), + ARROW_FORWARD_TO_LINE("arrow.forward.to.line"), + ARROW_FORWARD_TO_LINE_CIRCLE("arrow.forward.to.line.circle"), + ARROW_FORWARD_TO_LINE_CIRCLE_FILL("arrow.forward.to.line.circle.fill"), + ARROW_FORWARD_TO_LINE_SQUARE("arrow.forward.to.line.square"), + ARROW_FORWARD_TO_LINE_SQUARE_FILL("arrow.forward.to.line.square.fill"), + ARROW_LEFT("arrow.left"), + ARROW_LEFT_AND_LINE_VERTICAL_AND_ARROW_RIGHT("arrow.left.and.line.vertical.and.arrow.right"), + ARROW_LEFT_AND_RIGHT("arrow.left.and.right"), + ARROW_LEFT_AND_RIGHT_CIRCLE("arrow.left.and.right.circle"), + ARROW_LEFT_AND_RIGHT_CIRCLE_FILL("arrow.left.and.right.circle.fill"), + ARROW_LEFT_AND_RIGHT_SQUARE("arrow.left.and.right.square"), + ARROW_LEFT_AND_RIGHT_SQUARE_FILL("arrow.left.and.right.square.fill"), + ARROW_LEFT_AND_RIGHT_TEXT_VERTICAL("arrow.left.and.right.text.vertical"), + ARROW_LEFT_ARROW_RIGHT("arrow.left.arrow.right"), + ARROW_LEFT_ARROW_RIGHT_CIRCLE("arrow.left.arrow.right.circle"), + ARROW_LEFT_ARROW_RIGHT_CIRCLE_FILL("arrow.left.arrow.right.circle.fill"), + ARROW_LEFT_ARROW_RIGHT_SQUARE("arrow.left.arrow.right.square"), + ARROW_LEFT_ARROW_RIGHT_SQUARE_FILL("arrow.left.arrow.right.square.fill"), + ARROW_LEFT_CIRCLE("arrow.left.circle"), + ARROW_LEFT_CIRCLE_DOTTED("arrow.left.circle.dotted"), + ARROW_LEFT_CIRCLE_FILL("arrow.left.circle.fill"), + ARROW_LEFT_SQUARE("arrow.left.square"), + ARROW_LEFT_SQUARE_FILL("arrow.left.square.fill"), + ARROW_LEFT_TO_LINE("arrow.left.to.line"), + ARROW_LEFT_TO_LINE_CIRCLE("arrow.left.to.line.circle"), + ARROW_LEFT_TO_LINE_CIRCLE_FILL("arrow.left.to.line.circle.fill"), + ARROW_LEFT_TO_LINE_COMPACT("arrow.left.to.line.compact"), + ARROW_LEFT_TO_LINE_SQUARE("arrow.left.to.line.square"), + ARROW_LEFT_TO_LINE_SQUARE_FILL("arrow.left.to.line.square.fill"), + ARROW_RIGHT("arrow.right"), + ARROW_RIGHT_AND_LINE_VERTICAL_AND_ARROW_LEFT("arrow.right.and.line.vertical.and.arrow.left"), + ARROW_RIGHT_CIRCLE("arrow.right.circle"), + ARROW_RIGHT_CIRCLE_DOTTED("arrow.right.circle.dotted"), + ARROW_RIGHT_CIRCLE_FILL("arrow.right.circle.fill"), + ARROW_RIGHT_FILLED_FILTER_ARROW_RIGHT("arrow.right.filled.filter.arrow.right"), + ARROW_RIGHT_PAGE_ON_CLIPBOARD("arrow.right.page.on.clipboard"), + ARROW_RIGHT_SQUARE("arrow.right.square"), + ARROW_RIGHT_SQUARE_FILL("arrow.right.square.fill"), + ARROW_RIGHT_TO_LINE("arrow.right.to.line"), + ARROW_RIGHT_TO_LINE_CIRCLE("arrow.right.to.line.circle"), + ARROW_RIGHT_TO_LINE_CIRCLE_FILL("arrow.right.to.line.circle.fill"), + ARROW_RIGHT_TO_LINE_COMPACT("arrow.right.to.line.compact"), + ARROW_RIGHT_TO_LINE_SQUARE("arrow.right.to.line.square"), + ARROW_RIGHT_TO_LINE_SQUARE_FILL("arrow.right.to.line.square.fill"), + ARROW_TRIANGLEHEAD_2_CLOCKWISE("arrow.trianglehead.2.clockwise"), + ARROW_TRIANGLEHEAD_2_CLOCKWISE_ROTATE_90("arrow.trianglehead.2.clockwise.rotate.90"), + ARROW_TRIANGLEHEAD_2_CLOCKWISE_ROTATE_90_CAMERA("arrow.trianglehead.2.clockwise.rotate.90.camera"), + ARROW_TRIANGLEHEAD_2_CLOCKWISE_ROTATE_90_CAMERA_FILL("arrow.trianglehead.2.clockwise.rotate.90.camera.fill"), + ARROW_TRIANGLEHEAD_2_CLOCKWISE_ROTATE_90_CIRCLE("arrow.trianglehead.2.clockwise.rotate.90.circle"), + ARROW_TRIANGLEHEAD_2_CLOCKWISE_ROTATE_90_CIRCLE_FILL("arrow.trianglehead.2.clockwise.rotate.90.circle.fill"), + ARROW_TRIANGLEHEAD_2_CLOCKWISE_ROTATE_90_ICLOUD("arrow.trianglehead.2.clockwise.rotate.90.icloud"), + ARROW_TRIANGLEHEAD_2_CLOCKWISE_ROTATE_90_ICLOUD_FILL("arrow.trianglehead.2.clockwise.rotate.90.icloud.fill"), + ARROW_TRIANGLEHEAD_2_CLOCKWISE_ROTATE_90_PAGE_ON_CLIPBOARD("arrow.trianglehead.2.clockwise.rotate.90.page.on.clipboard"), + ARROW_TRIANGLEHEAD_2_COUNTERCLOCKWISE("arrow.trianglehead.2.counterclockwise"), + ARROW_TRIANGLEHEAD_2_COUNTERCLOCKWISE_ROTATE_90("arrow.trianglehead.2.counterclockwise.rotate.90"), + ARROW_TRIANGLEHEAD_BOTTOMLEFT_CAPSULEPATH_CLOCKWISE("arrow.trianglehead.bottomleft.capsulepath.clockwise"), + ARROW_TRIANGLEHEAD_BRANCH("arrow.trianglehead.branch"), + ARROW_TRIANGLEHEAD_CLOCKWISE("arrow.trianglehead.clockwise"), + ARROW_TRIANGLEHEAD_CLOCKWISE_HEART("arrow.trianglehead.clockwise.heart"), + ARROW_TRIANGLEHEAD_CLOCKWISE_HEART_FILL("arrow.trianglehead.clockwise.heart.fill"), + ARROW_TRIANGLEHEAD_CLOCKWISE_ICLOUD("arrow.trianglehead.clockwise.icloud"), + ARROW_TRIANGLEHEAD_CLOCKWISE_ICLOUD_FILL("arrow.trianglehead.clockwise.icloud.fill"), + ARROW_TRIANGLEHEAD_CLOCKWISE_ROTATE_90("arrow.trianglehead.clockwise.rotate.90"), + ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("arrow.trianglehead.counterclockwise"), + ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ICLOUD("arrow.trianglehead.counterclockwise.icloud"), + ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ICLOUD_FILL("arrow.trianglehead.counterclockwise.icloud.fill"), + ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("arrow.trianglehead.counterclockwise.rotate.90"), + ARROW_TRIANGLEHEAD_LEFT_AND_RIGHT_RIGHTTRIANGLE_LEFT_RIGHTTRIANGLE_RIGHT("arrow.trianglehead.left.and.right.righttriangle.left.righttriangle.right"), + ARROW_TRIANGLEHEAD_LEFT_AND_RIGHT_RIGHTTRIANGLE_LEFT_RIGHTTRIANGLE_RIGHT_FILL("arrow.trianglehead.left.and.right.righttriangle.left.righttriangle.right.fill"), + ARROW_TRIANGLEHEAD_MERGE("arrow.trianglehead.merge"), + ARROW_TRIANGLEHEAD_PULL("arrow.trianglehead.pull"), + ARROW_TRIANGLEHEAD_RECTANGLEPATH("arrow.trianglehead.rectanglepath"), + ARROW_TRIANGLEHEAD_SWAP("arrow.trianglehead.swap"), + ARROW_TRIANGLEHEAD_TOPRIGHT_CAPSULEPATH_CLOCKWISE("arrow.trianglehead.topright.capsulepath.clockwise"), + ARROW_TRIANGLEHEAD_TURN_UP_RIGHT_CIRCLE("arrow.trianglehead.turn.up.right.circle"), + ARROW_TRIANGLEHEAD_TURN_UP_RIGHT_CIRCLE_FILL("arrow.trianglehead.turn.up.right.circle.fill"), + ARROW_TRIANGLEHEAD_TURN_UP_RIGHT_DIAMOND("arrow.trianglehead.turn.up.right.diamond"), + ARROW_TRIANGLEHEAD_TURN_UP_RIGHT_DIAMOND_FILL("arrow.trianglehead.turn.up.right.diamond.fill"), + ARROW_TRIANGLEHEAD_UP_AND_DOWN_RIGHTTRIANGLE_UP_RIGHTTRIANGLE_DOWN("arrow.trianglehead.up.and.down.righttriangle.up.righttriangle.down"), + ARROW_TRIANGLEHEAD_UP_AND_DOWN_RIGHTTRIANGLE_UP_RIGHTTRIANGLE_DOWN_FILL("arrow.trianglehead.up.and.down.righttriangle.up.righttriangle.down.fill"), + ARROW_TURN_DOWN_LEFT("arrow.turn.down.left"), + ARROW_TURN_DOWN_RIGHT("arrow.turn.down.right"), + ARROW_TURN_LEFT_DOWN("arrow.turn.left.down"), + ARROW_TURN_LEFT_UP("arrow.turn.left.up"), + ARROW_TURN_RIGHT_DOWN("arrow.turn.right.down"), + ARROW_TURN_RIGHT_UP("arrow.turn.right.up"), + ARROW_TURN_UP_FORWARD_IPHONE("arrow.turn.up.forward.iphone"), + ARROW_TURN_UP_FORWARD_IPHONE_FILL("arrow.turn.up.forward.iphone.fill"), + ARROW_TURN_UP_LEFT("arrow.turn.up.left"), + ARROW_TURN_UP_RIGHT("arrow.turn.up.right"), + ARROW_UP("arrow.up"), + ARROW_UP_AND_DOWN("arrow.up.and.down"), + ARROW_UP_AND_DOWN_AND_ARROW_LEFT_AND_RIGHT("arrow.up.and.down.and.arrow.left.and.right"), + ARROW_UP_AND_DOWN_AND_SPARKLES("arrow.up.and.down.and.sparkles"), + ARROW_UP_AND_DOWN_CIRCLE("arrow.up.and.down.circle"), + ARROW_UP_AND_DOWN_CIRCLE_FILL("arrow.up.and.down.circle.fill"), + ARROW_UP_AND_DOWN_SQUARE("arrow.up.and.down.square"), + ARROW_UP_AND_DOWN_SQUARE_FILL("arrow.up.and.down.square.fill"), + ARROW_UP_AND_DOWN_TEXT_HORIZONTAL("arrow.up.and.down.text.horizontal"), + ARROW_UP_AND_LINE_HORIZONTAL_AND_ARROW_DOWN("arrow.up.and.line.horizontal.and.arrow.down"), + ARROW_UP_AND_PERSON_RECTANGLE_PORTRAIT("arrow.up.and.person.rectangle.portrait"), + ARROW_UP_AND_PERSON_RECTANGLE_TURN_LEFT("arrow.up.and.person.rectangle.turn.left"), + ARROW_UP_AND_PERSON_RECTANGLE_TURN_RIGHT("arrow.up.and.person.rectangle.turn.right"), + ARROW_UP_ARROW_DOWN("arrow.up.arrow.down"), + ARROW_UP_ARROW_DOWN_CIRCLE("arrow.up.arrow.down.circle"), + ARROW_UP_ARROW_DOWN_CIRCLE_FILL("arrow.up.arrow.down.circle.fill"), + ARROW_UP_ARROW_DOWN_SQUARE("arrow.up.arrow.down.square"), + ARROW_UP_ARROW_DOWN_SQUARE_FILL("arrow.up.arrow.down.square.fill"), + ARROW_UP_BACKWARD("arrow.up.backward"), + ARROW_UP_BACKWARD_AND_ARROW_DOWN_FORWARD("arrow.up.backward.and.arrow.down.forward"), + ARROW_UP_BACKWARD_AND_ARROW_DOWN_FORWARD_CIRCLE("arrow.up.backward.and.arrow.down.forward.circle"), + ARROW_UP_BACKWARD_AND_ARROW_DOWN_FORWARD_CIRCLE_FILL("arrow.up.backward.and.arrow.down.forward.circle.fill"), + ARROW_UP_BACKWARD_AND_ARROW_DOWN_FORWARD_RECTANGLE("arrow.up.backward.and.arrow.down.forward.rectangle"), + ARROW_UP_BACKWARD_AND_ARROW_DOWN_FORWARD_RECTANGLE_FILL("arrow.up.backward.and.arrow.down.forward.rectangle.fill"), + ARROW_UP_BACKWARD_AND_ARROW_DOWN_FORWARD_SQUARE("arrow.up.backward.and.arrow.down.forward.square"), + ARROW_UP_BACKWARD_AND_ARROW_DOWN_FORWARD_SQUARE_FILL("arrow.up.backward.and.arrow.down.forward.square.fill"), + ARROW_UP_BACKWARD_BOTTOMTRAILING_RECTANGLE("arrow.up.backward.bottomtrailing.rectangle"), + ARROW_UP_BACKWARD_BOTTOMTRAILING_RECTANGLE_FILL("arrow.up.backward.bottomtrailing.rectangle.fill"), + ARROW_UP_BACKWARD_CIRCLE("arrow.up.backward.circle"), + ARROW_UP_BACKWARD_CIRCLE_DOTTED("arrow.up.backward.circle.dotted"), + ARROW_UP_BACKWARD_CIRCLE_FILL("arrow.up.backward.circle.fill"), + ARROW_UP_BACKWARD_SQUARE("arrow.up.backward.square"), + ARROW_UP_BACKWARD_SQUARE_FILL("arrow.up.backward.square.fill"), + ARROW_UP_BIN("arrow.up.bin"), + ARROW_UP_BIN_FILL("arrow.up.bin.fill"), + ARROW_UP_CIRCLE("arrow.up.circle"), + ARROW_UP_CIRCLE_BADGE_CLOCK("arrow.up.circle.badge.clock"), + ARROW_UP_CIRCLE_DOTTED("arrow.up.circle.dotted"), + ARROW_UP_CIRCLE_FILL("arrow.up.circle.fill"), + ARROW_UP_DOCUMENT("arrow.up.document"), + ARROW_UP_DOCUMENT_FILL("arrow.up.document.fill"), + ARROW_UP_FORWARD("arrow.up.forward"), + ARROW_UP_FORWARD_AND_ARROW_DOWN_BACKWARD("arrow.up.forward.and.arrow.down.backward"), + ARROW_UP_FORWARD_AND_ARROW_DOWN_BACKWARD_CIRCLE("arrow.up.forward.and.arrow.down.backward.circle"), + ARROW_UP_FORWARD_AND_ARROW_DOWN_BACKWARD_CIRCLE_FILL("arrow.up.forward.and.arrow.down.backward.circle.fill"), + ARROW_UP_FORWARD_AND_ARROW_DOWN_BACKWARD_RECTANGLE("arrow.up.forward.and.arrow.down.backward.rectangle"), + ARROW_UP_FORWARD_AND_ARROW_DOWN_BACKWARD_RECTANGLE_FILL("arrow.up.forward.and.arrow.down.backward.rectangle.fill"), + ARROW_UP_FORWARD_AND_ARROW_DOWN_BACKWARD_SQUARE("arrow.up.forward.and.arrow.down.backward.square"), + ARROW_UP_FORWARD_AND_ARROW_DOWN_BACKWARD_SQUARE_FILL("arrow.up.forward.and.arrow.down.backward.square.fill"), + ARROW_UP_FORWARD_APP("arrow.up.forward.app"), + ARROW_UP_FORWARD_APP_FILL("arrow.up.forward.app.fill"), + ARROW_UP_FORWARD_BOTTOMLEADING_RECTANGLE("arrow.up.forward.bottomleading.rectangle"), + ARROW_UP_FORWARD_BOTTOMLEADING_RECTANGLE_FILL("arrow.up.forward.bottomleading.rectangle.fill"), + ARROW_UP_FORWARD_CIRCLE("arrow.up.forward.circle"), + ARROW_UP_FORWARD_CIRCLE_DOTTED("arrow.up.forward.circle.dotted"), + ARROW_UP_FORWARD_CIRCLE_FILL("arrow.up.forward.circle.fill"), + ARROW_UP_FORWARD_SQUARE("arrow.up.forward.square"), + ARROW_UP_FORWARD_SQUARE_FILL("arrow.up.forward.square.fill"), + ARROW_UP_HEART("arrow.up.heart"), + ARROW_UP_HEART_FILL("arrow.up.heart.fill"), + ARROW_UP_LEFT("arrow.up.left"), + ARROW_UP_LEFT_AND_ARROW_DOWN_RIGHT("arrow.up.left.and.arrow.down.right"), + ARROW_UP_LEFT_AND_ARROW_DOWN_RIGHT_CIRCLE("arrow.up.left.and.arrow.down.right.circle"), + ARROW_UP_LEFT_AND_ARROW_DOWN_RIGHT_CIRCLE_FILL("arrow.up.left.and.arrow.down.right.circle.fill"), + ARROW_UP_LEFT_AND_ARROW_DOWN_RIGHT_RECTANGLE("arrow.up.left.and.arrow.down.right.rectangle"), + ARROW_UP_LEFT_AND_ARROW_DOWN_RIGHT_RECTANGLE_FILL("arrow.up.left.and.arrow.down.right.rectangle.fill"), + ARROW_UP_LEFT_AND_ARROW_DOWN_RIGHT_SQUARE("arrow.up.left.and.arrow.down.right.square"), + ARROW_UP_LEFT_AND_ARROW_DOWN_RIGHT_SQUARE_FILL("arrow.up.left.and.arrow.down.right.square.fill"), + ARROW_UP_LEFT_AND_DOWN_RIGHT_AND_ARROW_UP_RIGHT_AND_DOWN_LEFT("arrow.up.left.and.down.right.and.arrow.up.right.and.down.left"), + ARROW_UP_LEFT_AND_DOWN_RIGHT_MAGNIFYINGGLASS("arrow.up.left.and.down.right.magnifyingglass"), + ARROW_UP_LEFT_ARROW_DOWN_RIGHT("arrow.up.left.arrow.down.right"), + ARROW_UP_LEFT_ARROW_DOWN_RIGHT_CIRCLE("arrow.up.left.arrow.down.right.circle"), + ARROW_UP_LEFT_ARROW_DOWN_RIGHT_CIRCLE_FILL("arrow.up.left.arrow.down.right.circle.fill"), + ARROW_UP_LEFT_ARROW_DOWN_RIGHT_SQUARE("arrow.up.left.arrow.down.right.square"), + ARROW_UP_LEFT_ARROW_DOWN_RIGHT_SQUARE_FILL("arrow.up.left.arrow.down.right.square.fill"), + ARROW_UP_LEFT_BOTTOMRIGHT_RECTANGLE("arrow.up.left.bottomright.rectangle"), + ARROW_UP_LEFT_BOTTOMRIGHT_RECTANGLE_FILL("arrow.up.left.bottomright.rectangle.fill"), + ARROW_UP_LEFT_CIRCLE("arrow.up.left.circle"), + ARROW_UP_LEFT_CIRCLE_DOTTED("arrow.up.left.circle.dotted"), + ARROW_UP_LEFT_CIRCLE_FILL("arrow.up.left.circle.fill"), + ARROW_UP_LEFT_SQUARE("arrow.up.left.square"), + ARROW_UP_LEFT_SQUARE_FILL("arrow.up.left.square.fill"), + ARROW_UP_MESSAGE("arrow.up.message"), + ARROW_UP_MESSAGE_FILL("arrow.up.message.fill"), + ARROW_UP_PAGE_ON_CLIPBOARD("arrow.up.page.on.clipboard"), + ARROW_UP_RIGHT("arrow.up.right"), + ARROW_UP_RIGHT_AND_ARROW_DOWN_LEFT("arrow.up.right.and.arrow.down.left"), + ARROW_UP_RIGHT_AND_ARROW_DOWN_LEFT_CIRCLE("arrow.up.right.and.arrow.down.left.circle"), + ARROW_UP_RIGHT_AND_ARROW_DOWN_LEFT_CIRCLE_FILL("arrow.up.right.and.arrow.down.left.circle.fill"), + ARROW_UP_RIGHT_AND_ARROW_DOWN_LEFT_RECTANGLE("arrow.up.right.and.arrow.down.left.rectangle"), + ARROW_UP_RIGHT_AND_ARROW_DOWN_LEFT_RECTANGLE_FILL("arrow.up.right.and.arrow.down.left.rectangle.fill"), + ARROW_UP_RIGHT_AND_ARROW_DOWN_LEFT_SQUARE("arrow.up.right.and.arrow.down.left.square"), + ARROW_UP_RIGHT_AND_ARROW_DOWN_LEFT_SQUARE_FILL("arrow.up.right.and.arrow.down.left.square.fill"), + ARROW_UP_RIGHT_BOTTOMLEFT_RECTANGLE("arrow.up.right.bottomleft.rectangle"), + ARROW_UP_RIGHT_BOTTOMLEFT_RECTANGLE_FILL("arrow.up.right.bottomleft.rectangle.fill"), + ARROW_UP_RIGHT_CIRCLE("arrow.up.right.circle"), + ARROW_UP_RIGHT_CIRCLE_DOTTED("arrow.up.right.circle.dotted"), + ARROW_UP_RIGHT_CIRCLE_FILL("arrow.up.right.circle.fill"), + ARROW_UP_RIGHT_SQUARE("arrow.up.right.square"), + ARROW_UP_RIGHT_SQUARE_FILL("arrow.up.right.square.fill"), + ARROW_UP_RIGHT_VIDEO("arrow.up.right.video"), + ARROW_UP_RIGHT_VIDEO_FILL("arrow.up.right.video.fill"), + ARROW_UP_SQUARE("arrow.up.square"), + ARROW_UP_SQUARE_FILL("arrow.up.square.fill"), + ARROW_UP_TO_LINE("arrow.up.to.line"), + ARROW_UP_TO_LINE_CIRCLE("arrow.up.to.line.circle"), + ARROW_UP_TO_LINE_CIRCLE_FILL("arrow.up.to.line.circle.fill"), + ARROW_UP_TO_LINE_COMPACT("arrow.up.to.line.compact"), + ARROW_UP_TO_LINE_SQUARE("arrow.up.to.line.square"), + ARROW_UP_TO_LINE_SQUARE_FILL("arrow.up.to.line.square.fill"), + ARROW_UP_TRASH("arrow.up.trash"), + ARROW_UP_TRASH_FILL("arrow.up.trash.fill"), + ARROW_UTURN_BACKWARD("arrow.uturn.backward"), + ARROW_UTURN_BACKWARD_CIRCLE("arrow.uturn.backward.circle"), + ARROW_UTURN_BACKWARD_CIRCLE_BADGE_ELLIPSIS("arrow.uturn.backward.circle.badge.ellipsis"), + ARROW_UTURN_BACKWARD_CIRCLE_FILL("arrow.uturn.backward.circle.fill"), + ARROW_UTURN_BACKWARD_SQUARE("arrow.uturn.backward.square"), + ARROW_UTURN_BACKWARD_SQUARE_FILL("arrow.uturn.backward.square.fill"), + ARROW_UTURN_DOWN("arrow.uturn.down"), + ARROW_UTURN_DOWN_CIRCLE("arrow.uturn.down.circle"), + ARROW_UTURN_DOWN_CIRCLE_FILL("arrow.uturn.down.circle.fill"), + ARROW_UTURN_DOWN_SQUARE("arrow.uturn.down.square"), + ARROW_UTURN_DOWN_SQUARE_FILL("arrow.uturn.down.square.fill"), + ARROW_UTURN_FORWARD("arrow.uturn.forward"), + ARROW_UTURN_FORWARD_CIRCLE("arrow.uturn.forward.circle"), + ARROW_UTURN_FORWARD_CIRCLE_FILL("arrow.uturn.forward.circle.fill"), + ARROW_UTURN_FORWARD_SQUARE("arrow.uturn.forward.square"), + ARROW_UTURN_FORWARD_SQUARE_FILL("arrow.uturn.forward.square.fill"), + ARROW_UTURN_LEFT("arrow.uturn.left"), + ARROW_UTURN_LEFT_CIRCLE("arrow.uturn.left.circle"), + ARROW_UTURN_LEFT_CIRCLE_BADGE_ELLIPSIS("arrow.uturn.left.circle.badge.ellipsis"), + ARROW_UTURN_LEFT_CIRCLE_FILL("arrow.uturn.left.circle.fill"), + ARROW_UTURN_LEFT_SQUARE("arrow.uturn.left.square"), + ARROW_UTURN_LEFT_SQUARE_FILL("arrow.uturn.left.square.fill"), + ARROW_UTURN_RIGHT("arrow.uturn.right"), + ARROW_UTURN_RIGHT_CIRCLE("arrow.uturn.right.circle"), + ARROW_UTURN_RIGHT_CIRCLE_FILL("arrow.uturn.right.circle.fill"), + ARROW_UTURN_RIGHT_SQUARE("arrow.uturn.right.square"), + ARROW_UTURN_RIGHT_SQUARE_FILL("arrow.uturn.right.square.fill"), + ARROW_UTURN_UP("arrow.uturn.up"), + ARROW_UTURN_UP_CIRCLE("arrow.uturn.up.circle"), + ARROW_UTURN_UP_CIRCLE_FILL("arrow.uturn.up.circle.fill"), + ARROW_UTURN_UP_SQUARE("arrow.uturn.up.square"), + ARROW_UTURN_UP_SQUARE_FILL("arrow.uturn.up.square.fill"), + ARROWKEYS("arrowkeys"), + ARROWKEYS_DOWN_FILLED("arrowkeys.down.filled"), + ARROWKEYS_FILL("arrowkeys.fill"), + ARROWKEYS_LEFT_FILLED("arrowkeys.left.filled"), + ARROWKEYS_RIGHT_FILLED("arrowkeys.right.filled"), + ARROWKEYS_UP_FILLED("arrowkeys.up.filled"), + ARROWSHAPE_BACKWARD("arrowshape.backward"), + ARROWSHAPE_BACKWARD_CIRCLE("arrowshape.backward.circle"), + ARROWSHAPE_BACKWARD_CIRCLE_FILL("arrowshape.backward.circle.fill"), + ARROWSHAPE_BACKWARD_FILL("arrowshape.backward.fill"), + ARROWSHAPE_BOUNCE_FORWARD("arrowshape.bounce.forward"), + ARROWSHAPE_BOUNCE_FORWARD_FILL("arrowshape.bounce.forward.fill"), + ARROWSHAPE_BOUNCE_RIGHT("arrowshape.bounce.right"), + ARROWSHAPE_BOUNCE_RIGHT_FILL("arrowshape.bounce.right.fill"), + ARROWSHAPE_DOWN("arrowshape.down"), + ARROWSHAPE_DOWN_CIRCLE("arrowshape.down.circle"), + ARROWSHAPE_DOWN_CIRCLE_FILL("arrowshape.down.circle.fill"), + ARROWSHAPE_DOWN_FILL("arrowshape.down.fill"), + ARROWSHAPE_FORWARD("arrowshape.forward"), + ARROWSHAPE_FORWARD_CIRCLE("arrowshape.forward.circle"), + ARROWSHAPE_FORWARD_CIRCLE_FILL("arrowshape.forward.circle.fill"), + ARROWSHAPE_FORWARD_FILL("arrowshape.forward.fill"), + ARROWSHAPE_LEFT("arrowshape.left"), + ARROWSHAPE_LEFT_ARROWSHAPE_RIGHT("arrowshape.left.arrowshape.right"), + ARROWSHAPE_LEFT_ARROWSHAPE_RIGHT_FILL("arrowshape.left.arrowshape.right.fill"), + ARROWSHAPE_LEFT_CIRCLE("arrowshape.left.circle"), + ARROWSHAPE_LEFT_CIRCLE_FILL("arrowshape.left.circle.fill"), + ARROWSHAPE_LEFT_FILL("arrowshape.left.fill"), + ARROWSHAPE_RIGHT("arrowshape.right"), + ARROWSHAPE_RIGHT_CIRCLE("arrowshape.right.circle"), + ARROWSHAPE_RIGHT_CIRCLE_FILL("arrowshape.right.circle.fill"), + ARROWSHAPE_RIGHT_FILL("arrowshape.right.fill"), + ARROWSHAPE_TURN_UP_BACKWARD("arrowshape.turn.up.backward"), + ARROWSHAPE_TURN_UP_BACKWARD_2("arrowshape.turn.up.backward.2"), + ARROWSHAPE_TURN_UP_BACKWARD_2_CIRCLE("arrowshape.turn.up.backward.2.circle"), + ARROWSHAPE_TURN_UP_BACKWARD_2_CIRCLE_FILL("arrowshape.turn.up.backward.2.circle.fill"), + ARROWSHAPE_TURN_UP_BACKWARD_2_FILL("arrowshape.turn.up.backward.2.fill"), + ARROWSHAPE_TURN_UP_BACKWARD_BADGE_CLOCK("arrowshape.turn.up.backward.badge.clock"), + ARROWSHAPE_TURN_UP_BACKWARD_BADGE_CLOCK_FILL("arrowshape.turn.up.backward.badge.clock.fill"), + ARROWSHAPE_TURN_UP_BACKWARD_CIRCLE("arrowshape.turn.up.backward.circle"), + ARROWSHAPE_TURN_UP_BACKWARD_CIRCLE_FILL("arrowshape.turn.up.backward.circle.fill"), + ARROWSHAPE_TURN_UP_BACKWARD_FILL("arrowshape.turn.up.backward.fill"), + ARROWSHAPE_TURN_UP_FORWARD("arrowshape.turn.up.forward"), + ARROWSHAPE_TURN_UP_FORWARD_CIRCLE("arrowshape.turn.up.forward.circle"), + ARROWSHAPE_TURN_UP_FORWARD_CIRCLE_FILL("arrowshape.turn.up.forward.circle.fill"), + ARROWSHAPE_TURN_UP_FORWARD_FILL("arrowshape.turn.up.forward.fill"), + ARROWSHAPE_TURN_UP_LEFT("arrowshape.turn.up.left"), + ARROWSHAPE_TURN_UP_LEFT_2("arrowshape.turn.up.left.2"), + ARROWSHAPE_TURN_UP_LEFT_2_CIRCLE("arrowshape.turn.up.left.2.circle"), + ARROWSHAPE_TURN_UP_LEFT_2_CIRCLE_FILL("arrowshape.turn.up.left.2.circle.fill"), + ARROWSHAPE_TURN_UP_LEFT_2_FILL("arrowshape.turn.up.left.2.fill"), + ARROWSHAPE_TURN_UP_LEFT_CIRCLE("arrowshape.turn.up.left.circle"), + ARROWSHAPE_TURN_UP_LEFT_CIRCLE_FILL("arrowshape.turn.up.left.circle.fill"), + ARROWSHAPE_TURN_UP_LEFT_FILL("arrowshape.turn.up.left.fill"), + ARROWSHAPE_TURN_UP_RIGHT("arrowshape.turn.up.right"), + ARROWSHAPE_TURN_UP_RIGHT_CIRCLE("arrowshape.turn.up.right.circle"), + ARROWSHAPE_TURN_UP_RIGHT_CIRCLE_FILL("arrowshape.turn.up.right.circle.fill"), + ARROWSHAPE_TURN_UP_RIGHT_FILL("arrowshape.turn.up.right.fill"), + ARROWSHAPE_UP("arrowshape.up"), + ARROWSHAPE_UP_CIRCLE("arrowshape.up.circle"), + ARROWSHAPE_UP_CIRCLE_FILL("arrowshape.up.circle.fill"), + ARROWSHAPE_UP_FILL("arrowshape.up.fill"), + ARROWSHAPE_ZIGZAG_FORWARD("arrowshape.zigzag.forward"), + ARROWSHAPE_ZIGZAG_FORWARD_FILL("arrowshape.zigzag.forward.fill"), + ARROWSHAPE_ZIGZAG_RIGHT("arrowshape.zigzag.right"), + ARROWSHAPE_ZIGZAG_RIGHT_FILL("arrowshape.zigzag.right.fill"), + ARROWTRIANGLE_BACKWARD("arrowtriangle.backward"), + ARROWTRIANGLE_BACKWARD_CIRCLE("arrowtriangle.backward.circle"), + ARROWTRIANGLE_BACKWARD_CIRCLE_FILL("arrowtriangle.backward.circle.fill"), + ARROWTRIANGLE_BACKWARD_FILL("arrowtriangle.backward.fill"), + ARROWTRIANGLE_BACKWARD_SQUARE("arrowtriangle.backward.square"), + ARROWTRIANGLE_BACKWARD_SQUARE_FILL("arrowtriangle.backward.square.fill"), + ARROWTRIANGLE_DOWN("arrowtriangle.down"), + ARROWTRIANGLE_DOWN_CIRCLE("arrowtriangle.down.circle"), + ARROWTRIANGLE_DOWN_CIRCLE_FILL("arrowtriangle.down.circle.fill"), + ARROWTRIANGLE_DOWN_FILL("arrowtriangle.down.fill"), + ARROWTRIANGLE_DOWN_SQUARE("arrowtriangle.down.square"), + ARROWTRIANGLE_DOWN_SQUARE_FILL("arrowtriangle.down.square.fill"), + ARROWTRIANGLE_FORWARD("arrowtriangle.forward"), + ARROWTRIANGLE_FORWARD_CIRCLE("arrowtriangle.forward.circle"), + ARROWTRIANGLE_FORWARD_CIRCLE_FILL("arrowtriangle.forward.circle.fill"), + ARROWTRIANGLE_FORWARD_FILL("arrowtriangle.forward.fill"), + ARROWTRIANGLE_FORWARD_SQUARE("arrowtriangle.forward.square"), + ARROWTRIANGLE_FORWARD_SQUARE_FILL("arrowtriangle.forward.square.fill"), + ARROWTRIANGLE_LEFT("arrowtriangle.left"), + ARROWTRIANGLE_LEFT_AND_LINE_VERTICAL_AND_ARROWTRIANGLE_RIGHT("arrowtriangle.left.and.line.vertical.and.arrowtriangle.right"), + ARROWTRIANGLE_LEFT_AND_LINE_VERTICAL_AND_ARROWTRIANGLE_RIGHT_FILL("arrowtriangle.left.and.line.vertical.and.arrowtriangle.right.fill"), + ARROWTRIANGLE_LEFT_CIRCLE("arrowtriangle.left.circle"), + ARROWTRIANGLE_LEFT_CIRCLE_FILL("arrowtriangle.left.circle.fill"), + ARROWTRIANGLE_LEFT_FILL("arrowtriangle.left.fill"), + ARROWTRIANGLE_LEFT_SQUARE("arrowtriangle.left.square"), + ARROWTRIANGLE_LEFT_SQUARE_FILL("arrowtriangle.left.square.fill"), + ARROWTRIANGLE_RIGHT("arrowtriangle.right"), + ARROWTRIANGLE_RIGHT_AND_LINE_VERTICAL_AND_ARROWTRIANGLE_LEFT("arrowtriangle.right.and.line.vertical.and.arrowtriangle.left"), + ARROWTRIANGLE_RIGHT_AND_LINE_VERTICAL_AND_ARROWTRIANGLE_LEFT_FILL("arrowtriangle.right.and.line.vertical.and.arrowtriangle.left.fill"), + ARROWTRIANGLE_RIGHT_CIRCLE("arrowtriangle.right.circle"), + ARROWTRIANGLE_RIGHT_CIRCLE_FILL("arrowtriangle.right.circle.fill"), + ARROWTRIANGLE_RIGHT_FILL("arrowtriangle.right.fill"), + ARROWTRIANGLE_RIGHT_SQUARE("arrowtriangle.right.square"), + ARROWTRIANGLE_RIGHT_SQUARE_FILL("arrowtriangle.right.square.fill"), + ARROWTRIANGLE_UP("arrowtriangle.up"), + ARROWTRIANGLE_UP_ARROWTRIANGLE_DOWN_WINDOW_LEFT("arrowtriangle.up.arrowtriangle.down.window.left"), + ARROWTRIANGLE_UP_ARROWTRIANGLE_DOWN_WINDOW_RIGHT("arrowtriangle.up.arrowtriangle.down.window.right"), + ARROWTRIANGLE_UP_CIRCLE("arrowtriangle.up.circle"), + ARROWTRIANGLE_UP_CIRCLE_FILL("arrowtriangle.up.circle.fill"), + ARROWTRIANGLE_UP_FILL("arrowtriangle.up.fill"), + ARROWTRIANGLE_UP_SQUARE("arrowtriangle.up.square"), + ARROWTRIANGLE_UP_SQUARE_FILL("arrowtriangle.up.square.fill"), + CHEVRON_BACKWARD("chevron.backward"), + CHEVRON_BACKWARD_2("chevron.backward.2"), + CHEVRON_BACKWARD_CHEVRON_BACKWARD_DOTTED("chevron.backward.chevron.backward.dotted"), + CHEVRON_BACKWARD_CIRCLE("chevron.backward.circle"), + CHEVRON_BACKWARD_CIRCLE_FILL("chevron.backward.circle.fill"), + CHEVRON_BACKWARD_SQUARE("chevron.backward.square"), + CHEVRON_BACKWARD_SQUARE_FILL("chevron.backward.square.fill"), + CHEVRON_BACKWARD_TO_LINE("chevron.backward.to.line"), + CHEVRON_COMPACT_BACKWARD("chevron.compact.backward"), + CHEVRON_COMPACT_DOWN("chevron.compact.down"), + CHEVRON_COMPACT_FORWARD("chevron.compact.forward"), + CHEVRON_COMPACT_LEFT("chevron.compact.left"), + CHEVRON_COMPACT_LEFT_CHEVRON_COMPACT_RIGHT("chevron.compact.left.chevron.compact.right"), + CHEVRON_COMPACT_RIGHT("chevron.compact.right"), + CHEVRON_COMPACT_UP("chevron.compact.up"), + CHEVRON_COMPACT_UP_CHEVRON_COMPACT_DOWN("chevron.compact.up.chevron.compact.down"), + CHEVRON_COMPACT_UP_CHEVRON_COMPACT_RIGHT_CHEVRON_COMPACT_DOWN_CHEVRON_COMPACT_LEFT("chevron.compact.up.chevron.compact.right.chevron.compact.down.chevron.compact.left"), + CHEVRON_DOWN("chevron.down"), + CHEVRON_DOWN_2("chevron.down.2"), + CHEVRON_DOWN_CIRCLE("chevron.down.circle"), + CHEVRON_DOWN_CIRCLE_FILL("chevron.down.circle.fill"), + CHEVRON_DOWN_DOTTED_2("chevron.down.dotted.2"), + CHEVRON_DOWN_FORWARD_2("chevron.down.forward.2"), + CHEVRON_DOWN_FORWARD_DOTTED_2("chevron.down.forward.dotted.2"), + CHEVRON_DOWN_RIGHT_2("chevron.down.right.2"), + CHEVRON_DOWN_RIGHT_DOTTED_2("chevron.down.right.dotted.2"), + CHEVRON_DOWN_SQUARE("chevron.down.square"), + CHEVRON_DOWN_SQUARE_FILL("chevron.down.square.fill"), + CHEVRON_FORWARD("chevron.forward"), + CHEVRON_FORWARD_2("chevron.forward.2"), + CHEVRON_FORWARD_CIRCLE("chevron.forward.circle"), + CHEVRON_FORWARD_CIRCLE_FILL("chevron.forward.circle.fill"), + CHEVRON_FORWARD_DOTTED_CHEVRON_FORWARD("chevron.forward.dotted.chevron.forward"), + CHEVRON_FORWARD_SQUARE("chevron.forward.square"), + CHEVRON_FORWARD_SQUARE_FILL("chevron.forward.square.fill"), + CHEVRON_FORWARD_TO_LINE("chevron.forward.to.line"), + CHEVRON_LEFT("chevron.left"), + CHEVRON_LEFT_2("chevron.left.2"), + CHEVRON_LEFT_CHEVRON_LEFT_DOTTED("chevron.left.chevron.left.dotted"), + CHEVRON_LEFT_CHEVRON_RIGHT("chevron.left.chevron.right"), + CHEVRON_LEFT_CIRCLE("chevron.left.circle"), + CHEVRON_LEFT_CIRCLE_FILL("chevron.left.circle.fill"), + CHEVRON_LEFT_FORWARDSLASH_CHEVRON_RIGHT("chevron.left.forwardslash.chevron.right"), + CHEVRON_LEFT_SQUARE("chevron.left.square"), + CHEVRON_LEFT_SQUARE_FILL("chevron.left.square.fill"), + CHEVRON_LEFT_TO_LINE("chevron.left.to.line"), + CHEVRON_RIGHT("chevron.right"), + CHEVRON_RIGHT_2("chevron.right.2"), + CHEVRON_RIGHT_CIRCLE("chevron.right.circle"), + CHEVRON_RIGHT_CIRCLE_FILL("chevron.right.circle.fill"), + CHEVRON_RIGHT_DOTTED_CHEVRON_RIGHT("chevron.right.dotted.chevron.right"), + CHEVRON_RIGHT_SQUARE("chevron.right.square"), + CHEVRON_RIGHT_SQUARE_FILL("chevron.right.square.fill"), + CHEVRON_RIGHT_TO_LINE("chevron.right.to.line"), + CHEVRON_UP("chevron.up"), + CHEVRON_UP_2("chevron.up.2"), + CHEVRON_UP_CHEVRON_DOWN("chevron.up.chevron.down"), + CHEVRON_UP_CHEVRON_DOWN_SQUARE("chevron.up.chevron.down.square"), + CHEVRON_UP_CHEVRON_DOWN_SQUARE_FILL("chevron.up.chevron.down.square.fill"), + CHEVRON_UP_CHEVRON_RIGHT_CHEVRON_DOWN_CHEVRON_LEFT("chevron.up.chevron.right.chevron.down.chevron.left"), + CHEVRON_UP_CIRCLE("chevron.up.circle"), + CHEVRON_UP_CIRCLE_FILL("chevron.up.circle.fill"), + CHEVRON_UP_DOTTED_2("chevron.up.dotted.2"), + CHEVRON_UP_FORWARD_2("chevron.up.forward.2"), + CHEVRON_UP_FORWARD_DOTTED_2("chevron.up.forward.dotted.2"), + CHEVRON_UP_RIGHT_2("chevron.up.right.2"), + CHEVRON_UP_RIGHT_DOTTED_2("chevron.up.right.dotted.2"), + CHEVRON_UP_SQUARE("chevron.up.square"), + CHEVRON_UP_SQUARE_FILL("chevron.up.square.fill"), + ESCAPE("escape"), + RETURN("return"), + RETURN_LEFT("return.left"), + RETURN_RIGHT("return.right"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolCommerce.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolCommerce.kt new file mode 100644 index 00000000..19e0d20f --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolCommerce.kt @@ -0,0 +1,271 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Commerce (264 symbols). */ +enum class SFSymbolCommerce( + override val symbolName: String, +) : SFSymbol { + BAG("bag"), + BAG_BADGE_MINUS("bag.badge.minus"), + BAG_BADGE_PLUS("bag.badge.plus"), + BAG_BADGE_QUESTIONMARK("bag.badge.questionmark"), + BAG_CIRCLE("bag.circle"), + BAG_CIRCLE_FILL("bag.circle.fill"), + BAG_FILL("bag.fill"), + BAG_FILL_BADGE_MINUS("bag.fill.badge.minus"), + BAG_FILL_BADGE_PLUS("bag.fill.badge.plus"), + BAG_FILL_BADGE_QUESTIONMARK("bag.fill.badge.questionmark"), + BAHTSIGN("bahtsign"), + BAHTSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("bahtsign.arrow.trianglehead.counterclockwise.rotate.90"), + BAHTSIGN_BANK_BUILDING("bahtsign.bank.building"), + BAHTSIGN_BANK_BUILDING_FILL("bahtsign.bank.building.fill"), + BAHTSIGN_CIRCLE("bahtsign.circle"), + BAHTSIGN_CIRCLE_FILL("bahtsign.circle.fill"), + BAHTSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("bahtsign.gauge.chart.lefthalf.righthalf"), + BAHTSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("bahtsign.gauge.chart.leftthird.topthird.rightthird"), + BAHTSIGN_SQUARE("bahtsign.square"), + BAHTSIGN_SQUARE_FILL("bahtsign.square.fill"), + BANKNOTE("banknote"), + BANKNOTE_FILL("banknote.fill"), + BITCOINSIGN("bitcoinsign"), + BITCOINSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("bitcoinsign.arrow.trianglehead.counterclockwise.rotate.90"), + BITCOINSIGN_BANK_BUILDING("bitcoinsign.bank.building"), + BITCOINSIGN_BANK_BUILDING_FILL("bitcoinsign.bank.building.fill"), + BITCOINSIGN_CIRCLE("bitcoinsign.circle"), + BITCOINSIGN_CIRCLE_FILL("bitcoinsign.circle.fill"), + BITCOINSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("bitcoinsign.gauge.chart.lefthalf.righthalf"), + BITCOINSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("bitcoinsign.gauge.chart.leftthird.topthird.rightthird"), + BITCOINSIGN_SQUARE("bitcoinsign.square"), + BITCOINSIGN_SQUARE_FILL("bitcoinsign.square.fill"), + BRAZILIANREALSIGN("brazilianrealsign"), + BRAZILIANREALSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("brazilianrealsign.arrow.trianglehead.counterclockwise.rotate.90"), + BRAZILIANREALSIGN_BANK_BUILDING("brazilianrealsign.bank.building"), + BRAZILIANREALSIGN_BANK_BUILDING_FILL("brazilianrealsign.bank.building.fill"), + BRAZILIANREALSIGN_CIRCLE("brazilianrealsign.circle"), + BRAZILIANREALSIGN_CIRCLE_FILL("brazilianrealsign.circle.fill"), + BRAZILIANREALSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("brazilianrealsign.gauge.chart.lefthalf.righthalf"), + BRAZILIANREALSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("brazilianrealsign.gauge.chart.leftthird.topthird.rightthird"), + BRAZILIANREALSIGN_SQUARE("brazilianrealsign.square"), + BRAZILIANREALSIGN_SQUARE_FILL("brazilianrealsign.square.fill"), + CENTSIGN("centsign"), + CENTSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("centsign.arrow.trianglehead.counterclockwise.rotate.90"), + CENTSIGN_BANK_BUILDING("centsign.bank.building"), + CENTSIGN_BANK_BUILDING_FILL("centsign.bank.building.fill"), + CENTSIGN_CIRCLE("centsign.circle"), + CENTSIGN_CIRCLE_FILL("centsign.circle.fill"), + CENTSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("centsign.gauge.chart.lefthalf.righthalf"), + CENTSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("centsign.gauge.chart.leftthird.topthird.rightthird"), + CENTSIGN_SQUARE("centsign.square"), + CENTSIGN_SQUARE_FILL("centsign.square.fill"), + COLONCURRENCYSIGN("coloncurrencysign"), + COLONCURRENCYSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("coloncurrencysign.arrow.trianglehead.counterclockwise.rotate.90"), + COLONCURRENCYSIGN_BANK_BUILDING("coloncurrencysign.bank.building"), + COLONCURRENCYSIGN_BANK_BUILDING_FILL("coloncurrencysign.bank.building.fill"), + COLONCURRENCYSIGN_CIRCLE("coloncurrencysign.circle"), + COLONCURRENCYSIGN_CIRCLE_FILL("coloncurrencysign.circle.fill"), + COLONCURRENCYSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("coloncurrencysign.gauge.chart.lefthalf.righthalf"), + COLONCURRENCYSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("coloncurrencysign.gauge.chart.leftthird.topthird.rightthird"), + COLONCURRENCYSIGN_SQUARE("coloncurrencysign.square"), + COLONCURRENCYSIGN_SQUARE_FILL("coloncurrencysign.square.fill"), + CREDITCARD("creditcard"), + CREDITCARD_AND_123("creditcard.and.123"), + CREDITCARD_CIRCLE("creditcard.circle"), + CREDITCARD_CIRCLE_FILL("creditcard.circle.fill"), + CREDITCARD_FILL("creditcard.fill"), + CREDITCARD_TRIANGLEBADGE_EXCLAMATIONMARK("creditcard.trianglebadge.exclamationmark"), + CREDITCARD_TRIANGLEBADGE_EXCLAMATIONMARK_FILL("creditcard.trianglebadge.exclamationmark.fill"), + CREDITCARD_VIEWFINDER("creditcard.viewfinder"), + CRUZEIROSIGN("cruzeirosign"), + CRUZEIROSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("cruzeirosign.arrow.trianglehead.counterclockwise.rotate.90"), + CRUZEIROSIGN_BANK_BUILDING("cruzeirosign.bank.building"), + CRUZEIROSIGN_BANK_BUILDING_FILL("cruzeirosign.bank.building.fill"), + CRUZEIROSIGN_CIRCLE("cruzeirosign.circle"), + CRUZEIROSIGN_CIRCLE_FILL("cruzeirosign.circle.fill"), + CRUZEIROSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("cruzeirosign.gauge.chart.lefthalf.righthalf"), + CRUZEIROSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("cruzeirosign.gauge.chart.leftthird.topthird.rightthird"), + CRUZEIROSIGN_SQUARE("cruzeirosign.square"), + CRUZEIROSIGN_SQUARE_FILL("cruzeirosign.square.fill"), + DOLLARSIGN("dollarsign"), + DOLLARSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("dollarsign.arrow.trianglehead.counterclockwise.rotate.90"), + DOLLARSIGN_BANK_BUILDING("dollarsign.bank.building"), + DOLLARSIGN_BANK_BUILDING_FILL("dollarsign.bank.building.fill"), + DOLLARSIGN_CIRCLE("dollarsign.circle"), + DOLLARSIGN_CIRCLE_FILL("dollarsign.circle.fill"), + DOLLARSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("dollarsign.gauge.chart.lefthalf.righthalf"), + DOLLARSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("dollarsign.gauge.chart.leftthird.topthird.rightthird"), + DOLLARSIGN_SQUARE("dollarsign.square"), + DOLLARSIGN_SQUARE_FILL("dollarsign.square.fill"), + EUROSIGN("eurosign"), + EUROSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("eurosign.arrow.trianglehead.counterclockwise.rotate.90"), + EUROSIGN_BANK_BUILDING("eurosign.bank.building"), + EUROSIGN_BANK_BUILDING_FILL("eurosign.bank.building.fill"), + EUROSIGN_CIRCLE("eurosign.circle"), + EUROSIGN_CIRCLE_FILL("eurosign.circle.fill"), + EUROSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("eurosign.gauge.chart.lefthalf.righthalf"), + EUROSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("eurosign.gauge.chart.leftthird.topthird.rightthird"), + EUROSIGN_SQUARE("eurosign.square"), + EUROSIGN_SQUARE_FILL("eurosign.square.fill"), + FRANCSIGN("francsign"), + FRANCSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("francsign.arrow.trianglehead.counterclockwise.rotate.90"), + FRANCSIGN_BANK_BUILDING("francsign.bank.building"), + FRANCSIGN_BANK_BUILDING_FILL("francsign.bank.building.fill"), + FRANCSIGN_CIRCLE("francsign.circle"), + FRANCSIGN_CIRCLE_FILL("francsign.circle.fill"), + FRANCSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("francsign.gauge.chart.lefthalf.righthalf"), + FRANCSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("francsign.gauge.chart.leftthird.topthird.rightthird"), + FRANCSIGN_SQUARE("francsign.square"), + FRANCSIGN_SQUARE_FILL("francsign.square.fill"), + GIFT("gift"), + GIFT_CIRCLE("gift.circle"), + GIFT_CIRCLE_FILL("gift.circle.fill"), + GIFT_FILL("gift.fill"), + GIFTCARD("giftcard"), + GIFTCARD_FILL("giftcard.fill"), + GUARANISIGN("guaranisign"), + GUARANISIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("guaranisign.arrow.trianglehead.counterclockwise.rotate.90"), + GUARANISIGN_BANK_BUILDING("guaranisign.bank.building"), + GUARANISIGN_BANK_BUILDING_FILL("guaranisign.bank.building.fill"), + GUARANISIGN_CIRCLE("guaranisign.circle"), + GUARANISIGN_CIRCLE_FILL("guaranisign.circle.fill"), + GUARANISIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("guaranisign.gauge.chart.lefthalf.righthalf"), + GUARANISIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("guaranisign.gauge.chart.leftthird.topthird.rightthird"), + GUARANISIGN_SQUARE("guaranisign.square"), + GUARANISIGN_SQUARE_FILL("guaranisign.square.fill"), + KIPSIGN("kipsign"), + KIPSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("kipsign.arrow.trianglehead.counterclockwise.rotate.90"), + KIPSIGN_BANK_BUILDING("kipsign.bank.building"), + KIPSIGN_BANK_BUILDING_FILL("kipsign.bank.building.fill"), + KIPSIGN_CIRCLE("kipsign.circle"), + KIPSIGN_CIRCLE_FILL("kipsign.circle.fill"), + KIPSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("kipsign.gauge.chart.lefthalf.righthalf"), + KIPSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("kipsign.gauge.chart.leftthird.topthird.rightthird"), + KIPSIGN_SQUARE("kipsign.square"), + KIPSIGN_SQUARE_FILL("kipsign.square.fill"), + LARISIGN("larisign"), + LARISIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("larisign.arrow.trianglehead.counterclockwise.rotate.90"), + LARISIGN_BANK_BUILDING("larisign.bank.building"), + LARISIGN_BANK_BUILDING_FILL("larisign.bank.building.fill"), + LARISIGN_CIRCLE("larisign.circle"), + LARISIGN_CIRCLE_FILL("larisign.circle.fill"), + LARISIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("larisign.gauge.chart.lefthalf.righthalf"), + LARISIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("larisign.gauge.chart.leftthird.topthird.rightthird"), + LARISIGN_SQUARE("larisign.square"), + LARISIGN_SQUARE_FILL("larisign.square.fill"), + MANATSIGN("manatsign"), + MANATSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("manatsign.arrow.trianglehead.counterclockwise.rotate.90"), + MANATSIGN_BANK_BUILDING("manatsign.bank.building"), + MANATSIGN_BANK_BUILDING_FILL("manatsign.bank.building.fill"), + MANATSIGN_CIRCLE("manatsign.circle"), + MANATSIGN_CIRCLE_FILL("manatsign.circle.fill"), + MANATSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("manatsign.gauge.chart.lefthalf.righthalf"), + MANATSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("manatsign.gauge.chart.leftthird.topthird.rightthird"), + MANATSIGN_SQUARE("manatsign.square"), + MANATSIGN_SQUARE_FILL("manatsign.square.fill"), + PESOSIGN("pesosign"), + PESOSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("pesosign.arrow.trianglehead.counterclockwise.rotate.90"), + PESOSIGN_BANK_BUILDING("pesosign.bank.building"), + PESOSIGN_BANK_BUILDING_FILL("pesosign.bank.building.fill"), + PESOSIGN_CIRCLE("pesosign.circle"), + PESOSIGN_CIRCLE_FILL("pesosign.circle.fill"), + PESOSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("pesosign.gauge.chart.lefthalf.righthalf"), + PESOSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("pesosign.gauge.chart.leftthird.topthird.rightthird"), + PESOSIGN_SQUARE("pesosign.square"), + PESOSIGN_SQUARE_FILL("pesosign.square.fill"), + RUBLESIGN("rublesign"), + RUBLESIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("rublesign.arrow.trianglehead.counterclockwise.rotate.90"), + RUBLESIGN_BANK_BUILDING("rublesign.bank.building"), + RUBLESIGN_BANK_BUILDING_FILL("rublesign.bank.building.fill"), + RUBLESIGN_CIRCLE("rublesign.circle"), + RUBLESIGN_CIRCLE_FILL("rublesign.circle.fill"), + RUBLESIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("rublesign.gauge.chart.lefthalf.righthalf"), + RUBLESIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("rublesign.gauge.chart.leftthird.topthird.rightthird"), + RUBLESIGN_SQUARE("rublesign.square"), + RUBLESIGN_SQUARE_FILL("rublesign.square.fill"), + RUPEESIGN("rupeesign"), + RUPEESIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("rupeesign.arrow.trianglehead.counterclockwise.rotate.90"), + RUPEESIGN_BANK_BUILDING("rupeesign.bank.building"), + RUPEESIGN_BANK_BUILDING_FILL("rupeesign.bank.building.fill"), + RUPEESIGN_CIRCLE("rupeesign.circle"), + RUPEESIGN_CIRCLE_FILL("rupeesign.circle.fill"), + RUPEESIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("rupeesign.gauge.chart.lefthalf.righthalf"), + RUPEESIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("rupeesign.gauge.chart.leftthird.topthird.rightthird"), + RUPEESIGN_SQUARE("rupeesign.square"), + RUPEESIGN_SQUARE_FILL("rupeesign.square.fill"), + SHEKELSIGN("shekelsign"), + SHEKELSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("shekelsign.arrow.trianglehead.counterclockwise.rotate.90"), + SHEKELSIGN_BANK_BUILDING("shekelsign.bank.building"), + SHEKELSIGN_BANK_BUILDING_FILL("shekelsign.bank.building.fill"), + SHEKELSIGN_CIRCLE("shekelsign.circle"), + SHEKELSIGN_CIRCLE_FILL("shekelsign.circle.fill"), + SHEKELSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("shekelsign.gauge.chart.lefthalf.righthalf"), + SHEKELSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("shekelsign.gauge.chart.leftthird.topthird.rightthird"), + SHEKELSIGN_SQUARE("shekelsign.square"), + SHEKELSIGN_SQUARE_FILL("shekelsign.square.fill"), + STERLINGSIGN("sterlingsign"), + STERLINGSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("sterlingsign.arrow.trianglehead.counterclockwise.rotate.90"), + STERLINGSIGN_BANK_BUILDING("sterlingsign.bank.building"), + STERLINGSIGN_BANK_BUILDING_FILL("sterlingsign.bank.building.fill"), + STERLINGSIGN_CIRCLE("sterlingsign.circle"), + STERLINGSIGN_CIRCLE_FILL("sterlingsign.circle.fill"), + STERLINGSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("sterlingsign.gauge.chart.lefthalf.righthalf"), + STERLINGSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("sterlingsign.gauge.chart.leftthird.topthird.rightthird"), + STERLINGSIGN_SQUARE("sterlingsign.square"), + STERLINGSIGN_SQUARE_FILL("sterlingsign.square.fill"), + TAG("tag"), + TAG_CIRCLE("tag.circle"), + TAG_CIRCLE_FILL("tag.circle.fill"), + TAG_FILL("tag.fill"), + TAG_SLASH("tag.slash"), + TAG_SLASH_FILL("tag.slash.fill"), + TAG_SQUARE("tag.square"), + TAG_SQUARE_FILL("tag.square.fill"), + TENGESIGN("tengesign"), + TENGESIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("tengesign.arrow.trianglehead.counterclockwise.rotate.90"), + TENGESIGN_BANK_BUILDING("tengesign.bank.building"), + TENGESIGN_BANK_BUILDING_FILL("tengesign.bank.building.fill"), + TENGESIGN_CIRCLE("tengesign.circle"), + TENGESIGN_CIRCLE_FILL("tengesign.circle.fill"), + TENGESIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("tengesign.gauge.chart.lefthalf.righthalf"), + TENGESIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("tengesign.gauge.chart.leftthird.topthird.rightthird"), + TENGESIGN_SQUARE("tengesign.square"), + TENGESIGN_SQUARE_FILL("tengesign.square.fill"), + TUGRIKSIGN("tugriksign"), + TUGRIKSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("tugriksign.arrow.trianglehead.counterclockwise.rotate.90"), + TUGRIKSIGN_BANK_BUILDING("tugriksign.bank.building"), + TUGRIKSIGN_BANK_BUILDING_FILL("tugriksign.bank.building.fill"), + TUGRIKSIGN_CIRCLE("tugriksign.circle"), + TUGRIKSIGN_CIRCLE_FILL("tugriksign.circle.fill"), + TUGRIKSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("tugriksign.gauge.chart.lefthalf.righthalf"), + TUGRIKSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("tugriksign.gauge.chart.leftthird.topthird.rightthird"), + TUGRIKSIGN_SQUARE("tugriksign.square"), + TUGRIKSIGN_SQUARE_FILL("tugriksign.square.fill"), + TURKISHLIRASIGN("turkishlirasign"), + TURKISHLIRASIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("turkishlirasign.arrow.trianglehead.counterclockwise.rotate.90"), + TURKISHLIRASIGN_BANK_BUILDING("turkishlirasign.bank.building"), + TURKISHLIRASIGN_BANK_BUILDING_FILL("turkishlirasign.bank.building.fill"), + TURKISHLIRASIGN_CIRCLE("turkishlirasign.circle"), + TURKISHLIRASIGN_CIRCLE_FILL("turkishlirasign.circle.fill"), + TURKISHLIRASIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("turkishlirasign.gauge.chart.lefthalf.righthalf"), + TURKISHLIRASIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("turkishlirasign.gauge.chart.leftthird.topthird.rightthird"), + TURKISHLIRASIGN_SQUARE("turkishlirasign.square"), + TURKISHLIRASIGN_SQUARE_FILL("turkishlirasign.square.fill"), + WONSIGN("wonsign"), + WONSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("wonsign.arrow.trianglehead.counterclockwise.rotate.90"), + WONSIGN_BANK_BUILDING("wonsign.bank.building"), + WONSIGN_BANK_BUILDING_FILL("wonsign.bank.building.fill"), + WONSIGN_CIRCLE("wonsign.circle"), + WONSIGN_CIRCLE_FILL("wonsign.circle.fill"), + WONSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("wonsign.gauge.chart.lefthalf.righthalf"), + WONSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("wonsign.gauge.chart.leftthird.topthird.rightthird"), + WONSIGN_SQUARE("wonsign.square"), + WONSIGN_SQUARE_FILL("wonsign.square.fill"), + YENSIGN("yensign"), + YENSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("yensign.arrow.trianglehead.counterclockwise.rotate.90"), + YENSIGN_BANK_BUILDING("yensign.bank.building"), + YENSIGN_BANK_BUILDING_FILL("yensign.bank.building.fill"), + YENSIGN_CIRCLE("yensign.circle"), + YENSIGN_CIRCLE_FILL("yensign.circle.fill"), + YENSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("yensign.gauge.chart.lefthalf.righthalf"), + YENSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("yensign.gauge.chart.leftthird.topthird.rightthird"), + YENSIGN_SQUARE("yensign.square"), + YENSIGN_SQUARE_FILL("yensign.square.fill"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolCommunication.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolCommunication.kt new file mode 100644 index 00000000..3a23e37e --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolCommunication.kt @@ -0,0 +1,108 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Communication (101 symbols). */ +enum class SFSymbolCommunication( + override val symbolName: String, +) : SFSymbol { + ANTENNA_RADIOWAVES_LEFT_AND_RIGHT("antenna.radiowaves.left.and.right"), + ANTENNA_RADIOWAVES_LEFT_AND_RIGHT_CIRCLE("antenna.radiowaves.left.and.right.circle"), + ANTENNA_RADIOWAVES_LEFT_AND_RIGHT_CIRCLE_FILL("antenna.radiowaves.left.and.right.circle.fill"), + ANTENNA_RADIOWAVES_LEFT_AND_RIGHT_SLASH("antenna.radiowaves.left.and.right.slash"), + ANTENNA_RADIOWAVES_LEFT_AND_RIGHT_SLASH_CIRCLE("antenna.radiowaves.left.and.right.slash.circle"), + ANTENNA_RADIOWAVES_LEFT_AND_RIGHT_SLASH_CIRCLE_FILL("antenna.radiowaves.left.and.right.slash.circle.fill"), + BUBBLE("bubble"), + BUBBLE_AND_PENCIL("bubble.and.pencil"), + BUBBLE_CIRCLE("bubble.circle"), + BUBBLE_CIRCLE_FILL("bubble.circle.fill"), + BUBBLE_FILL("bubble.fill"), + BUBBLE_LEFT("bubble.left"), + BUBBLE_LEFT_AND_BUBBLE_RIGHT("bubble.left.and.bubble.right"), + BUBBLE_LEFT_AND_BUBBLE_RIGHT_FILL("bubble.left.and.bubble.right.fill"), + BUBBLE_LEFT_AND_EXCLAMATIONMARK_BUBBLE_RIGHT("bubble.left.and.exclamationmark.bubble.right"), + BUBBLE_LEFT_AND_EXCLAMATIONMARK_BUBBLE_RIGHT_FILL("bubble.left.and.exclamationmark.bubble.right.fill"), + BUBBLE_LEFT_AND_TEXT_BUBBLE_RIGHT("bubble.left.and.text.bubble.right"), + BUBBLE_LEFT_AND_TEXT_BUBBLE_RIGHT_FILL("bubble.left.and.text.bubble.right.fill"), + BUBBLE_LEFT_CIRCLE("bubble.left.circle"), + BUBBLE_LEFT_CIRCLE_FILL("bubble.left.circle.fill"), + BUBBLE_LEFT_FILL("bubble.left.fill"), + BUBBLE_MIDDLE_BOTTOM("bubble.middle.bottom"), + BUBBLE_MIDDLE_BOTTOM_FILL("bubble.middle.bottom.fill"), + BUBBLE_MIDDLE_TOP("bubble.middle.top"), + BUBBLE_MIDDLE_TOP_FILL("bubble.middle.top.fill"), + BUBBLE_RIGHT("bubble.right"), + BUBBLE_RIGHT_CIRCLE("bubble.right.circle"), + BUBBLE_RIGHT_CIRCLE_FILL("bubble.right.circle.fill"), + BUBBLE_RIGHT_FILL("bubble.right.fill"), + BUBBLES_AND_SPARKLES("bubbles.and.sparkles"), + BUBBLES_AND_SPARKLES_FILL("bubbles.and.sparkles.fill"), + ENVELOPE("envelope"), + ENVELOPE_AND_ARROW_TRIANGLEHEAD_BRANCH("envelope.and.arrow.trianglehead.branch"), + ENVELOPE_AND_ARROW_TRIANGLEHEAD_BRANCH_FILL("envelope.and.arrow.trianglehead.branch.fill"), + ENVELOPE_BADGE("envelope.badge"), + ENVELOPE_BADGE_FILL("envelope.badge.fill"), + ENVELOPE_BADGE_PERSON_CROP("envelope.badge.person.crop"), + ENVELOPE_BADGE_PERSON_CROP_FILL("envelope.badge.person.crop.fill"), + ENVELOPE_BADGE_SHIELD_HALF_FILLED("envelope.badge.shield.half.filled"), + ENVELOPE_BADGE_SHIELD_HALF_FILLED_FILL("envelope.badge.shield.half.filled.fill"), + ENVELOPE_CIRCLE("envelope.circle"), + ENVELOPE_CIRCLE_FILL("envelope.circle.fill"), + ENVELOPE_FILL("envelope.fill"), + ENVELOPE_FRONT("envelope.front"), + ENVELOPE_FRONT_FILL("envelope.front.fill"), + ENVELOPE_OPEN("envelope.open"), + ENVELOPE_OPEN_BADGE_CLOCK("envelope.open.badge.clock"), + ENVELOPE_OPEN_FILL("envelope.open.fill"), + MAIL("mail"), + MAIL_AND_TEXT_MAGNIFYINGGLASS("mail.and.text.magnifyingglass"), + MAIL_FILL("mail.fill"), + MAIL_STACK("mail.stack"), + MAIL_STACK_FILL("mail.stack.fill"), + MEGAPHONE("megaphone"), + MEGAPHONE_FILL("megaphone.fill"), + MESSAGE("message"), + MESSAGE_BADGE("message.badge"), + MESSAGE_BADGE_CIRCLE("message.badge.circle"), + MESSAGE_BADGE_CIRCLE_FILL("message.badge.circle.fill"), + MESSAGE_BADGE_FILL("message.badge.fill"), + MESSAGE_BADGE_FILLED_FILL("message.badge.filled.fill"), + MESSAGE_BADGE_WAVEFORM("message.badge.waveform"), + MESSAGE_BADGE_WAVEFORM_FILL("message.badge.waveform.fill"), + MESSAGE_CIRCLE("message.circle"), + MESSAGE_CIRCLE_FILL("message.circle.fill"), + MESSAGE_FILL("message.fill"), + PHONE("phone"), + PHONE_ARROW_DOWN_LEFT("phone.arrow.down.left"), + PHONE_ARROW_DOWN_LEFT_FILL("phone.arrow.down.left.fill"), + PHONE_ARROW_RIGHT("phone.arrow.right"), + PHONE_ARROW_RIGHT_FILL("phone.arrow.right.fill"), + PHONE_ARROW_UP_RIGHT("phone.arrow.up.right"), + PHONE_ARROW_UP_RIGHT_CIRCLE("phone.arrow.up.right.circle"), + PHONE_ARROW_UP_RIGHT_CIRCLE_FILL("phone.arrow.up.right.circle.fill"), + PHONE_ARROW_UP_RIGHT_FILL("phone.arrow.up.right.fill"), + PHONE_BADGE_CHECKMARK("phone.badge.checkmark"), + PHONE_BADGE_CLOCK("phone.badge.clock"), + PHONE_BADGE_CLOCK_FILL("phone.badge.clock.fill"), + PHONE_BADGE_PLUS("phone.badge.plus"), + PHONE_BADGE_WAVEFORM("phone.badge.waveform"), + PHONE_BADGE_WAVEFORM_FILL("phone.badge.waveform.fill"), + PHONE_BUBBLE("phone.bubble"), + PHONE_BUBBLE_FILL("phone.bubble.fill"), + PHONE_CIRCLE("phone.circle"), + PHONE_CIRCLE_FILL("phone.circle.fill"), + PHONE_CONNECTION("phone.connection"), + PHONE_CONNECTION_FILL("phone.connection.fill"), + PHONE_DOWN("phone.down"), + PHONE_DOWN_CIRCLE("phone.down.circle"), + PHONE_DOWN_CIRCLE_FILL("phone.down.circle.fill"), + PHONE_DOWN_FILL("phone.down.fill"), + PHONE_DOWN_WAVES_LEFT_AND_RIGHT("phone.down.waves.left.and.right"), + PHONE_FILL("phone.fill"), + PHONE_FILL_BADGE_CHECKMARK("phone.fill.badge.checkmark"), + PHONE_FILL_BADGE_PLUS("phone.fill.badge.plus"), + TELETYPE("teletype"), + TELETYPE_ANSWER("teletype.answer"), + TELETYPE_ANSWER_CIRCLE("teletype.answer.circle"), + TELETYPE_ANSWER_CIRCLE_FILL("teletype.answer.circle.fill"), + TELETYPE_CIRCLE("teletype.circle"), + TELETYPE_CIRCLE_FILL("teletype.circle.fill"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolConnectivity.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolConnectivity.kt new file mode 100644 index 00000000..411e1ee7 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolConnectivity.kt @@ -0,0 +1,34 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Connectivity (27 symbols). */ +enum class SFSymbolConnectivity( + override val symbolName: String, +) : SFSymbol { + CABLE_COAXIAL("cable.coaxial"), + CABLE_CONNECTOR("cable.connector"), + CABLE_CONNECTOR_HORIZONTAL("cable.connector.horizontal"), + CABLE_CONNECTOR_SLASH("cable.connector.slash"), + CABLECAR("cablecar"), + CABLECAR_FILL("cablecar.fill"), + CELLULARBARS("cellularbars"), + FIBRECHANNEL("fibrechannel"), + NETWORK("network"), + NETWORK_BADGE_SHIELD_HALF_FILLED("network.badge.shield.half.filled"), + NETWORK_SLASH("network.slash"), + PERSONALHOTSPOT("personalhotspot"), + PERSONALHOTSPOT_CIRCLE("personalhotspot.circle"), + PERSONALHOTSPOT_CIRCLE_FILL("personalhotspot.circle.fill"), + POINT_3_CONNECTED_TRIANGLEPATH_DOTTED("point.3.connected.trianglepath.dotted"), + POINT_3_FILLED_CONNECTED_TRIANGLEPATH_DOTTED("point.3.filled.connected.trianglepath.dotted"), + WIFI("wifi"), + WIFI_CIRCLE("wifi.circle"), + WIFI_CIRCLE_FILL("wifi.circle.fill"), + WIFI_EXCLAMATIONMARK("wifi.exclamationmark"), + WIFI_EXCLAMATIONMARK_CIRCLE("wifi.exclamationmark.circle"), + WIFI_EXCLAMATIONMARK_CIRCLE_FILL("wifi.exclamationmark.circle.fill"), + WIFI_ROUTER("wifi.router"), + WIFI_ROUTER_FILL("wifi.router.fill"), + WIFI_SLASH("wifi.slash"), + WIFI_SQUARE("wifi.square"), + WIFI_SQUARE_FILL("wifi.square.fill"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolDevices.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolDevices.kt new file mode 100644 index 00000000..6f3e57f8 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolDevices.kt @@ -0,0 +1,356 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Devices (349 symbols). */ +enum class SFSymbolDevices( + override val symbolName: String, +) : SFSymbol { + AIRPOD_GEN3_LEFT("airpod.gen3.left"), + AIRPOD_GEN3_RIGHT("airpod.gen3.right"), + AIRPOD_LEFT("airpod.left"), + AIRPOD_RIGHT("airpod.right"), + AIRPODS("airpods"), + AIRPODS_CHARGINGCASE("airpods.chargingcase"), + AIRPODS_CHARGINGCASE_FILL("airpods.chargingcase.fill"), + AIRPODS_CHARGINGCASE_WIRELESS("airpods.chargingcase.wireless"), + AIRPODS_CHARGINGCASE_WIRELESS_FILL("airpods.chargingcase.wireless.fill"), + AIRPODS_GEN3("airpods.gen3"), + AIRPODS_GEN3_CHARGINGCASE_WIRELESS("airpods.gen3.chargingcase.wireless"), + AIRPODS_GEN3_CHARGINGCASE_WIRELESS_FILL("airpods.gen3.chargingcase.wireless.fill"), + AIRPODS_MAX("airpods.max"), + AIRPODS_PRO("airpods.pro"), + AIRPODS_PRO_CHARGINGCASE_WIRELESS("airpods.pro.chargingcase.wireless"), + AIRPODS_PRO_CHARGINGCASE_WIRELESS_FILL("airpods.pro.chargingcase.wireless.fill"), + AIRPODS_PRO_CHARGINGCASE_WIRELESS_RADIOWAVES_LEFT_AND_RIGHT("airpods.pro.chargingcase.wireless.radiowaves.left.and.right"), + AIRPODS_PRO_CHARGINGCASE_WIRELESS_RADIOWAVES_LEFT_AND_RIGHT_FILL("airpods.pro.chargingcase.wireless.radiowaves.left.and.right.fill"), + AIRPODS_PRO_LEFT("airpods.pro.left"), + AIRPODS_PRO_RIGHT("airpods.pro.right"), + AIRTAG("airtag"), + AIRTAG_FILL("airtag.fill"), + AIRTAG_RADIOWAVES_FORWARD("airtag.radiowaves.forward"), + AIRTAG_RADIOWAVES_FORWARD_FILL("airtag.radiowaves.forward.fill"), + APPLE_HAPTICS_AND_EXCLAMATIONMARK_TRIANGLE("apple.haptics.and.exclamationmark.triangle"), + APPLE_HAPTICS_AND_MUSIC_NOTE("apple.haptics.and.music.note"), + APPLE_HAPTICS_AND_MUSIC_NOTE_SLASH("apple.haptics.and.music.note.slash"), + APPLE_LOGO("apple.logo"), + APPLE_MEDITATE("apple.meditate"), + APPLE_MEDITATE_CIRCLE("apple.meditate.circle"), + APPLE_MEDITATE_CIRCLE_FILL("apple.meditate.circle.fill"), + APPLE_MEDITATE_SQUARE_STACK("apple.meditate.square.stack"), + APPLE_MEDITATE_SQUARE_STACK_FILL("apple.meditate.square.stack.fill"), + APPLE_TERMINAL("apple.terminal"), + APPLE_TERMINAL_CIRCLE("apple.terminal.circle"), + APPLE_TERMINAL_CIRCLE_FILL("apple.terminal.circle.fill"), + APPLE_TERMINAL_FILL("apple.terminal.fill"), + APPLE_TERMINAL_ON_RECTANGLE("apple.terminal.on.rectangle"), + APPLE_TERMINAL_ON_RECTANGLE_FILL("apple.terminal.on.rectangle.fill"), + APPLEPENCIL("applepencil"), + APPLEPENCIL_ADAPTER_USB_C("applepencil.adapter.usb.c"), + APPLEPENCIL_ADAPTER_USB_C_FILL("applepencil.adapter.usb.c.fill"), + APPLEPENCIL_AND_SCRIBBLE("applepencil.and.scribble"), + APPLEPENCIL_GEN1("applepencil.gen1"), + APPLEPENCIL_GEN2("applepencil.gen2"), + APPLEPENCIL_TIP("applepencil.tip"), + APPLESCRIPT("applescript"), + APPLESCRIPT_FILL("applescript.fill"), + APPLETV("appletv"), + APPLETV_FILL("appletv.fill"), + APPLETVREMOTE_GEN1("appletvremote.gen1"), + APPLETVREMOTE_GEN1_FILL("appletvremote.gen1.fill"), + APPLETVREMOTE_GEN2("appletvremote.gen2"), + APPLETVREMOTE_GEN2_FILL("appletvremote.gen2.fill"), + APPLETVREMOTE_GEN3("appletvremote.gen3"), + APPLETVREMOTE_GEN3_FILL("appletvremote.gen3.fill"), + APPLETVREMOTE_GEN4("appletvremote.gen4"), + APPLETVREMOTE_GEN4_FILL("appletvremote.gen4.fill"), + APPLEWATCH("applewatch"), + APPLEWATCH_AND_ARROW_FORWARD("applewatch.and.arrow.forward"), + APPLEWATCH_CASE_SIZES("applewatch.case.sizes"), + APPLEWATCH_RADIOWAVES_LEFT_AND_RIGHT("applewatch.radiowaves.left.and.right"), + APPLEWATCH_SIDE_RIGHT("applewatch.side.right"), + APPLEWATCH_SLASH("applewatch.slash"), + APPLEWATCH_WATCHFACE("applewatch.watchface"), + BEATS_EARPHONES("beats.earphones"), + BEATS_FITPRO("beats.fitpro"), + BEATS_FITPRO_CHARGINGCASE("beats.fitpro.chargingcase"), + BEATS_FITPRO_CHARGINGCASE_FILL("beats.fitpro.chargingcase.fill"), + BEATS_FITPRO_LEFT("beats.fitpro.left"), + BEATS_FITPRO_RIGHT("beats.fitpro.right"), + BEATS_HEADPHONES("beats.headphones"), + BEATS_POWERBEATS("beats.powerbeats"), + BEATS_POWERBEATS_LEFT("beats.powerbeats.left"), + BEATS_POWERBEATS_PRO("beats.powerbeats.pro"), + BEATS_POWERBEATS_PRO_CHARGINGCASE("beats.powerbeats.pro.chargingcase"), + BEATS_POWERBEATS_PRO_CHARGINGCASE_FILL("beats.powerbeats.pro.chargingcase.fill"), + BEATS_POWERBEATS_PRO_LEFT("beats.powerbeats.pro.left"), + BEATS_POWERBEATS_PRO_RIGHT("beats.powerbeats.pro.right"), + BEATS_POWERBEATS_RIGHT("beats.powerbeats.right"), + BEATS_POWERBEATS3("beats.powerbeats3"), + BEATS_POWERBEATS3_LEFT("beats.powerbeats3.left"), + BEATS_POWERBEATS3_RIGHT("beats.powerbeats3.right"), + BEATS_STUDIOBUDS("beats.studiobuds"), + BEATS_STUDIOBUDS_CHARGINGCASE("beats.studiobuds.chargingcase"), + BEATS_STUDIOBUDS_CHARGINGCASE_FILL("beats.studiobuds.chargingcase.fill"), + BEATS_STUDIOBUDS_LEFT("beats.studiobuds.left"), + BEATS_STUDIOBUDS_PLUS("beats.studiobuds.plus"), + BEATS_STUDIOBUDS_PLUS_CHARGINGCASE("beats.studiobuds.plus.chargingcase"), + BEATS_STUDIOBUDS_PLUS_CHARGINGCASE_FILL("beats.studiobuds.plus.chargingcase.fill"), + BEATS_STUDIOBUDS_PLUS_LEFT("beats.studiobuds.plus.left"), + BEATS_STUDIOBUDS_PLUS_RIGHT("beats.studiobuds.plus.right"), + BEATS_STUDIOBUDS_RIGHT("beats.studiobuds.right"), + CPU("cpu"), + CPU_FILL("cpu.fill"), + DESKTOPCOMPUTER("desktopcomputer"), + DESKTOPCOMPUTER_AND_ARROW_DOWN("desktopcomputer.and.arrow.down"), + DESKTOPCOMPUTER_AND_MACBOOK("desktopcomputer.and.macbook"), + DESKTOPCOMPUTER_TRIANGLEBADGE_EXCLAMATIONMARK("desktopcomputer.trianglebadge.exclamationmark"), + DISPLAY("display"), + DISPLAY_2("display.2"), + DISPLAY_AND_ARROW_DOWN("display.and.arrow.down"), + DISPLAY_TRIANGLEBADGE_EXCLAMATIONMARK("display.trianglebadge.exclamationmark"), + GAMECONTROLLER("gamecontroller"), + GAMECONTROLLER_CIRCLE("gamecontroller.circle"), + GAMECONTROLLER_CIRCLE_FILL("gamecontroller.circle.fill"), + GAMECONTROLLER_FILL("gamecontroller.fill"), + HIFISPEAKER("hifispeaker"), + HIFISPEAKER_2("hifispeaker.2"), + HIFISPEAKER_2_BADGE_MINUS("hifispeaker.2.badge.minus"), + HIFISPEAKER_2_BADGE_MINUS_FILL("hifispeaker.2.badge.minus.fill"), + HIFISPEAKER_2_BADGE_PLUS("hifispeaker.2.badge.plus"), + HIFISPEAKER_2_BADGE_PLUS_FILL("hifispeaker.2.badge.plus.fill"), + HIFISPEAKER_2_FILL("hifispeaker.2.fill"), + HIFISPEAKER_AND_APPLETV("hifispeaker.and.appletv"), + HIFISPEAKER_AND_APPLETV_FILL("hifispeaker.and.appletv.fill"), + HIFISPEAKER_AND_HOMEPOD("hifispeaker.and.homepod"), + HIFISPEAKER_AND_HOMEPOD_BADGE_MINUS("hifispeaker.and.homepod.badge.minus"), + HIFISPEAKER_AND_HOMEPOD_BADGE_MINUS_FILL("hifispeaker.and.homepod.badge.minus.fill"), + HIFISPEAKER_AND_HOMEPOD_BADGE_PLUS("hifispeaker.and.homepod.badge.plus"), + HIFISPEAKER_AND_HOMEPOD_BADGE_PLUS_FILL("hifispeaker.and.homepod.badge.plus.fill"), + HIFISPEAKER_AND_HOMEPOD_FILL("hifispeaker.and.homepod.fill"), + HIFISPEAKER_AND_HOMEPOD_MINI("hifispeaker.and.homepod.mini"), + HIFISPEAKER_AND_HOMEPOD_MINI_BADGE_MINUS("hifispeaker.and.homepod.mini.badge.minus"), + HIFISPEAKER_AND_HOMEPOD_MINI_BADGE_MINUS_FILL("hifispeaker.and.homepod.mini.badge.minus.fill"), + HIFISPEAKER_AND_HOMEPOD_MINI_BADGE_PLUS("hifispeaker.and.homepod.mini.badge.plus"), + HIFISPEAKER_AND_HOMEPOD_MINI_BADGE_PLUS_FILL("hifispeaker.and.homepod.mini.badge.plus.fill"), + HIFISPEAKER_AND_HOMEPOD_MINI_FILL("hifispeaker.and.homepod.mini.fill"), + HIFISPEAKER_ARROW_FORWARD("hifispeaker.arrow.forward"), + HIFISPEAKER_ARROW_FORWARD_FILL("hifispeaker.arrow.forward.fill"), + HIFISPEAKER_BADGE_MINUS("hifispeaker.badge.minus"), + HIFISPEAKER_BADGE_MINUS_FILL("hifispeaker.badge.minus.fill"), + HIFISPEAKER_BADGE_PLUS("hifispeaker.badge.plus"), + HIFISPEAKER_BADGE_PLUS_FILL("hifispeaker.badge.plus.fill"), + HIFISPEAKER_FILL("hifispeaker.fill"), + HOMEPOD("homepod"), + HOMEPOD_2("homepod.2"), + HOMEPOD_2_BADGE_MINUS("homepod.2.badge.minus"), + HOMEPOD_2_BADGE_MINUS_FILL("homepod.2.badge.minus.fill"), + HOMEPOD_2_BADGE_PLUS("homepod.2.badge.plus"), + HOMEPOD_2_BADGE_PLUS_FILL("homepod.2.badge.plus.fill"), + HOMEPOD_2_FILL("homepod.2.fill"), + HOMEPOD_AND_APPLETV("homepod.and.appletv"), + HOMEPOD_AND_APPLETV_FILL("homepod.and.appletv.fill"), + HOMEPOD_AND_HOMEPOD_MINI("homepod.and.homepod.mini"), + HOMEPOD_AND_HOMEPOD_MINI_BADGE_MINUS("homepod.and.homepod.mini.badge.minus"), + HOMEPOD_AND_HOMEPOD_MINI_BADGE_MINUS_FILL("homepod.and.homepod.mini.badge.minus.fill"), + HOMEPOD_AND_HOMEPOD_MINI_BADGE_PLUS("homepod.and.homepod.mini.badge.plus"), + HOMEPOD_AND_HOMEPOD_MINI_BADGE_PLUS_FILL("homepod.and.homepod.mini.badge.plus.fill"), + HOMEPOD_AND_HOMEPOD_MINI_FILL("homepod.and.homepod.mini.fill"), + HOMEPOD_ARROW_FORWARD("homepod.arrow.forward"), + HOMEPOD_ARROW_FORWARD_FILL("homepod.arrow.forward.fill"), + HOMEPOD_BADGE_MINUS("homepod.badge.minus"), + HOMEPOD_BADGE_MINUS_FILL("homepod.badge.minus.fill"), + HOMEPOD_BADGE_PLUS("homepod.badge.plus"), + HOMEPOD_BADGE_PLUS_FILL("homepod.badge.plus.fill"), + HOMEPOD_FILL("homepod.fill"), + HOMEPOD_MINI("homepod.mini"), + HOMEPOD_MINI_2("homepod.mini.2"), + HOMEPOD_MINI_2_BADGE_MINUS("homepod.mini.2.badge.minus"), + HOMEPOD_MINI_2_BADGE_MINUS_FILL("homepod.mini.2.badge.minus.fill"), + HOMEPOD_MINI_2_BADGE_PLUS("homepod.mini.2.badge.plus"), + HOMEPOD_MINI_2_BADGE_PLUS_FILL("homepod.mini.2.badge.plus.fill"), + HOMEPOD_MINI_2_FILL("homepod.mini.2.fill"), + HOMEPOD_MINI_ARROW_FORWARD("homepod.mini.arrow.forward"), + HOMEPOD_MINI_ARROW_FORWARD_FILL("homepod.mini.arrow.forward.fill"), + HOMEPOD_MINI_BADGE_MINUS("homepod.mini.badge.minus"), + HOMEPOD_MINI_BADGE_MINUS_FILL("homepod.mini.badge.minus.fill"), + HOMEPOD_MINI_BADGE_PLUS("homepod.mini.badge.plus"), + HOMEPOD_MINI_BADGE_PLUS_FILL("homepod.mini.badge.plus.fill"), + HOMEPOD_MINI_FILL("homepod.mini.fill"), + HOMEPODMINI_AND_APPLETV("homepodmini.and.appletv"), + HOMEPODMINI_AND_APPLETV_FILL("homepodmini.and.appletv.fill"), + IPAD("ipad"), + IPAD_AND_ARROW_FORWARD("ipad.and.arrow.forward"), + IPAD_BADGE_EXCLAMATIONMARK("ipad.badge.exclamationmark"), + IPAD_BADGE_LOCATION("ipad.badge.location"), + IPAD_BADGE_PLAY("ipad.badge.play"), + IPAD_CASE("ipad.case"), + IPAD_CASE_AND_IPHONE_CASE("ipad.case.and.iphone.case"), + IPAD_GEN1("ipad.gen1"), + IPAD_GEN1_BADGE_EXCLAMATIONMARK("ipad.gen1.badge.exclamationmark"), + IPAD_GEN1_BADGE_LOCATION("ipad.gen1.badge.location"), + IPAD_GEN1_BADGE_PLAY("ipad.gen1.badge.play"), + IPAD_GEN1_LANDSCAPE("ipad.gen1.landscape"), + IPAD_GEN1_LANDSCAPE_BADGE_EXCLAMATIONMARK("ipad.gen1.landscape.badge.exclamationmark"), + IPAD_GEN1_LANDSCAPE_BADGE_LOCATION("ipad.gen1.landscape.badge.location"), + IPAD_GEN1_LANDSCAPE_BADGE_PLAY("ipad.gen1.landscape.badge.play"), + IPAD_GEN2("ipad.gen2"), + IPAD_GEN2_BADGE_EXCLAMATIONMARK("ipad.gen2.badge.exclamationmark"), + IPAD_GEN2_BADGE_LOCATION("ipad.gen2.badge.location"), + IPAD_GEN2_BADGE_PLAY("ipad.gen2.badge.play"), + IPAD_GEN2_LANDSCAPE("ipad.gen2.landscape"), + IPAD_GEN2_LANDSCAPE_BADGE_EXCLAMATIONMARK("ipad.gen2.landscape.badge.exclamationmark"), + IPAD_GEN2_LANDSCAPE_BADGE_LOCATION("ipad.gen2.landscape.badge.location"), + IPAD_GEN2_LANDSCAPE_BADGE_PLAY("ipad.gen2.landscape.badge.play"), + IPAD_LANDSCAPE("ipad.landscape"), + IPAD_LANDSCAPE_AND_IPHONE("ipad.landscape.and.iphone"), + IPAD_LANDSCAPE_AND_IPHONE_SLASH("ipad.landscape.and.iphone.slash"), + IPAD_LANDSCAPE_BADGE_EXCLAMATIONMARK("ipad.landscape.badge.exclamationmark"), + IPAD_LANDSCAPE_BADGE_LOCATION("ipad.landscape.badge.location"), + IPAD_LANDSCAPE_BADGE_PLAY("ipad.landscape.badge.play"), + IPAD_REAR_CAMERA("ipad.rear.camera"), + IPAD_SIZES("ipad.sizes"), + IPHONE("iphone"), + IPHONE_AND_ARROW_FORWARD_INWARD("iphone.and.arrow.forward.inward"), + IPHONE_AND_ARROW_FORWARD_OUTWARD("iphone.and.arrow.forward.outward"), + IPHONE_AND_ARROW_LEFT_AND_ARROW_RIGHT_INWARD("iphone.and.arrow.left.and.arrow.right.inward"), + IPHONE_AND_ARROW_RIGHT_INWARD("iphone.and.arrow.right.inward"), + IPHONE_AND_ARROW_RIGHT_OUTWARD("iphone.and.arrow.right.outward"), + IPHONE_APP_SWITCHER("iphone.app.switcher"), + IPHONE_BADGE_EXCLAMATIONMARK("iphone.badge.exclamationmark"), + IPHONE_BADGE_LOCATION("iphone.badge.location"), + IPHONE_BADGE_PLAY("iphone.badge.play"), + IPHONE_CASE("iphone.case"), + IPHONE_CIRCLE("iphone.circle"), + IPHONE_CIRCLE_FILL("iphone.circle.fill"), + IPHONE_CROP_CIRCLE("iphone.crop.circle"), + IPHONE_DOCK_MOTORIZED_VIEWFINDER("iphone.dock.motorized.viewfinder"), + IPHONE_GEN1("iphone.gen1"), + IPHONE_GEN1_AND_ARROW_LEFT("iphone.gen1.and.arrow.left"), + IPHONE_GEN1_BADGE_EXCLAMATIONMARK("iphone.gen1.badge.exclamationmark"), + IPHONE_GEN1_BADGE_LOCATION("iphone.gen1.badge.location"), + IPHONE_GEN1_BADGE_PLAY("iphone.gen1.badge.play"), + IPHONE_GEN1_CIRCLE("iphone.gen1.circle"), + IPHONE_GEN1_CIRCLE_FILL("iphone.gen1.circle.fill"), + IPHONE_GEN1_CROP_CIRCLE("iphone.gen1.crop.circle"), + IPHONE_GEN1_LANDSCAPE("iphone.gen1.landscape"), + IPHONE_GEN1_MOTION("iphone.gen1.motion"), + IPHONE_GEN1_RADIOWAVES_LEFT_AND_RIGHT("iphone.gen1.radiowaves.left.and.right"), + IPHONE_GEN1_RADIOWAVES_LEFT_AND_RIGHT_CIRCLE("iphone.gen1.radiowaves.left.and.right.circle"), + IPHONE_GEN1_RADIOWAVES_LEFT_AND_RIGHT_CIRCLE_FILL("iphone.gen1.radiowaves.left.and.right.circle.fill"), + IPHONE_GEN1_SLASH("iphone.gen1.slash"), + IPHONE_GEN1_SLASH_CIRCLE("iphone.gen1.slash.circle"), + IPHONE_GEN1_SLASH_CIRCLE_FILL("iphone.gen1.slash.circle.fill"), + IPHONE_GEN2("iphone.gen2"), + IPHONE_GEN2_AND_ARROW_LEFT_AND_ARROW_RIGHT_INWARD("iphone.gen2.and.arrow.left.and.arrow.right.inward"), + IPHONE_GEN2_BADGE_EXCLAMATIONMARK("iphone.gen2.badge.exclamationmark"), + IPHONE_GEN2_BADGE_LOCATION("iphone.gen2.badge.location"), + IPHONE_GEN2_BADGE_PLAY("iphone.gen2.badge.play"), + IPHONE_GEN2_CIRCLE("iphone.gen2.circle"), + IPHONE_GEN2_CIRCLE_FILL("iphone.gen2.circle.fill"), + IPHONE_GEN2_CROP_CIRCLE("iphone.gen2.crop.circle"), + IPHONE_GEN2_LANDSCAPE("iphone.gen2.landscape"), + IPHONE_GEN2_MOTION("iphone.gen2.motion"), + IPHONE_GEN2_RADIOWAVES_LEFT_AND_RIGHT("iphone.gen2.radiowaves.left.and.right"), + IPHONE_GEN2_RADIOWAVES_LEFT_AND_RIGHT_CIRCLE("iphone.gen2.radiowaves.left.and.right.circle"), + IPHONE_GEN2_RADIOWAVES_LEFT_AND_RIGHT_CIRCLE_FILL("iphone.gen2.radiowaves.left.and.right.circle.fill"), + IPHONE_GEN2_SLASH("iphone.gen2.slash"), + IPHONE_GEN2_SLASH_CIRCLE("iphone.gen2.slash.circle"), + IPHONE_GEN2_SLASH_CIRCLE_FILL("iphone.gen2.slash.circle.fill"), + IPHONE_GEN3("iphone.gen3"), + IPHONE_GEN3_AND_ARROW_LEFT_AND_ARROW_RIGHT_INWARD("iphone.gen3.and.arrow.left.and.arrow.right.inward"), + IPHONE_GEN3_BADGE_EXCLAMATIONMARK("iphone.gen3.badge.exclamationmark"), + IPHONE_GEN3_BADGE_LOCATION("iphone.gen3.badge.location"), + IPHONE_GEN3_BADGE_PLAY("iphone.gen3.badge.play"), + IPHONE_GEN3_CIRCLE("iphone.gen3.circle"), + IPHONE_GEN3_CIRCLE_FILL("iphone.gen3.circle.fill"), + IPHONE_GEN3_CROP_CIRCLE("iphone.gen3.crop.circle"), + IPHONE_GEN3_LANDSCAPE("iphone.gen3.landscape"), + IPHONE_GEN3_MOTION("iphone.gen3.motion"), + IPHONE_GEN3_RADIOWAVES_LEFT_AND_RIGHT("iphone.gen3.radiowaves.left.and.right"), + IPHONE_GEN3_RADIOWAVES_LEFT_AND_RIGHT_CIRCLE("iphone.gen3.radiowaves.left.and.right.circle"), + IPHONE_GEN3_RADIOWAVES_LEFT_AND_RIGHT_CIRCLE_FILL("iphone.gen3.radiowaves.left.and.right.circle.fill"), + IPHONE_GEN3_SLASH("iphone.gen3.slash"), + IPHONE_GEN3_SLASH_CIRCLE("iphone.gen3.slash.circle"), + IPHONE_GEN3_SLASH_CIRCLE_FILL("iphone.gen3.slash.circle.fill"), + IPHONE_LANDSCAPE("iphone.landscape"), + IPHONE_MOTION("iphone.motion"), + IPHONE_RADIOWAVES_LEFT_AND_RIGHT("iphone.radiowaves.left.and.right"), + IPHONE_RADIOWAVES_LEFT_AND_RIGHT_CIRCLE("iphone.radiowaves.left.and.right.circle"), + IPHONE_RADIOWAVES_LEFT_AND_RIGHT_CIRCLE_FILL("iphone.radiowaves.left.and.right.circle.fill"), + IPHONE_REAR_CAMERA("iphone.rear.camera"), + IPHONE_SIZES("iphone.sizes"), + IPHONE_SLASH("iphone.slash"), + IPHONE_SLASH_CIRCLE("iphone.slash.circle"), + IPHONE_SLASH_CIRCLE_FILL("iphone.slash.circle.fill"), + IPHONE_SMARTBATTERYCASE_GEN1("iphone.smartbatterycase.gen1"), + IPHONE_SMARTBATTERYCASE_GEN2("iphone.smartbatterycase.gen2"), + KEYBOARD("keyboard"), + KEYBOARD_BADGE_ELLIPSIS("keyboard.badge.ellipsis"), + KEYBOARD_BADGE_ELLIPSIS_FILL("keyboard.badge.ellipsis.fill"), + KEYBOARD_BADGE_EYE("keyboard.badge.eye"), + KEYBOARD_BADGE_EYE_FILL("keyboard.badge.eye.fill"), + KEYBOARD_CHEVRON_COMPACT_DOWN("keyboard.chevron.compact.down"), + KEYBOARD_CHEVRON_COMPACT_DOWN_FILL("keyboard.chevron.compact.down.fill"), + KEYBOARD_CHEVRON_COMPACT_LEFT("keyboard.chevron.compact.left"), + KEYBOARD_CHEVRON_COMPACT_LEFT_FILL("keyboard.chevron.compact.left.fill"), + KEYBOARD_FILL("keyboard.fill"), + KEYBOARD_MACWINDOW("keyboard.macwindow"), + KEYBOARD_ONEHANDED_LEFT("keyboard.onehanded.left"), + KEYBOARD_ONEHANDED_LEFT_FILL("keyboard.onehanded.left.fill"), + KEYBOARD_ONEHANDED_RIGHT("keyboard.onehanded.right"), + KEYBOARD_ONEHANDED_RIGHT_FILL("keyboard.onehanded.right.fill"), + LAPTOPCOMPUTER("laptopcomputer"), + LAPTOPCOMPUTER_AND_ARROW_DOWN("laptopcomputer.and.arrow.down"), + LAPTOPCOMPUTER_SLASH("laptopcomputer.slash"), + LAPTOPCOMPUTER_TRIANGLEBADGE_EXCLAMATIONMARK("laptopcomputer.trianglebadge.exclamationmark"), + MACBOOK("macbook"), + MACBOOK_AND_IPAD("macbook.and.ipad"), + MACBOOK_AND_IPHONE("macbook.and.iphone"), + MACBOOK_AND_VISION_PRO("macbook.and.vision.pro"), + MACBOOK_GEN1("macbook.gen1"), + MACBOOK_GEN2("macbook.gen2"), + MACMINI("macmini"), + MACMINI_FILL("macmini.fill"), + MACPRO_GEN1("macpro.gen1"), + MACPRO_GEN1_FILL("macpro.gen1.fill"), + MACPRO_GEN2("macpro.gen2"), + MACPRO_GEN2_FILL("macpro.gen2.fill"), + MACPRO_GEN3("macpro.gen3"), + MACPRO_GEN3_FILL("macpro.gen3.fill"), + MACPRO_GEN3_SERVER("macpro.gen3.server"), + MACSTUDIO("macstudio"), + MACSTUDIO_FILL("macstudio.fill"), + MACWINDOW("macwindow"), + MACWINDOW_AND_CURSORARROW("macwindow.and.cursorarrow"), + MACWINDOW_BADGE_PLUS("macwindow.badge.plus"), + MACWINDOW_ON_RECTANGLE("macwindow.on.rectangle"), + MEMORYCHIP("memorychip"), + MEMORYCHIP_FILL("memorychip.fill"), + PRINTER("printer"), + PRINTER_DOTMATRIX("printer.dotmatrix"), + PRINTER_DOTMATRIX_FILL("printer.dotmatrix.fill"), + PRINTER_DOTMATRIX_FILLED_AND_PAPER("printer.dotmatrix.filled.and.paper"), + PRINTER_DOTMATRIX_FILLED_AND_PAPER_INVERSE("printer.dotmatrix.filled.and.paper.inverse"), + PRINTER_DOTMATRIX_INVERSE("printer.dotmatrix.inverse"), + PRINTER_FILL("printer.fill"), + PRINTER_FILLED_AND_PAPER("printer.filled.and.paper"), + PRINTER_FILLED_AND_PAPER_INVERSE("printer.filled.and.paper.inverse"), + PRINTER_INVERSE("printer.inverse"), + SCANNER("scanner"), + SCANNER_FILL("scanner.fill"), + SENSOR("sensor"), + SENSOR_FILL("sensor.fill"), + SENSOR_TAG_RADIOWAVES_FORWARD("sensor.tag.radiowaves.forward"), + SENSOR_TAG_RADIOWAVES_FORWARD_FILL("sensor.tag.radiowaves.forward.fill"), + SERVER_RACK("server.rack"), + TV("tv"), + TV_AND_HIFISPEAKER_FILL("tv.and.hifispeaker.fill"), + TV_AND_MEDIABOX("tv.and.mediabox"), + TV_AND_MEDIABOX_FILL("tv.and.mediabox.fill"), + TV_BADGE_WIFI("tv.badge.wifi"), + TV_BADGE_WIFI_FILL("tv.badge.wifi.fill"), + TV_CIRCLE("tv.circle"), + TV_CIRCLE_FILL("tv.circle.fill"), + TV_FILL("tv.fill"), + TV_SLASH("tv.slash"), + TV_SLASH_FILL("tv.slash.fill"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolGeneral.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolGeneral.kt new file mode 100644 index 00000000..73dc53e7 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolGeneral.kt @@ -0,0 +1,1369 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — General (1362 symbols). */ +enum class SFSymbolGeneral( + override val symbolName: String, +) : SFSymbol { + ABS("abs"), + ABS_BRAKESIGNAL("abs.brakesignal"), + ABS_BRAKESIGNAL_SLASH("abs.brakesignal.slash"), + ABS_CIRCLE("abs.circle"), + ABS_CIRCLE_FILL("abs.circle.fill"), + AIR_CONDITIONER_HORIZONTAL("air.conditioner.horizontal"), + AIR_CONDITIONER_HORIZONTAL_FILL("air.conditioner.horizontal.fill"), + AIR_CONDITIONER_VERTICAL("air.conditioner.vertical"), + AIR_CONDITIONER_VERTICAL_FILL("air.conditioner.vertical.fill"), + AIR_PURIFIER("air.purifier"), + AIR_PURIFIER_FILL("air.purifier.fill"), + AIRPORT_EXPRESS("airport.express"), + AIRPORT_EXTREME("airport.extreme"), + AIRPORT_EXTREME_TOWER("airport.extreme.tower"), + ALIGN_HORIZONTAL_CENTER("align.horizontal.center"), + ALIGN_HORIZONTAL_CENTER_FILL("align.horizontal.center.fill"), + ALIGN_HORIZONTAL_LEFT("align.horizontal.left"), + ALIGN_HORIZONTAL_LEFT_FILL("align.horizontal.left.fill"), + ALIGN_HORIZONTAL_RIGHT("align.horizontal.right"), + ALIGN_HORIZONTAL_RIGHT_FILL("align.horizontal.right.fill"), + ALIGN_VERTICAL_BOTTOM("align.vertical.bottom"), + ALIGN_VERTICAL_BOTTOM_FILL("align.vertical.bottom.fill"), + ALIGN_VERTICAL_CENTER("align.vertical.center"), + ALIGN_VERTICAL_CENTER_FILL("align.vertical.center.fill"), + ALIGN_VERTICAL_TOP("align.vertical.top"), + ALIGN_VERTICAL_TOP_FILL("align.vertical.top.fill"), + ALT("alt"), + ALTERNATINGCURRENT("alternatingcurrent"), + AMERICAN_FOOTBALL("american.football"), + AMERICAN_FOOTBALL_CIRCLE("american.football.circle"), + AMERICAN_FOOTBALL_CIRCLE_FILL("american.football.circle.fill"), + AMERICAN_FOOTBALL_FILL("american.football.fill"), + AMERICAN_FOOTBALL_PROFESSIONAL("american.football.professional"), + AMERICAN_FOOTBALL_PROFESSIONAL_CIRCLE("american.football.professional.circle"), + AMERICAN_FOOTBALL_PROFESSIONAL_CIRCLE_FILL("american.football.professional.circle.fill"), + AMERICAN_FOOTBALL_PROFESSIONAL_FILL("american.football.professional.fill"), + AMPLIFIER("amplifier"), + ANGLE("angle"), + ANT("ant"), + ANT_CIRCLE("ant.circle"), + ANT_CIRCLE_FILL("ant.circle.fill"), + ANT_FILL("ant.fill"), + AQI_HIGH("aqi.high"), + AQI_LOW("aqi.low"), + AQI_MEDIUM("aqi.medium"), + ARCADE_STICK("arcade.stick"), + ARCADE_STICK_AND_ARROW_DOWN("arcade.stick.and.arrow.down"), + ARCADE_STICK_AND_ARROW_LEFT("arcade.stick.and.arrow.left"), + ARCADE_STICK_AND_ARROW_LEFT_AND_ARROW_RIGHT_OUTWARD("arcade.stick.and.arrow.left.and.arrow.right.outward"), + ARCADE_STICK_AND_ARROW_RIGHT("arcade.stick.and.arrow.right"), + ARCADE_STICK_AND_ARROW_UP("arcade.stick.and.arrow.up"), + ARCADE_STICK_AND_ARROW_UP_AND_ARROW_DOWN("arcade.stick.and.arrow.up.and.arrow.down"), + ARCADE_STICK_CONSOLE("arcade.stick.console"), + ARCADE_STICK_CONSOLE_FILL("arcade.stick.console.fill"), + ARCHIVEBOX("archivebox"), + ARCHIVEBOX_CIRCLE("archivebox.circle"), + ARCHIVEBOX_CIRCLE_FILL("archivebox.circle.fill"), + ARCHIVEBOX_FILL("archivebox.fill"), + ARKIT("arkit"), + ARKIT_BADGE_XMARK("arkit.badge.xmark"), + ASPECTRATIO("aspectratio"), + ASPECTRATIO_FILL("aspectratio.fill"), + ASTERISK("asterisk"), + ASTERISK_CIRCLE("asterisk.circle"), + ASTERISK_CIRCLE_FILL("asterisk.circle.fill"), + AT("at"), + AT_BADGE_MINUS("at.badge.minus"), + AT_BADGE_PLUS("at.badge.plus"), + AT_CIRCLE("at.circle"), + AT_CIRCLE_FILL("at.circle.fill"), + ATOM("atom"), + AUDIO_JACK_MONO("audio.jack.mono"), + AUDIO_JACK_STEREO("audio.jack.stereo"), + AUSTRALIAN_FOOTBALL("australian.football"), + AUSTRALIAN_FOOTBALL_CIRCLE("australian.football.circle"), + AUSTRALIAN_FOOTBALL_CIRCLE_FILL("australian.football.circle.fill"), + AUSTRALIAN_FOOTBALL_FILL("australian.football.fill"), + AUSTRALIANDOLLARSIGN("australiandollarsign"), + AUSTRALIANDOLLARSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("australiandollarsign.arrow.trianglehead.counterclockwise.rotate.90"), + AUSTRALIANDOLLARSIGN_BANK_BUILDING("australiandollarsign.bank.building"), + AUSTRALIANDOLLARSIGN_BANK_BUILDING_FILL("australiandollarsign.bank.building.fill"), + AUSTRALIANDOLLARSIGN_CIRCLE("australiandollarsign.circle"), + AUSTRALIANDOLLARSIGN_CIRCLE_FILL("australiandollarsign.circle.fill"), + AUSTRALIANDOLLARSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("australiandollarsign.gauge.chart.lefthalf.righthalf"), + AUSTRALIANDOLLARSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("australiandollarsign.gauge.chart.leftthird.topthird.rightthird"), + AUSTRALIANDOLLARSIGN_SQUARE("australiandollarsign.square"), + AUSTRALIANDOLLARSIGN_SQUARE_FILL("australiandollarsign.square.fill"), + AUSTRALSIGN("australsign"), + AUSTRALSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("australsign.arrow.trianglehead.counterclockwise.rotate.90"), + AUSTRALSIGN_BANK_BUILDING("australsign.bank.building"), + AUSTRALSIGN_BANK_BUILDING_FILL("australsign.bank.building.fill"), + AUSTRALSIGN_CIRCLE("australsign.circle"), + AUSTRALSIGN_CIRCLE_FILL("australsign.circle.fill"), + AUSTRALSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("australsign.gauge.chart.lefthalf.righthalf"), + AUSTRALSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("australsign.gauge.chart.leftthird.topthird.rightthird"), + AUSTRALSIGN_SQUARE("australsign.square"), + AUSTRALSIGN_SQUARE_FILL("australsign.square.fill"), + AUTOMATIC_BRAKESIGNAL("automatic.brakesignal"), + AUTOMATIC_HEADLIGHT_HIGH_BEAM("automatic.headlight.high.beam"), + AUTOMATIC_HEADLIGHT_HIGH_BEAM_FILL("automatic.headlight.high.beam.fill"), + AUTOMATIC_HEADLIGHT_LOW_BEAM("automatic.headlight.low.beam"), + AUTOMATIC_HEADLIGHT_LOW_BEAM_FILL("automatic.headlight.low.beam.fill"), + AUTOSTARTSTOP("autostartstop"), + AUTOSTARTSTOP_SLASH("autostartstop.slash"), + AUTOSTARTSTOP_TRIANGLEBADGE_EXCLAMATIONMARK("autostartstop.trianglebadge.exclamationmark"), + AV_REMOTE("av.remote"), + AV_REMOTE_FILL("av.remote.fill"), + AXLE_2("axle.2"), + AXLE_2_DRIVESHAFT_DISENGAGED("axle.2.driveshaft.disengaged"), + AXLE_2_FRONT_AND_REAR_ENGAGED("axle.2.front.and.rear.engaged"), + AXLE_2_FRONT_DISENGAGED("axle.2.front.disengaged"), + AXLE_2_FRONT_ENGAGED("axle.2.front.engaged"), + AXLE_2_REAR_DISENGAGED("axle.2.rear.disengaged"), + AXLE_2_REAR_ENGAGED("axle.2.rear.engaged"), + AXLE_2_REAR_LOCK("axle.2.rear.lock"), + BACKPACK("backpack"), + BACKPACK_CIRCLE("backpack.circle"), + BACKPACK_CIRCLE_FILL("backpack.circle.fill"), + BACKPACK_FILL("backpack.fill"), + BALLOON("balloon"), + BALLOON_2("balloon.2"), + BALLOON_2_FILL("balloon.2.fill"), + BALLOON_FILL("balloon.fill"), + BARCODE("barcode"), + BARCODE_VIEWFINDER("barcode.viewfinder"), + BAROMETER("barometer"), + BASKET("basket"), + BASKET_FILL("basket.fill"), + BEACH_UMBRELLA("beach.umbrella"), + BEACH_UMBRELLA_FILL("beach.umbrella.fill"), + BIRD("bird"), + BIRD_CIRCLE("bird.circle"), + BIRD_CIRCLE_FILL("bird.circle.fill"), + BIRD_FILL("bird.fill"), + BIRTHDAY_CAKE("birthday.cake"), + BIRTHDAY_CAKE_FILL("birthday.cake.fill"), + BLINDS_HORIZONTAL_CLOSED("blinds.horizontal.closed"), + BLINDS_HORIZONTAL_OPEN("blinds.horizontal.open"), + BLINDS_VERTICAL_CLOSED("blinds.vertical.closed"), + BLINDS_VERTICAL_OPEN("blinds.vertical.open"), + BONJOUR("bonjour"), + BRAKESIGNAL("brakesignal"), + BRAKESIGNAL_DASHED("brakesignal.dashed"), + BRIEFCASE("briefcase"), + BRIEFCASE_CIRCLE("briefcase.circle"), + BRIEFCASE_CIRCLE_FILL("briefcase.circle.fill"), + BRIEFCASE_FILL("briefcase.fill"), + BURN("burn"), + BURST("burst"), + BURST_FILL("burst.fill"), + BUTTON_ANGLEDBOTTOM_HORIZONTAL_LEFT("button.angledbottom.horizontal.left"), + BUTTON_ANGLEDBOTTOM_HORIZONTAL_LEFT_FILL("button.angledbottom.horizontal.left.fill"), + BUTTON_ANGLEDBOTTOM_HORIZONTAL_RIGHT("button.angledbottom.horizontal.right"), + BUTTON_ANGLEDBOTTOM_HORIZONTAL_RIGHT_FILL("button.angledbottom.horizontal.right.fill"), + BUTTON_ANGLEDTOP_VERTICAL_LEFT("button.angledtop.vertical.left"), + BUTTON_ANGLEDTOP_VERTICAL_LEFT_FILL("button.angledtop.vertical.left.fill"), + BUTTON_ANGLEDTOP_VERTICAL_RIGHT("button.angledtop.vertical.right"), + BUTTON_ANGLEDTOP_VERTICAL_RIGHT_FILL("button.angledtop.vertical.right.fill"), + BUTTON_HORIZONTAL("button.horizontal"), + BUTTON_HORIZONTAL_FILL("button.horizontal.fill"), + BUTTON_HORIZONTAL_TOP_PRESS("button.horizontal.top.press"), + BUTTON_HORIZONTAL_TOP_PRESS_FILL("button.horizontal.top.press.fill"), + BUTTON_PROGRAMMABLE("button.programmable"), + BUTTON_PROGRAMMABLE_SQUARE("button.programmable.square"), + BUTTON_PROGRAMMABLE_SQUARE_FILL("button.programmable.square.fill"), + BUTTON_ROUNDEDBOTTOM_HORIZONTAL("button.roundedbottom.horizontal"), + BUTTON_ROUNDEDBOTTOM_HORIZONTAL_FILL("button.roundedbottom.horizontal.fill"), + BUTTON_ROUNDEDTOP_HORIZONTAL("button.roundedtop.horizontal"), + BUTTON_ROUNDEDTOP_HORIZONTAL_FILL("button.roundedtop.horizontal.fill"), + BUTTON_VERTICAL_LEFT_PRESS("button.vertical.left.press"), + BUTTON_VERTICAL_LEFT_PRESS_FILL("button.vertical.left.press.fill"), + BUTTON_VERTICAL_RIGHT_PRESS("button.vertical.right.press"), + BUTTON_VERTICAL_RIGHT_PRESS_FILL("button.vertical.right.press.fill"), + CANDYBARPHONE("candybarphone"), + CAPSLOCK("capslock"), + CAPSLOCK_FILL("capslock.fill"), + CAPTIONS_BUBBLE("captions.bubble"), + CAPTIONS_BUBBLE_FILL("captions.bubble.fill"), + CASE("case"), + CASE_FILL("case.fill"), + CAT("cat"), + CAT_CIRCLE("cat.circle"), + CAT_CIRCLE_FILL("cat.circle.fill"), + CAT_FILL("cat.fill"), + CEDISIGN("cedisign"), + CEDISIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("cedisign.arrow.trianglehead.counterclockwise.rotate.90"), + CEDISIGN_BANK_BUILDING("cedisign.bank.building"), + CEDISIGN_BANK_BUILDING_FILL("cedisign.bank.building.fill"), + CEDISIGN_CIRCLE("cedisign.circle"), + CEDISIGN_CIRCLE_FILL("cedisign.circle.fill"), + CEDISIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("cedisign.gauge.chart.lefthalf.righthalf"), + CEDISIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("cedisign.gauge.chart.leftthird.topthird.rightthird"), + CEDISIGN_SQUARE("cedisign.square"), + CEDISIGN_SQUARE_FILL("cedisign.square.fill"), + CHECKLIST("checklist"), + CHECKLIST_CHECKED("checklist.checked"), + CHECKLIST_UNCHECKED("checklist.unchecked"), + CHINESEYUANRENMINBISIGN("chineseyuanrenminbisign"), + CHINESEYUANRENMINBISIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("chineseyuanrenminbisign.arrow.trianglehead.counterclockwise.rotate.90"), + CHINESEYUANRENMINBISIGN_BANK_BUILDING("chineseyuanrenminbisign.bank.building"), + CHINESEYUANRENMINBISIGN_BANK_BUILDING_FILL("chineseyuanrenminbisign.bank.building.fill"), + CHINESEYUANRENMINBISIGN_CIRCLE("chineseyuanrenminbisign.circle"), + CHINESEYUANRENMINBISIGN_CIRCLE_FILL("chineseyuanrenminbisign.circle.fill"), + CHINESEYUANRENMINBISIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("chineseyuanrenminbisign.gauge.chart.lefthalf.righthalf"), + CHINESEYUANRENMINBISIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("chineseyuanrenminbisign.gauge.chart.leftthird.topthird.rightthird"), + CHINESEYUANRENMINBISIGN_SQUARE("chineseyuanrenminbisign.square"), + CHINESEYUANRENMINBISIGN_SQUARE_FILL("chineseyuanrenminbisign.square.fill"), + CLEAR("clear"), + CLEAR_FILL("clear.fill"), + CLIPBOARD("clipboard"), + CLIPBOARD_FILL("clipboard.fill"), + COAT("coat"), + COAT_FILL("coat.fill"), + COMB("comb"), + COMB_FILL("comb.fill"), + COMMAND("command"), + COMMAND_CIRCLE("command.circle"), + COMMAND_CIRCLE_FILL("command.circle.fill"), + COMMAND_SQUARE("command.square"), + COMMAND_SQUARE_FILL("command.square.fill"), + COMPUTERMOUSE("computermouse"), + COMPUTERMOUSE_FILL("computermouse.fill"), + CONE("cone"), + CONE_FILL("cone.fill"), + CONTACT_SENSOR("contact.sensor"), + CONTACT_SENSOR_FILL("contact.sensor.fill"), + CONTEXTUALMENU_AND_CURSORARROW("contextualmenu.and.cursorarrow"), + CONTROL("control"), + CROP("crop"), + CROP_ROTATE("crop.rotate"), + CROWN("crown"), + CROWN_FILL("crown.fill"), + CUBE("cube"), + CUBE_FILL("cube.fill"), + CUBE_TRANSPARENT("cube.transparent"), + CUBE_TRANSPARENT_FILL("cube.transparent.fill"), + CUP_AND_SAUCER("cup.and.saucer"), + CUP_AND_SAUCER_FILL("cup.and.saucer.fill"), + CURLYBRACES("curlybraces"), + CURLYBRACES_SQUARE("curlybraces.square"), + CURLYBRACES_SQUARE_FILL("curlybraces.square.fill"), + CURSORARROW("cursorarrow"), + CURSORARROW_AND_SQUARE_ON_SQUARE_DASHED("cursorarrow.and.square.on.square.dashed"), + CURSORARROW_CLICK("cursorarrow.click"), + CURSORARROW_CLICK_2("cursorarrow.click.2"), + CURSORARROW_CLICK_BADGE_CLOCK("cursorarrow.click.badge.clock"), + CURSORARROW_MOTIONLINES("cursorarrow.motionlines"), + CURSORARROW_MOTIONLINES_CLICK("cursorarrow.motionlines.click"), + CURSORARROW_RAYS("cursorarrow.rays"), + CURSORARROW_SLASH("cursorarrow.slash"), + CURSORARROW_SLASH_SQUARE("cursorarrow.slash.square"), + CURSORARROW_SLASH_SQUARE_FILL("cursorarrow.slash.square.fill"), + CURSORARROW_SQUARE("cursorarrow.square"), + CURSORARROW_SQUARE_FILL("cursorarrow.square.fill"), + CYLINDER("cylinder"), + CYLINDER_FILL("cylinder.fill"), + CYLINDER_SPLIT_1X2("cylinder.split.1x2"), + CYLINDER_SPLIT_1X2_FILL("cylinder.split.1x2.fill"), + DANISHKRONESIGN("danishkronesign"), + DANISHKRONESIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("danishkronesign.arrow.trianglehead.counterclockwise.rotate.90"), + DANISHKRONESIGN_BANK_BUILDING("danishkronesign.bank.building"), + DANISHKRONESIGN_BANK_BUILDING_FILL("danishkronesign.bank.building.fill"), + DANISHKRONESIGN_CIRCLE("danishkronesign.circle"), + DANISHKRONESIGN_CIRCLE_FILL("danishkronesign.circle.fill"), + DANISHKRONESIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("danishkronesign.gauge.chart.lefthalf.righthalf"), + DANISHKRONESIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("danishkronesign.gauge.chart.leftthird.topthird.rightthird"), + DANISHKRONESIGN_SQUARE("danishkronesign.square"), + DANISHKRONESIGN_SQUARE_FILL("danishkronesign.square.fill"), + DECREASE_INDENT("decrease.indent"), + DECREASE_QUOTELEVEL("decrease.quotelevel"), + DEGREESIGN_CELSIUS("degreesign.celsius"), + DEGREESIGN_FARENHEIT("degreesign.farenheit"), + DEHUMIDIFIER("dehumidifier"), + DEHUMIDIFIER_FILL("dehumidifier.fill"), + DELETE_BACKWARD("delete.backward"), + DELETE_BACKWARD_FILL("delete.backward.fill"), + DELETE_FORWARD("delete.forward"), + DELETE_FORWARD_FILL("delete.forward.fill"), + DELETE_LEFT("delete.left"), + DELETE_LEFT_FILL("delete.left.fill"), + DELETE_RIGHT("delete.right"), + DELETE_RIGHT_FILL("delete.right.fill"), + DESKCLOCK("deskclock"), + DESKCLOCK_FILL("deskclock.fill"), + DESKVIEW("deskview"), + DESKVIEW_FILL("deskview.fill"), + DIAL_HIGH("dial.high"), + DIAL_HIGH_FILL("dial.high.fill"), + DIAL_LOW("dial.low"), + DIAL_LOW_FILL("dial.low.fill"), + DIAL_MEDIUM("dial.medium"), + DIAL_MEDIUM_FILL("dial.medium.fill"), + DICE("dice"), + DICE_FILL("dice.fill"), + DIE_FACE_1("die.face.1"), + DIE_FACE_1_FILL("die.face.1.fill"), + DIE_FACE_2("die.face.2"), + DIE_FACE_2_FILL("die.face.2.fill"), + DIE_FACE_3("die.face.3"), + DIE_FACE_3_FILL("die.face.3.fill"), + DIE_FACE_4("die.face.4"), + DIE_FACE_4_FILL("die.face.4.fill"), + DIE_FACE_5("die.face.5"), + DIE_FACE_5_FILL("die.face.5.fill"), + DIE_FACE_6("die.face.6"), + DIE_FACE_6_FILL("die.face.6.fill"), + DIGITALCROWN_ARROW_CLOCKWISE("digitalcrown.arrow.clockwise"), + DIGITALCROWN_ARROW_CLOCKWISE_FILL("digitalcrown.arrow.clockwise.fill"), + DIGITALCROWN_ARROW_COUNTERCLOCKWISE("digitalcrown.arrow.counterclockwise"), + DIGITALCROWN_ARROW_COUNTERCLOCKWISE_FILL("digitalcrown.arrow.counterclockwise.fill"), + DIGITALCROWN_HORIZONTAL_ARROW_CLOCKWISE("digitalcrown.horizontal.arrow.clockwise"), + DIGITALCROWN_HORIZONTAL_ARROW_CLOCKWISE_FILL("digitalcrown.horizontal.arrow.clockwise.fill"), + DIGITALCROWN_HORIZONTAL_ARROW_COUNTERCLOCKWISE("digitalcrown.horizontal.arrow.counterclockwise"), + DIGITALCROWN_HORIZONTAL_ARROW_COUNTERCLOCKWISE_FILL("digitalcrown.horizontal.arrow.counterclockwise.fill"), + DIGITALCROWN_HORIZONTAL_PRESS("digitalcrown.horizontal.press"), + DIGITALCROWN_HORIZONTAL_PRESS_FILL("digitalcrown.horizontal.press.fill"), + DIGITALCROWN_PRESS("digitalcrown.press"), + DIGITALCROWN_PRESS_FILL("digitalcrown.press.fill"), + DIRECTCURRENT("directcurrent"), + DISTRIBUTE_HORIZONTAL("distribute.horizontal"), + DISTRIBUTE_HORIZONTAL_CENTER("distribute.horizontal.center"), + DISTRIBUTE_HORIZONTAL_CENTER_FILL("distribute.horizontal.center.fill"), + DISTRIBUTE_HORIZONTAL_FILL("distribute.horizontal.fill"), + DISTRIBUTE_HORIZONTAL_LEFT("distribute.horizontal.left"), + DISTRIBUTE_HORIZONTAL_LEFT_FILL("distribute.horizontal.left.fill"), + DISTRIBUTE_HORIZONTAL_RIGHT("distribute.horizontal.right"), + DISTRIBUTE_HORIZONTAL_RIGHT_FILL("distribute.horizontal.right.fill"), + DISTRIBUTE_VERTICAL("distribute.vertical"), + DISTRIBUTE_VERTICAL_BOTTOM("distribute.vertical.bottom"), + DISTRIBUTE_VERTICAL_BOTTOM_FILL("distribute.vertical.bottom.fill"), + DISTRIBUTE_VERTICAL_CENTER("distribute.vertical.center"), + DISTRIBUTE_VERTICAL_CENTER_FILL("distribute.vertical.center.fill"), + DISTRIBUTE_VERTICAL_FILL("distribute.vertical.fill"), + DISTRIBUTE_VERTICAL_TOP("distribute.vertical.top"), + DISTRIBUTE_VERTICAL_TOP_FILL("distribute.vertical.top.fill"), + DIVIDE("divide"), + DIVIDE_CIRCLE("divide.circle"), + DIVIDE_CIRCLE_FILL("divide.circle.fill"), + DIVIDE_SQUARE("divide.square"), + DIVIDE_SQUARE_FILL("divide.square.fill"), + DOG("dog"), + DOG_CIRCLE("dog.circle"), + DOG_CIRCLE_FILL("dog.circle.fill"), + DOG_FILL("dog.fill"), + DONGSIGN("dongsign"), + DONGSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("dongsign.arrow.trianglehead.counterclockwise.rotate.90"), + DONGSIGN_BANK_BUILDING("dongsign.bank.building"), + DONGSIGN_BANK_BUILDING_FILL("dongsign.bank.building.fill"), + DONGSIGN_CIRCLE("dongsign.circle"), + DONGSIGN_CIRCLE_FILL("dongsign.circle.fill"), + DONGSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("dongsign.gauge.chart.lefthalf.righthalf"), + DONGSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("dongsign.gauge.chart.leftthird.topthird.rightthird"), + DONGSIGN_SQUARE("dongsign.square"), + DONGSIGN_SQUARE_FILL("dongsign.square.fill"), + DOT_ARROWTRIANGLES_UP_RIGHT_DOWN_LEFT_CIRCLE("dot.arrowtriangles.up.right.down.left.circle"), + DOT_CIRCLE_AND_CURSORARROW("dot.circle.and.cursorarrow"), + DOT_CIRCLE_AND_HAND_POINT_UP_LEFT_FILL("dot.circle.and.hand.point.up.left.fill"), + DOT_CIRCLE_VIEWFINDER("dot.circle.viewfinder"), + DOT_RADIOWAVES_FORWARD("dot.radiowaves.forward"), + DOT_RADIOWAVES_LEFT_AND_RIGHT("dot.radiowaves.left.and.right"), + DOT_RADIOWAVES_RIGHT("dot.radiowaves.right"), + DOT_RADIOWAVES_UP_FORWARD("dot.radiowaves.up.forward"), + DOT_SCOPE("dot.scope"), + DOT_SCOPE_DISPLAY("dot.scope.display"), + DOT_SCOPE_LAPTOPCOMPUTER("dot.scope.laptopcomputer"), + DOT_SQUARE("dot.square"), + DOT_SQUARE_FILL("dot.square.fill"), + DOT_SQUARESHAPE("dot.squareshape"), + DOT_SQUARESHAPE_FILL("dot.squareshape.fill"), + DOT_SQUARESHAPE_SPLIT_2X2("dot.squareshape.split.2x2"), + DOT_VIEWFINDER("dot.viewfinder"), + DOTS_AND_LINE_VERTICAL_AND_CURSORARROW_RECTANGLE("dots.and.line.vertical.and.cursorarrow.rectangle"), + DPAD("dpad"), + DPAD_DOWN_FILLED("dpad.down.filled"), + DPAD_FILL("dpad.fill"), + DPAD_LEFT_FILLED("dpad.left.filled"), + DPAD_RIGHT_FILLED("dpad.right.filled"), + DPAD_UP_FILLED("dpad.up.filled"), + DRONE("drone"), + DRONE_FILL("drone.fill"), + DUFFLE_BAG("duffle.bag"), + DUFFLE_BAG_FILL("duffle.bag.fill"), + ECG_TEXT_PAGE("ecg.text.page"), + ECG_TEXT_PAGE_FILL("ecg.text.page.fill"), + EJECT("eject"), + EJECT_CIRCLE("eject.circle"), + EJECT_CIRCLE_FILL("eject.circle.fill"), + EJECT_FILL("eject.fill"), + ELLIPSIS("ellipsis"), + ELLIPSIS_BUBBLE("ellipsis.bubble"), + ELLIPSIS_BUBBLE_FILL("ellipsis.bubble.fill"), + ELLIPSIS_CIRCLE("ellipsis.circle"), + ELLIPSIS_CIRCLE_FILL("ellipsis.circle.fill"), + ELLIPSIS_CURLYBRACES("ellipsis.curlybraces"), + ELLIPSIS_MESSAGE("ellipsis.message"), + ELLIPSIS_MESSAGE_FILL("ellipsis.message.fill"), + ELLIPSIS_RECTANGLE("ellipsis.rectangle"), + ELLIPSIS_RECTANGLE_FILL("ellipsis.rectangle.fill"), + ELLIPSIS_VERTICAL_BUBBLE("ellipsis.vertical.bubble"), + ELLIPSIS_VERTICAL_BUBBLE_FILL("ellipsis.vertical.bubble.fill"), + ELLIPSIS_VIEWFINDER("ellipsis.viewfinder"), + ENTRY_LEVER_KEYPAD("entry.lever.keypad"), + ENTRY_LEVER_KEYPAD_FILL("entry.lever.keypad.fill"), + ENTRY_LEVER_KEYPAD_TRIANGLEBADGE_EXCLAMATIONMARK("entry.lever.keypad.trianglebadge.exclamationmark"), + ENTRY_LEVER_KEYPAD_TRIANGLEBADGE_EXCLAMATIONMARK_FILL("entry.lever.keypad.trianglebadge.exclamationmark.fill"), + EQUAL("equal"), + EQUAL_CIRCLE("equal.circle"), + EQUAL_CIRCLE_FILL("equal.circle.fill"), + EQUAL_SQUARE("equal.square"), + EQUAL_SQUARE_FILL("equal.square.fill"), + ESIM("esim"), + ESIM_FILL("esim.fill"), + EUROZONESIGN("eurozonesign"), + EUROZONESIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("eurozonesign.arrow.trianglehead.counterclockwise.rotate.90"), + EUROZONESIGN_BANK_BUILDING("eurozonesign.bank.building"), + EUROZONESIGN_BANK_BUILDING_FILL("eurozonesign.bank.building.fill"), + EUROZONESIGN_CIRCLE("eurozonesign.circle"), + EUROZONESIGN_CIRCLE_FILL("eurozonesign.circle.fill"), + EUROZONESIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("eurozonesign.gauge.chart.lefthalf.righthalf"), + EUROZONESIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("eurozonesign.gauge.chart.leftthird.topthird.rightthird"), + EUROZONESIGN_SQUARE("eurozonesign.square"), + EUROZONESIGN_SQUARE_FILL("eurozonesign.square.fill"), + EXTERNALDRIVE("externaldrive"), + EXTERNALDRIVE_BADGE_CHECKMARK("externaldrive.badge.checkmark"), + EXTERNALDRIVE_BADGE_EXCLAMATIONMARK("externaldrive.badge.exclamationmark"), + EXTERNALDRIVE_BADGE_ICLOUD("externaldrive.badge.icloud"), + EXTERNALDRIVE_BADGE_MINUS("externaldrive.badge.minus"), + EXTERNALDRIVE_BADGE_PERSON_CROP("externaldrive.badge.person.crop"), + EXTERNALDRIVE_BADGE_PLUS("externaldrive.badge.plus"), + EXTERNALDRIVE_BADGE_QUESTIONMARK("externaldrive.badge.questionmark"), + EXTERNALDRIVE_BADGE_TIMEMACHINE("externaldrive.badge.timemachine"), + EXTERNALDRIVE_BADGE_WIFI("externaldrive.badge.wifi"), + EXTERNALDRIVE_BADGE_XMARK("externaldrive.badge.xmark"), + EXTERNALDRIVE_CONNECTED_TO_LINE_BELOW("externaldrive.connected.to.line.below"), + EXTERNALDRIVE_CONNECTED_TO_LINE_BELOW_FILL("externaldrive.connected.to.line.below.fill"), + EXTERNALDRIVE_FILL("externaldrive.fill"), + EXTERNALDRIVE_FILL_BADGE_CHECKMARK("externaldrive.fill.badge.checkmark"), + EXTERNALDRIVE_FILL_BADGE_EXCLAMATIONMARK("externaldrive.fill.badge.exclamationmark"), + EXTERNALDRIVE_FILL_BADGE_ICLOUD("externaldrive.fill.badge.icloud"), + EXTERNALDRIVE_FILL_BADGE_MINUS("externaldrive.fill.badge.minus"), + EXTERNALDRIVE_FILL_BADGE_PERSON_CROP("externaldrive.fill.badge.person.crop"), + EXTERNALDRIVE_FILL_BADGE_PLUS("externaldrive.fill.badge.plus"), + EXTERNALDRIVE_FILL_BADGE_QUESTIONMARK("externaldrive.fill.badge.questionmark"), + EXTERNALDRIVE_FILL_BADGE_TIMEMACHINE("externaldrive.fill.badge.timemachine"), + EXTERNALDRIVE_FILL_BADGE_WIFI("externaldrive.fill.badge.wifi"), + EXTERNALDRIVE_FILL_BADGE_XMARK("externaldrive.fill.badge.xmark"), + EXTERNALDRIVE_FILL_TRIANGLEBADGE_EXCLAMATIONMARK("externaldrive.fill.trianglebadge.exclamationmark"), + EXTERNALDRIVE_TRIANGLEBADGE_EXCLAMATIONMARK("externaldrive.trianglebadge.exclamationmark"), + FAXMACHINE("faxmachine"), + FAXMACHINE_FILL("faxmachine.fill"), + FIELD_OF_VIEW_ULTRAWIDE("field.of.view.ultrawide"), + FIELD_OF_VIEW_ULTRAWIDE_FILL("field.of.view.ultrawide.fill"), + FIELD_OF_VIEW_WIDE("field.of.view.wide"), + FIELD_OF_VIEW_WIDE_FILL("field.of.view.wide.fill"), + FILEMENU_AND_CURSORARROW("filemenu.and.cursorarrow"), + FILEMENU_AND_SELECTION("filemenu.and.selection"), + FIRE_EXTINGUISHER("fire.extinguisher"), + FIRE_EXTINGUISHER_FILL("fire.extinguisher.fill"), + FIREWALL("firewall"), + FIREWALL_FILL("firewall.fill"), + FIREWORKS("fireworks"), + FISH("fish"), + FISH_CIRCLE("fish.circle"), + FISH_CIRCLE_FILL("fish.circle.fill"), + FISH_FILL("fish.fill"), + FLASK("flask"), + FLASK_FILL("flask.fill"), + FLEURON("fleuron"), + FLEURON_FILL("fleuron.fill"), + FLIPPHONE("flipphone"), + FLORINSIGN("florinsign"), + FLORINSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("florinsign.arrow.trianglehead.counterclockwise.rotate.90"), + FLORINSIGN_BANK_BUILDING("florinsign.bank.building"), + FLORINSIGN_BANK_BUILDING_FILL("florinsign.bank.building.fill"), + FLORINSIGN_CIRCLE("florinsign.circle"), + FLORINSIGN_CIRCLE_FILL("florinsign.circle.fill"), + FLORINSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("florinsign.gauge.chart.lefthalf.righthalf"), + FLORINSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("florinsign.gauge.chart.leftthird.topthird.rightthird"), + FLORINSIGN_SQUARE("florinsign.square"), + FLORINSIGN_SQUARE_FILL("florinsign.square.fill"), + FLOWCHART("flowchart"), + FLOWCHART_FILL("flowchart.fill"), + FLUID_BATTERYBLOCK("fluid.batteryblock"), + FLUID_BRAKESIGNAL("fluid.brakesignal"), + FLUID_TRANSMISSION("fluid.transmission"), + FN("fn"), + FORK_KNIFE("fork.knife"), + FORK_KNIFE_CIRCLE("fork.knife.circle"), + FORK_KNIFE_CIRCLE_FILL("fork.knife.circle.fill"), + FORMFITTING_GAMECONTROLLER("formfitting.gamecontroller"), + FORMFITTING_GAMECONTROLLER_FILL("formfitting.gamecontroller.fill"), + FOSSIL_SHELL("fossil.shell"), + FOSSIL_SHELL_FILL("fossil.shell.fill"), + FRYING_PAN("frying.pan"), + FRYING_PAN_FILL("frying.pan.fill"), + FUNCTION("function"), + FX("fx"), + GEAR("gear"), + GEAR_BADGE("gear.badge"), + GEAR_BADGE_CHECKMARK("gear.badge.checkmark"), + GEAR_BADGE_QUESTIONMARK("gear.badge.questionmark"), + GEAR_BADGE_XMARK("gear.badge.xmark"), + GEAR_CIRCLE("gear.circle"), + GEAR_CIRCLE_FILL("gear.circle.fill"), + GEARSHAPE("gearshape"), + GEARSHAPE_2("gearshape.2"), + GEARSHAPE_2_FILL("gearshape.2.fill"), + GEARSHAPE_ARROW_TRIANGLEHEAD_2_CLOCKWISE_ROTATE_90("gearshape.arrow.trianglehead.2.clockwise.rotate.90"), + GEARSHAPE_CIRCLE("gearshape.circle"), + GEARSHAPE_CIRCLE_FILL("gearshape.circle.fill"), + GEARSHAPE_FILL("gearshape.fill"), + GEARSHIFT_LAYOUT_SIXSPEED("gearshift.layout.sixspeed"), + GLOWPLUG("glowplug"), + GRADUATIONCAP("graduationcap"), + GRADUATIONCAP_CIRCLE("graduationcap.circle"), + GRADUATIONCAP_CIRCLE_FILL("graduationcap.circle.fill"), + GRADUATIONCAP_FILL("graduationcap.fill"), + GREATERTHAN("greaterthan"), + GREATERTHAN_CIRCLE("greaterthan.circle"), + GREATERTHAN_CIRCLE_FILL("greaterthan.circle.fill"), + GREATERTHAN_SQUARE("greaterthan.square"), + GREATERTHAN_SQUARE_FILL("greaterthan.square.fill"), + GREATERTHANOREQUALTO("greaterthanorequalto"), + GREATERTHANOREQUALTO_CIRCLE("greaterthanorequalto.circle"), + GREATERTHANOREQUALTO_CIRCLE_FILL("greaterthanorequalto.circle.fill"), + GREATERTHANOREQUALTO_SQUARE("greaterthanorequalto.square"), + GREATERTHANOREQUALTO_SQUARE_FILL("greaterthanorequalto.square.fill"), + GREETINGCARD("greetingcard"), + GREETINGCARD_FILL("greetingcard.fill"), + GRID("grid"), + GRID_CIRCLE("grid.circle"), + GRID_CIRCLE_FILL("grid.circle.fill"), + GUITARS("guitars"), + GUITARS_FILL("guitars.fill"), + GYROSCOPE("gyroscope"), + HANGER("hanger"), + HARE("hare"), + HARE_CIRCLE("hare.circle"), + HARE_CIRCLE_FILL("hare.circle.fill"), + HARE_FILL("hare.fill"), + HAT_CAP("hat.cap"), + HAT_CAP_FILL("hat.cap.fill"), + HAT_WIDEBRIM("hat.widebrim"), + HAT_WIDEBRIM_FILL("hat.widebrim.fill"), + HAZARDSIGN("hazardsign"), + HAZARDSIGN_FILL("hazardsign.fill"), + HEAD_PROFILE_ARROW_FORWARD_AND_VISION_PRO("head.profile.arrow.forward.and.vision.pro"), + HEADLIGHT_DAYTIME("headlight.daytime"), + HEADLIGHT_DAYTIME_FILL("headlight.daytime.fill"), + HEADLIGHT_FOG("headlight.fog"), + HEADLIGHT_FOG_FILL("headlight.fog.fill"), + HEADLIGHT_HIGH_BEAM("headlight.high.beam"), + HEADLIGHT_HIGH_BEAM_FILL("headlight.high.beam.fill"), + HEADLIGHT_LOW_BEAM("headlight.low.beam"), + HEADLIGHT_LOW_BEAM_FILL("headlight.low.beam.fill"), + HEADSET("headset"), + HEADSET_CIRCLE("headset.circle"), + HEADSET_CIRCLE_FILL("headset.circle.fill"), + HEARINGDEVICE_AND_SIGNAL_METER("hearingdevice.and.signal.meter"), + HEARINGDEVICE_AND_SIGNAL_METER_FILL("hearingdevice.and.signal.meter.fill"), + HEARINGDEVICE_EAR("hearingdevice.ear"), + HEARINGDEVICE_EAR_FILL("hearingdevice.ear.fill"), + HEAT_ELEMENT_WINDSHIELD("heat.element.windshield"), + HEAT_WAVES("heat.waves"), + HEAT_WAVES_AND_FAN("heat.waves.and.fan"), + HEATER_VERTICAL("heater.vertical"), + HEATER_VERTICAL_FILL("heater.vertical.fill"), + HELM("helm"), + HELMET("helmet"), + HELMET_FILL("helmet.fill"), + HIFIRECEIVER("hifireceiver"), + HIFIRECEIVER_FILL("hifireceiver.fill"), + HIGHLIGHTER("highlighter"), + HOLD_BRAKESIGNAL("hold.brakesignal"), + HOMEKIT("homekit"), + HORN("horn"), + HORN_BLAST("horn.blast"), + HORN_BLAST_FILL("horn.blast.fill"), + HORN_FILL("horn.fill"), + HRYVNIASIGN("hryvniasign"), + HRYVNIASIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("hryvniasign.arrow.trianglehead.counterclockwise.rotate.90"), + HRYVNIASIGN_BANK_BUILDING("hryvniasign.bank.building"), + HRYVNIASIGN_BANK_BUILDING_FILL("hryvniasign.bank.building.fill"), + HRYVNIASIGN_CIRCLE("hryvniasign.circle"), + HRYVNIASIGN_CIRCLE_FILL("hryvniasign.circle.fill"), + HRYVNIASIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("hryvniasign.gauge.chart.lefthalf.righthalf"), + HRYVNIASIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("hryvniasign.gauge.chart.leftthird.topthird.rightthird"), + HRYVNIASIGN_SQUARE("hryvniasign.square"), + HRYVNIASIGN_SQUARE_FILL("hryvniasign.square.fill"), + HUMIDIFIER("humidifier"), + HUMIDIFIER_AND_DROPLETS("humidifier.and.droplets"), + HUMIDIFIER_AND_DROPLETS_FILL("humidifier.and.droplets.fill"), + HUMIDIFIER_FILL("humidifier.fill"), + ICLOUD("icloud"), + ICLOUD_AND_ARROW_DOWN("icloud.and.arrow.down"), + ICLOUD_AND_ARROW_DOWN_FILL("icloud.and.arrow.down.fill"), + ICLOUD_AND_ARROW_UP("icloud.and.arrow.up"), + ICLOUD_AND_ARROW_UP_FILL("icloud.and.arrow.up.fill"), + ICLOUD_CIRCLE("icloud.circle"), + ICLOUD_CIRCLE_FILL("icloud.circle.fill"), + ICLOUD_FILL("icloud.fill"), + ICLOUD_SLASH("icloud.slash"), + ICLOUD_SLASH_FILL("icloud.slash.fill"), + ICLOUD_SQUARE("icloud.square"), + ICLOUD_SQUARE_FILL("icloud.square.fill"), + INCREASE_INDENT("increase.indent"), + INCREASE_QUOTELEVEL("increase.quotelevel"), + INDIANRUPEESIGN("indianrupeesign"), + INDIANRUPEESIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("indianrupeesign.arrow.trianglehead.counterclockwise.rotate.90"), + INDIANRUPEESIGN_BANK_BUILDING("indianrupeesign.bank.building"), + INDIANRUPEESIGN_BANK_BUILDING_FILL("indianrupeesign.bank.building.fill"), + INDIANRUPEESIGN_CIRCLE("indianrupeesign.circle"), + INDIANRUPEESIGN_CIRCLE_FILL("indianrupeesign.circle.fill"), + INDIANRUPEESIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("indianrupeesign.gauge.chart.lefthalf.righthalf"), + INDIANRUPEESIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("indianrupeesign.gauge.chart.leftthird.topthird.rightthird"), + INDIANRUPEESIGN_SQUARE("indianrupeesign.square"), + INDIANRUPEESIGN_SQUARE_FILL("indianrupeesign.square.fill"), + INFINITY("infinity"), + INFINITY_CIRCLE("infinity.circle"), + INFINITY_CIRCLE_FILL("infinity.circle.fill"), + INHALER("inhaler"), + INHALER_FILL("inhaler.fill"), + INTERNALDRIVE("internaldrive"), + INTERNALDRIVE_FILL("internaldrive.fill"), + IPOD("ipod"), + IPOD_SHUFFLE_GEN1("ipod.shuffle.gen1"), + IPOD_SHUFFLE_GEN2("ipod.shuffle.gen2"), + IPOD_SHUFFLE_GEN3("ipod.shuffle.gen3"), + IPOD_SHUFFLE_GEN4("ipod.shuffle.gen4"), + IPOD_TOUCH("ipod.touch"), + IPOD_TOUCH_LANDSCAPE("ipod.touch.landscape"), + IPOD_TOUCH_SLASH("ipod.touch.slash"), + IVFLUID_BAG("ivfluid.bag"), + IVFLUID_BAG_FILL("ivfluid.bag.fill"), + JACKET("jacket"), + JACKET_FILL("jacket.fill"), + K("k"), + KASHIDA_ARABIC("kashida.arabic"), + KPH("kph"), + KPH_CIRCLE("kph.circle"), + KPH_CIRCLE_FILL("kph.circle.fill"), + L1_BUTTON_ROUNDEDBOTTOM_HORIZONTAL("l1.button.roundedbottom.horizontal"), + L1_BUTTON_ROUNDEDBOTTOM_HORIZONTAL_FILL("l1.button.roundedbottom.horizontal.fill"), + L1_CIRCLE("l1.circle"), + L1_CIRCLE_FILL("l1.circle.fill"), + L2_BUTTON_ANGLEDTOP_VERTICAL_LEFT("l2.button.angledtop.vertical.left"), + L2_BUTTON_ANGLEDTOP_VERTICAL_LEFT_FILL("l2.button.angledtop.vertical.left.fill"), + L2_BUTTON_ROUNDEDTOP_HORIZONTAL("l2.button.roundedtop.horizontal"), + L2_BUTTON_ROUNDEDTOP_HORIZONTAL_FILL("l2.button.roundedtop.horizontal.fill"), + L2_CIRCLE("l2.circle"), + L2_CIRCLE_FILL("l2.circle.fill"), + L3_BUTTON_ANGLEDBOTTOM_HORIZONTAL_LEFT("l3.button.angledbottom.horizontal.left"), + L3_BUTTON_ANGLEDBOTTOM_HORIZONTAL_LEFT_FILL("l3.button.angledbottom.horizontal.left.fill"), + L4_BUTTON_HORIZONTAL("l4.button.horizontal"), + L4_BUTTON_HORIZONTAL_FILL("l4.button.horizontal.fill"), + LADYBUG("ladybug"), + LADYBUG_CIRCLE("ladybug.circle"), + LADYBUG_CIRCLE_FILL("ladybug.circle.fill"), + LADYBUG_FILL("ladybug.fill"), + LADYBUG_SLASH("ladybug.slash"), + LADYBUG_SLASH_CIRCLE("ladybug.slash.circle"), + LADYBUG_SLASH_CIRCLE_FILL("ladybug.slash.circle.fill"), + LADYBUG_SLASH_FILL("ladybug.slash.fill"), + LANE("lane"), + LANYARDCARD("lanyardcard"), + LANYARDCARD_FILL("lanyardcard.fill"), + LASER_BURST("laser.burst"), + LASSO("lasso"), + LASSO_BADGE_SPARKLES("lasso.badge.sparkles"), + LATCH_2_CASE("latch.2.case"), + LATCH_2_CASE_FILL("latch.2.case.fill"), + LAUREL_LEADING("laurel.leading"), + LAUREL_TRAILING("laurel.trailing"), + LB_BUTTON_ROUNDEDBOTTOM_HORIZONTAL("lb.button.roundedbottom.horizontal"), + LB_BUTTON_ROUNDEDBOTTOM_HORIZONTAL_FILL("lb.button.roundedbottom.horizontal.fill"), + LB_CIRCLE("lb.circle"), + LB_CIRCLE_FILL("lb.circle.fill"), + LEAF("leaf"), + LEAF_ARROW_TRIANGLEHEAD_CLOCKWISE("leaf.arrow.trianglehead.clockwise"), + LEAF_CIRCLE("leaf.circle"), + LEAF_CIRCLE_FILL("leaf.circle.fill"), + LEAF_FILL("leaf.fill"), + LEFT("left"), + LEFT_CIRCLE("left.circle"), + LEFT_CIRCLE_FILL("left.circle.fill"), + LESSTHAN("lessthan"), + LESSTHAN_CIRCLE("lessthan.circle"), + LESSTHAN_CIRCLE_FILL("lessthan.circle.fill"), + LESSTHAN_SQUARE("lessthan.square"), + LESSTHAN_SQUARE_FILL("lessthan.square.fill"), + LESSTHANOREQUALTO("lessthanorequalto"), + LESSTHANOREQUALTO_CIRCLE("lessthanorequalto.circle"), + LESSTHANOREQUALTO_CIRCLE_FILL("lessthanorequalto.circle.fill"), + LESSTHANOREQUALTO_SQUARE("lessthanorequalto.square"), + LESSTHANOREQUALTO_SQUARE_FILL("lessthanorequalto.square.fill"), + LICENSEPLATE("licenseplate"), + LICENSEPLATE_FILL("licenseplate.fill"), + LIFEPRESERVER("lifepreserver"), + LIFEPRESERVER_FILL("lifepreserver.fill"), + LIGHTBULB("lightbulb"), + LIGHTBULB_2("lightbulb.2"), + LIGHTBULB_2_FILL("lightbulb.2.fill"), + LIGHTBULB_CIRCLE("lightbulb.circle"), + LIGHTBULB_CIRCLE_FILL("lightbulb.circle.fill"), + LIGHTBULB_FILL("lightbulb.fill"), + LIGHTBULB_LED("lightbulb.led"), + LIGHTBULB_LED_FILL("lightbulb.led.fill"), + LIGHTBULB_LED_WIDE("lightbulb.led.wide"), + LIGHTBULB_LED_WIDE_FILL("lightbulb.led.wide.fill"), + LIGHTBULB_MAX("lightbulb.max"), + LIGHTBULB_MAX_FILL("lightbulb.max.fill"), + LIGHTBULB_MIN("lightbulb.min"), + LIGHTBULB_MIN_BADGE_EXCLAMATIONMARK("lightbulb.min.badge.exclamationmark"), + LIGHTBULB_MIN_BADGE_EXCLAMATIONMARK_FILL("lightbulb.min.badge.exclamationmark.fill"), + LIGHTBULB_MIN_FILL("lightbulb.min.fill"), + LIGHTBULB_SLASH("lightbulb.slash"), + LIGHTBULB_SLASH_FILL("lightbulb.slash.fill"), + LIGHTRAIL("lightrail"), + LIGHTRAIL_FILL("lightrail.fill"), + LIGHTSPECTRUM_HORIZONTAL("lightspectrum.horizontal"), + LIRASIGN("lirasign"), + LIRASIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("lirasign.arrow.trianglehead.counterclockwise.rotate.90"), + LIRASIGN_BANK_BUILDING("lirasign.bank.building"), + LIRASIGN_BANK_BUILDING_FILL("lirasign.bank.building.fill"), + LIRASIGN_CIRCLE("lirasign.circle"), + LIRASIGN_CIRCLE_FILL("lirasign.circle.fill"), + LIRASIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("lirasign.gauge.chart.lefthalf.righthalf"), + LIRASIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("lirasign.gauge.chart.leftthird.topthird.rightthird"), + LIRASIGN_SQUARE("lirasign.square"), + LIRASIGN_SQUARE_FILL("lirasign.square.fill"), + LIZARD("lizard"), + LIZARD_CIRCLE("lizard.circle"), + LIZARD_CIRCLE_FILL("lizard.circle.fill"), + LIZARD_FILL("lizard.fill"), + LM_BUTTON_HORIZONTAL("lm.button.horizontal"), + LM_BUTTON_HORIZONTAL_FILL("lm.button.horizontal.fill"), + LOUPE("loupe"), + LSB_BUTTON_ANGLEDBOTTOM_HORIZONTAL_LEFT("lsb.button.angledbottom.horizontal.left"), + LSB_BUTTON_ANGLEDBOTTOM_HORIZONTAL_LEFT_FILL("lsb.button.angledbottom.horizontal.left.fill"), + LT_BUTTON_ROUNDEDTOP_HORIZONTAL("lt.button.roundedtop.horizontal"), + LT_BUTTON_ROUNDEDTOP_HORIZONTAL_FILL("lt.button.roundedtop.horizontal.fill"), + LT_CIRCLE("lt.circle"), + LT_CIRCLE_FILL("lt.circle.fill"), + M1_BUTTON_HORIZONTAL("m1.button.horizontal"), + M1_BUTTON_HORIZONTAL_FILL("m1.button.horizontal.fill"), + M2_BUTTON_HORIZONTAL("m2.button.horizontal"), + M2_BUTTON_HORIZONTAL_FILL("m2.button.horizontal.fill"), + M3_BUTTON_HORIZONTAL("m3.button.horizontal"), + M3_BUTTON_HORIZONTAL_FILL("m3.button.horizontal.fill"), + M4_BUTTON_HORIZONTAL("m4.button.horizontal"), + M4_BUTTON_HORIZONTAL_FILL("m4.button.horizontal.fill"), + MAGAZINE("magazine"), + MAGAZINE_FILL("magazine.fill"), + MAGICMOUSE("magicmouse"), + MAGICMOUSE_FILL("magicmouse.fill"), + MAGSAFE_BATTERYPACK("magsafe.batterypack"), + MAGSAFE_BATTERYPACK_FILL("magsafe.batterypack.fill"), + MALAYSIANRINGGITSIGN("malaysianringgitsign"), + MALAYSIANRINGGITSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("malaysianringgitsign.arrow.trianglehead.counterclockwise.rotate.90"), + MALAYSIANRINGGITSIGN_BANK_BUILDING("malaysianringgitsign.bank.building"), + MALAYSIANRINGGITSIGN_BANK_BUILDING_FILL("malaysianringgitsign.bank.building.fill"), + MALAYSIANRINGGITSIGN_CIRCLE("malaysianringgitsign.circle"), + MALAYSIANRINGGITSIGN_CIRCLE_FILL("malaysianringgitsign.circle.fill"), + MALAYSIANRINGGITSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("malaysianringgitsign.gauge.chart.lefthalf.righthalf"), + MALAYSIANRINGGITSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("malaysianringgitsign.gauge.chart.leftthird.topthird.rightthird"), + MALAYSIANRINGGITSIGN_SQUARE("malaysianringgitsign.square"), + MALAYSIANRINGGITSIGN_SQUARE_FILL("malaysianringgitsign.square.fill"), + MEDAL("medal"), + MEDAL_FILL("medal.fill"), + MEDAL_STAR("medal.star"), + MEDAL_STAR_FILL("medal.star.fill"), + MEDIASTICK("mediastick"), + MEMORIES("memories"), + MEMORIES_BADGE_MINUS("memories.badge.minus"), + MEMORIES_BADGE_PLUS("memories.badge.plus"), + MENUBAR_ARROW_DOWN_RECTANGLE("menubar.arrow.down.rectangle"), + MENUBAR_ARROW_UP_RECTANGLE("menubar.arrow.up.rectangle"), + MENUBAR_DOCK_RECTANGLE("menubar.dock.rectangle"), + MENUBAR_DOCK_RECTANGLE_BADGE_RECORD("menubar.dock.rectangle.badge.record"), + MENUBAR_RECTANGLE("menubar.rectangle"), + MENUCARD("menucard"), + MENUCARD_FILL("menucard.fill"), + METRONOME("metronome"), + METRONOME_FILL("metronome.fill"), + MILLSIGN("millsign"), + MILLSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("millsign.arrow.trianglehead.counterclockwise.rotate.90"), + MILLSIGN_BANK_BUILDING("millsign.bank.building"), + MILLSIGN_BANK_BUILDING_FILL("millsign.bank.building.fill"), + MILLSIGN_CIRCLE("millsign.circle"), + MILLSIGN_CIRCLE_FILL("millsign.circle.fill"), + MILLSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("millsign.gauge.chart.lefthalf.righthalf"), + MILLSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("millsign.gauge.chart.leftthird.topthird.rightthird"), + MILLSIGN_SQUARE("millsign.square"), + MILLSIGN_SQUARE_FILL("millsign.square.fill"), + MIRROR_SIDE_LEFT("mirror.side.left"), + MIRROR_SIDE_LEFT_AND_ARROW_TURN_DOWN_RIGHT("mirror.side.left.and.arrow.turn.down.right"), + MIRROR_SIDE_LEFT_AND_HEAT_WAVES("mirror.side.left.and.heat.waves"), + MIRROR_SIDE_RIGHT("mirror.side.right"), + MIRROR_SIDE_RIGHT_AND_ARROW_TURN_DOWN_LEFT("mirror.side.right.and.arrow.turn.down.left"), + MIRROR_SIDE_RIGHT_AND_HEAT_WAVES("mirror.side.right.and.heat.waves"), + MOPED("moped"), + MOPED_FILL("moped.fill"), + MOSAIC("mosaic"), + MOSAIC_FILL("mosaic.fill"), + MOTORCYCLE("motorcycle"), + MOTORCYCLE_FILL("motorcycle.fill"), + MOUNT("mount"), + MOUNT_FILL("mount.fill"), + MOUNTAIN_2("mountain.2"), + MOUNTAIN_2_CIRCLE("mountain.2.circle"), + MOUNTAIN_2_CIRCLE_FILL("mountain.2.circle.fill"), + MOUNTAIN_2_FILL("mountain.2.fill"), + MOVE_3D("move.3d"), + MOVIECLAPPER("movieclapper"), + MOVIECLAPPER_FILL("movieclapper.fill"), + MPH("mph"), + MPH_CIRCLE("mph.circle"), + MPH_CIRCLE_FILL("mph.circle.fill"), + MUG("mug"), + MUG_FILL("mug.fill"), + MULTIPLY("multiply"), + MULTIPLY_CIRCLE("multiply.circle"), + MULTIPLY_CIRCLE_FILL("multiply.circle.fill"), + MULTIPLY_SQUARE("multiply.square"), + MULTIPLY_SQUARE_FILL("multiply.square.fill"), + MUSTACHE("mustache"), + MUSTACHE_FILL("mustache.fill"), + NAIRASIGN("nairasign"), + NAIRASIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("nairasign.arrow.trianglehead.counterclockwise.rotate.90"), + NAIRASIGN_BANK_BUILDING("nairasign.bank.building"), + NAIRASIGN_BANK_BUILDING_FILL("nairasign.bank.building.fill"), + NAIRASIGN_CIRCLE("nairasign.circle"), + NAIRASIGN_CIRCLE_FILL("nairasign.circle.fill"), + NAIRASIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("nairasign.gauge.chart.lefthalf.righthalf"), + NAIRASIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("nairasign.gauge.chart.leftthird.topthird.rightthird"), + NAIRASIGN_SQUARE("nairasign.square"), + NAIRASIGN_SQUARE_FILL("nairasign.square.fill"), + NORWEGIANKRONESIGN("norwegiankronesign"), + NORWEGIANKRONESIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("norwegiankronesign.arrow.trianglehead.counterclockwise.rotate.90"), + NORWEGIANKRONESIGN_BANK_BUILDING("norwegiankronesign.bank.building"), + NORWEGIANKRONESIGN_BANK_BUILDING_FILL("norwegiankronesign.bank.building.fill"), + NORWEGIANKRONESIGN_CIRCLE("norwegiankronesign.circle"), + NORWEGIANKRONESIGN_CIRCLE_FILL("norwegiankronesign.circle.fill"), + NORWEGIANKRONESIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("norwegiankronesign.gauge.chart.lefthalf.righthalf"), + NORWEGIANKRONESIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("norwegiankronesign.gauge.chart.leftthird.topthird.rightthird"), + NORWEGIANKRONESIGN_SQUARE("norwegiankronesign.square"), + NORWEGIANKRONESIGN_SQUARE_FILL("norwegiankronesign.square.fill"), + NOSIGN("nosign"), + NOSIGN_APP("nosign.app"), + NOSIGN_APP_FILL("nosign.app.fill"), + NOTE("note"), + NOTE_TEXT("note.text"), + NOTE_TEXT_BADGE_PLUS("note.text.badge.plus"), + NOTEQUAL("notequal"), + NOTEQUAL_CIRCLE("notequal.circle"), + NOTEQUAL_CIRCLE_FILL("notequal.circle.fill"), + NOTEQUAL_SQUARE("notequal.square"), + NOTEQUAL_SQUARE_FILL("notequal.square.fill"), + OAR_2_CROSSED("oar.2.crossed"), + OAR_2_CROSSED_CIRCLE("oar.2.crossed.circle"), + OAR_2_CROSSED_CIRCLE_FILL("oar.2.crossed.circle.fill"), + OPTICALDISC("opticaldisc"), + OPTICALDISC_FILL("opticaldisc.fill"), + OPTICALDISCDRIVE("opticaldiscdrive"), + OPTICALDISCDRIVE_FILL("opticaldiscdrive.fill"), + OPTICID("opticid"), + OPTICID_FILL("opticid.fill"), + OPTION("option"), + P1_BUTTON_HORIZONTAL("p1.button.horizontal"), + P1_BUTTON_HORIZONTAL_FILL("p1.button.horizontal.fill"), + P2_BUTTON_HORIZONTAL("p2.button.horizontal"), + P2_BUTTON_HORIZONTAL_FILL("p2.button.horizontal.fill"), + P3_BUTTON_HORIZONTAL("p3.button.horizontal"), + P3_BUTTON_HORIZONTAL_FILL("p3.button.horizontal.fill"), + P4_BUTTON_HORIZONTAL("p4.button.horizontal"), + P4_BUTTON_HORIZONTAL_FILL("p4.button.horizontal.fill"), + PADDLESHIFTER_LEFT("paddleshifter.left"), + PADDLESHIFTER_LEFT_FILL("paddleshifter.left.fill"), + PADDLESHIFTER_RIGHT("paddleshifter.right"), + PADDLESHIFTER_RIGHT_FILL("paddleshifter.right.fill"), + PAINTPALETTE("paintpalette"), + PAINTPALETTE_FILL("paintpalette.fill"), + PANO("pano"), + PANO_BADGE_PLAY("pano.badge.play"), + PANO_BADGE_PLAY_FILL("pano.badge.play.fill"), + PANO_FILL("pano.fill"), + PAPERPLANE("paperplane"), + PAPERPLANE_CIRCLE("paperplane.circle"), + PAPERPLANE_CIRCLE_FILL("paperplane.circle.fill"), + PAPERPLANE_FILL("paperplane.fill"), + PARENTHESES("parentheses"), + PARKINGLIGHT("parkinglight"), + PARKINGLIGHT_FILL("parkinglight.fill"), + PARTY_POPPER("party.popper"), + PARTY_POPPER_FILL("party.popper.fill"), + PAWPRINT("pawprint"), + PAWPRINT_CIRCLE("pawprint.circle"), + PAWPRINT_CIRCLE_FILL("pawprint.circle.fill"), + PAWPRINT_FILL("pawprint.fill"), + PC("pc"), + PEACESIGN("peacesign"), + PEDAL_ACCELERATOR("pedal.accelerator"), + PEDAL_ACCELERATOR_FILL("pedal.accelerator.fill"), + PEDAL_BRAKE("pedal.brake"), + PEDAL_BRAKE_FILL("pedal.brake.fill"), + PEDAL_CLUTCH("pedal.clutch"), + PEDAL_CLUTCH_FILL("pedal.clutch.fill"), + PEDESTRIAN_GATE_CLOSED("pedestrian.gate.closed"), + PEDESTRIAN_GATE_OPEN("pedestrian.gate.open"), + PERCENT("percent"), + PERSPECTIVE("perspective"), + PERUVIANSOLESSIGN("peruviansolessign"), + PERUVIANSOLESSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("peruviansolessign.arrow.trianglehead.counterclockwise.rotate.90"), + PERUVIANSOLESSIGN_BANK_BUILDING("peruviansolessign.bank.building"), + PERUVIANSOLESSIGN_BANK_BUILDING_FILL("peruviansolessign.bank.building.fill"), + PERUVIANSOLESSIGN_CIRCLE("peruviansolessign.circle"), + PERUVIANSOLESSIGN_CIRCLE_FILL("peruviansolessign.circle.fill"), + PERUVIANSOLESSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("peruviansolessign.gauge.chart.lefthalf.righthalf"), + PERUVIANSOLESSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("peruviansolessign.gauge.chart.leftthird.topthird.rightthird"), + PERUVIANSOLESSIGN_SQUARE("peruviansolessign.square"), + PERUVIANSOLESSIGN_SQUARE_FILL("peruviansolessign.square.fill"), + PESETASIGN("pesetasign"), + PESETASIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("pesetasign.arrow.trianglehead.counterclockwise.rotate.90"), + PESETASIGN_BANK_BUILDING("pesetasign.bank.building"), + PESETASIGN_BANK_BUILDING_FILL("pesetasign.bank.building.fill"), + PESETASIGN_CIRCLE("pesetasign.circle"), + PESETASIGN_CIRCLE_FILL("pesetasign.circle.fill"), + PESETASIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("pesetasign.gauge.chart.lefthalf.righthalf"), + PESETASIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("pesetasign.gauge.chart.leftthird.topthird.rightthird"), + PESETASIGN_SQUARE("pesetasign.square"), + PESETASIGN_SQUARE_FILL("pesetasign.square.fill"), + PIANOKEYS("pianokeys"), + PIANOKEYS_INVERSE("pianokeys.inverse"), + PIP("pip"), + PIP_ENTER("pip.enter"), + PIP_EXIT("pip.exit"), + PIP_FILL("pip.fill"), + PIP_REMOVE("pip.remove"), + PIP_SWAP("pip.swap"), + PLACEHOLDERTEXT_FILL("placeholdertext.fill"), + PLATTER_2_FILLED_IPAD("platter.2.filled.ipad"), + PLATTER_2_FILLED_IPAD_LANDSCAPE("platter.2.filled.ipad.landscape"), + PLATTER_2_FILLED_IPHONE("platter.2.filled.iphone"), + PLATTER_2_FILLED_IPHONE_LANDSCAPE("platter.2.filled.iphone.landscape"), + PLATTER_BOTTOM_APPLEWATCH_CASE("platter.bottom.applewatch.case"), + PLATTER_FILLED_BOTTOM_AND_ARROW_DOWN_IPHONE("platter.filled.bottom.and.arrow.down.iphone"), + PLATTER_FILLED_BOTTOM_APPLEWATCH_CASE("platter.filled.bottom.applewatch.case"), + PLATTER_FILLED_BOTTOM_IPHONE("platter.filled.bottom.iphone"), + PLATTER_FILLED_TOP_AND_ARROW_UP_IPHONE("platter.filled.top.and.arrow.up.iphone"), + PLATTER_FILLED_TOP_APPLEWATCH_CASE("platter.filled.top.applewatch.case"), + PLATTER_FILLED_TOP_IPHONE("platter.filled.top.iphone"), + PLATTER_TOP_APPLEWATCH_CASE("platter.top.applewatch.case"), + POINT_BOTTOMLEFT_FILLED_FORWARD_TO_POINT_TOPRIGHT_SCURVEPATH("point.bottomleft.filled.forward.to.point.topright.scurvepath"), + POINT_BOTTOMLEFT_FORWARD_TO_ARROW_TRIANGLE_SCURVEPATH("point.bottomleft.forward.to.arrow.triangle.scurvepath"), + POINT_BOTTOMLEFT_FORWARD_TO_ARROW_TRIANGLE_SCURVEPATH_FILL("point.bottomleft.forward.to.arrow.triangle.scurvepath.fill"), + POINT_BOTTOMLEFT_FORWARD_TO_ARROW_TRIANGLE_UTURN_SCURVEPATH("point.bottomleft.forward.to.arrow.triangle.uturn.scurvepath"), + POINT_BOTTOMLEFT_FORWARD_TO_ARROW_TRIANGLE_UTURN_SCURVEPATH_FILL("point.bottomleft.forward.to.arrow.triangle.uturn.scurvepath.fill"), + POINT_BOTTOMLEFT_FORWARD_TO_POINT_TOPRIGHT_FILLED_SCURVEPATH("point.bottomleft.forward.to.point.topright.filled.scurvepath"), + POINT_BOTTOMLEFT_FORWARD_TO_POINT_TOPRIGHT_SCURVEPATH("point.bottomleft.forward.to.point.topright.scurvepath"), + POINT_BOTTOMLEFT_FORWARD_TO_POINT_TOPRIGHT_SCURVEPATH_FILL("point.bottomleft.forward.to.point.topright.scurvepath.fill"), + POINT_FORWARD_TO_POINT_CAPSULEPATH("point.forward.to.point.capsulepath"), + POINT_FORWARD_TO_POINT_CAPSULEPATH_FILL("point.forward.to.point.capsulepath.fill"), + POINT_TOPLEFT_DOWN_TO_POINT_BOTTOMRIGHT_CURVEPATH("point.topleft.down.to.point.bottomright.curvepath"), + POINT_TOPLEFT_DOWN_TO_POINT_BOTTOMRIGHT_CURVEPATH_FILL("point.topleft.down.to.point.bottomright.curvepath.fill"), + POINT_TOPLEFT_DOWN_TO_POINT_BOTTOMRIGHT_FILLED_CURVEPATH("point.topleft.down.to.point.bottomright.filled.curvepath"), + POINT_TOPLEFT_FILLED_DOWN_TO_POINT_BOTTOMRIGHT_CURVEPATH("point.topleft.filled.down.to.point.bottomright.curvepath"), + POINT_TOPRIGHT_ARROW_TRIANGLE_BACKWARD_TO_POINT_BOTTOMLEFT_FILLED_SCURVEPATH("point.topright.arrow.triangle.backward.to.point.bottomleft.filled.scurvepath"), + POINT_TOPRIGHT_ARROW_TRIANGLE_BACKWARD_TO_POINT_BOTTOMLEFT_SCURVEPATH("point.topright.arrow.triangle.backward.to.point.bottomleft.scurvepath"), + POINT_TOPRIGHT_ARROW_TRIANGLE_BACKWARD_TO_POINT_BOTTOMLEFT_SCURVEPATH_FILL("point.topright.arrow.triangle.backward.to.point.bottomleft.scurvepath.fill"), + POINT_TOPRIGHT_FILLED_ARROW_TRIANGLE_BACKWARD_TO_POINT_BOTTOMLEFT_SCURVEPATH("point.topright.filled.arrow.triangle.backward.to.point.bottomleft.scurvepath"), + POLISHZLOTYSIGN("polishzlotysign"), + POLISHZLOTYSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("polishzlotysign.arrow.trianglehead.counterclockwise.rotate.90"), + POLISHZLOTYSIGN_BANK_BUILDING("polishzlotysign.bank.building"), + POLISHZLOTYSIGN_BANK_BUILDING_FILL("polishzlotysign.bank.building.fill"), + POLISHZLOTYSIGN_CIRCLE("polishzlotysign.circle"), + POLISHZLOTYSIGN_CIRCLE_FILL("polishzlotysign.circle.fill"), + POLISHZLOTYSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("polishzlotysign.gauge.chart.lefthalf.righthalf"), + POLISHZLOTYSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("polishzlotysign.gauge.chart.leftthird.topthird.rightthird"), + POLISHZLOTYSIGN_SQUARE("polishzlotysign.square"), + POLISHZLOTYSIGN_SQUARE_FILL("polishzlotysign.square.fill"), + POPCORN("popcorn"), + POPCORN_CIRCLE("popcorn.circle"), + POPCORN_CIRCLE_FILL("popcorn.circle.fill"), + POPCORN_FILL("popcorn.fill"), + PROGRESS_INDICATOR("progress.indicator"), + PROJECTIVE("projective"), + PURCHASED("purchased"), + PURCHASED_CIRCLE("purchased.circle"), + PURCHASED_CIRCLE_FILL("purchased.circle.fill"), + PUZZLEPIECE("puzzlepiece"), + PUZZLEPIECE_EXTENSION("puzzlepiece.extension"), + PUZZLEPIECE_EXTENSION_FILL("puzzlepiece.extension.fill"), + PUZZLEPIECE_FILL("puzzlepiece.fill"), + PYRAMID("pyramid"), + PYRAMID_FILL("pyramid.fill"), + QRCODE("qrcode"), + QRCODE_VIEWFINDER("qrcode.viewfinder"), + QUOTE_BUBBLE("quote.bubble"), + QUOTE_BUBBLE_FILL("quote.bubble.fill"), + QUOTE_CLOSING("quote.closing"), + QUOTE_OPENING("quote.opening"), + QUOTELEVEL("quotelevel"), + R1_BUTTON_ROUNDEDBOTTOM_HORIZONTAL("r1.button.roundedbottom.horizontal"), + R1_BUTTON_ROUNDEDBOTTOM_HORIZONTAL_FILL("r1.button.roundedbottom.horizontal.fill"), + R1_CIRCLE("r1.circle"), + R1_CIRCLE_FILL("r1.circle.fill"), + R2_BUTTON_ANGLEDTOP_VERTICAL_RIGHT("r2.button.angledtop.vertical.right"), + R2_BUTTON_ANGLEDTOP_VERTICAL_RIGHT_FILL("r2.button.angledtop.vertical.right.fill"), + R2_BUTTON_ROUNDEDTOP_HORIZONTAL("r2.button.roundedtop.horizontal"), + R2_BUTTON_ROUNDEDTOP_HORIZONTAL_FILL("r2.button.roundedtop.horizontal.fill"), + R2_CIRCLE("r2.circle"), + R2_CIRCLE_FILL("r2.circle.fill"), + R3_BUTTON_ANGLEDBOTTOM_HORIZONTAL_RIGHT("r3.button.angledbottom.horizontal.right"), + R3_BUTTON_ANGLEDBOTTOM_HORIZONTAL_RIGHT_FILL("r3.button.angledbottom.horizontal.right.fill"), + R4_BUTTON_HORIZONTAL("r4.button.horizontal"), + R4_BUTTON_HORIZONTAL_FILL("r4.button.horizontal.fill"), + RADIO("radio"), + RADIO_FILL("radio.fill"), + RAYS("rays"), + RB_BUTTON_ROUNDEDBOTTOM_HORIZONTAL("rb.button.roundedbottom.horizontal"), + RB_BUTTON_ROUNDEDBOTTOM_HORIZONTAL_FILL("rb.button.roundedbottom.horizontal.fill"), + RB_CIRCLE("rb.circle"), + RB_CIRCLE_FILL("rb.circle.fill"), + RESTART("restart"), + RESTART_CIRCLE("restart.circle"), + RESTART_CIRCLE_FILL("restart.circle.fill"), + RETARDER_BRAKESIGNAL("retarder.brakesignal"), + RETARDER_BRAKESIGNAL_AND_EXCLAMATIONMARK("retarder.brakesignal.and.exclamationmark"), + RETARDER_BRAKESIGNAL_SLASH("retarder.brakesignal.slash"), + RICHTEXT_PAGE("richtext.page"), + RICHTEXT_PAGE_FILL("richtext.page.fill"), + RIGHT("right"), + RIGHT_CIRCLE("right.circle"), + RIGHT_CIRCLE_FILL("right.circle.fill"), + RIGHTTRIANGLE("righttriangle"), + RIGHTTRIANGLE_FILL("righttriangle.fill"), + RIGHTTRIANGLE_SPLIT_DIAGONAL("righttriangle.split.diagonal"), + RIGHTTRIANGLE_SPLIT_DIAGONAL_FILL("righttriangle.split.diagonal.fill"), + RM_BUTTON_HORIZONTAL("rm.button.horizontal"), + RM_BUTTON_HORIZONTAL_FILL("rm.button.horizontal.fill"), + ROBOTIC_VACUUM("robotic.vacuum"), + ROBOTIC_VACUUM_FILL("robotic.vacuum.fill"), + ROLLER_SHADE_CLOSED("roller.shade.closed"), + ROLLER_SHADE_OPEN("roller.shade.open"), + ROMAN_SHADE_CLOSED("roman.shade.closed"), + ROMAN_SHADE_OPEN("roman.shade.open"), + ROSETTE("rosette"), + ROTATE_3D("rotate.3d"), + ROTATE_3D_CIRCLE("rotate.3d.circle"), + ROTATE_3D_CIRCLE_FILL("rotate.3d.circle.fill"), + ROTATE_3D_FILL("rotate.3d.fill"), + ROTATE_LEFT("rotate.left"), + ROTATE_LEFT_FILL("rotate.left.fill"), + ROTATE_RIGHT("rotate.right"), + ROTATE_RIGHT_FILL("rotate.right.fill"), + RSB_BUTTON_ANGLEDBOTTOM_HORIZONTAL_RIGHT("rsb.button.angledbottom.horizontal.right"), + RSB_BUTTON_ANGLEDBOTTOM_HORIZONTAL_RIGHT_FILL("rsb.button.angledbottom.horizontal.right.fill"), + RT_BUTTON_ROUNDEDTOP_HORIZONTAL("rt.button.roundedtop.horizontal"), + RT_BUTTON_ROUNDEDTOP_HORIZONTAL_FILL("rt.button.roundedtop.horizontal.fill"), + RT_CIRCLE("rt.circle"), + RT_CIRCLE_FILL("rt.circle.fill"), + RULER("ruler"), + RULER_FILL("ruler.fill"), + SCALE_3D("scale.3d"), + SCALEMASS("scalemass"), + SCALEMASS_FILL("scalemass.fill"), + SCRIBBLE("scribble"), + SCRIBBLE_VARIABLE("scribble.variable"), + SCROLL("scroll"), + SCROLL_FILL("scroll.fill"), + SDCARD("sdcard"), + SDCARD_FILL("sdcard.fill"), + SELECTION_PIN_IN_OUT("selection.pin.in.out"), + SHADOW("shadow"), + SHAREDWITHYOU("sharedwithyou"), + SHAREDWITHYOU_CIRCLE("sharedwithyou.circle"), + SHAREDWITHYOU_CIRCLE_FILL("sharedwithyou.circle.fill"), + SHAREDWITHYOU_CIRCLE_SLASH("sharedwithyou.circle.slash"), + SHAREPLAY("shareplay"), + SHAREPLAY_SLASH("shareplay.slash"), + SHAZAM_LOGO("shazam.logo"), + SHAZAM_LOGO_FILL("shazam.logo.fill"), + SHIFT("shift"), + SHIFT_FILL("shift.fill"), + SHIPPINGBOX("shippingbox"), + SHIPPINGBOX_AND_ARROW_BACKWARD("shippingbox.and.arrow.backward"), + SHIPPINGBOX_AND_ARROW_BACKWARD_FILL("shippingbox.and.arrow.backward.fill"), + SHIPPINGBOX_CIRCLE("shippingbox.circle"), + SHIPPINGBOX_CIRCLE_FILL("shippingbox.circle.fill"), + SHIPPINGBOX_FILL("shippingbox.fill"), + SHOE("shoe"), + SHOE_2("shoe.2"), + SHOE_2_FILL("shoe.2.fill"), + SHOE_CIRCLE("shoe.circle"), + SHOE_CIRCLE_FILL("shoe.circle.fill"), + SHOE_FILL("shoe.fill"), + SHOEPRINTS_FILL("shoeprints.fill"), + SIDEBAR_LEADING("sidebar.leading"), + SIDEBAR_LEFT("sidebar.left"), + SIDEBAR_RIGHT("sidebar.right"), + SIDEBAR_SQUARES_LEADING("sidebar.squares.leading"), + SIDEBAR_SQUARES_LEFT("sidebar.squares.left"), + SIDEBAR_SQUARES_RIGHT("sidebar.squares.right"), + SIDEBAR_SQUARES_TRAILING("sidebar.squares.trailing"), + SIDEBAR_TRAILING("sidebar.trailing"), + SIGNATURE("signature"), + SIGNPOST_AND_ARROWTRIANGLE_UP("signpost.and.arrowtriangle.up"), + SIGNPOST_AND_ARROWTRIANGLE_UP_CIRCLE("signpost.and.arrowtriangle.up.circle"), + SIGNPOST_AND_ARROWTRIANGLE_UP_CIRCLE_FILL("signpost.and.arrowtriangle.up.circle.fill"), + SIGNPOST_AND_ARROWTRIANGLE_UP_FILL("signpost.and.arrowtriangle.up.fill"), + SIGNPOST_LEFT("signpost.left"), + SIGNPOST_LEFT_CIRCLE("signpost.left.circle"), + SIGNPOST_LEFT_CIRCLE_FILL("signpost.left.circle.fill"), + SIGNPOST_LEFT_FILL("signpost.left.fill"), + SIGNPOST_RIGHT("signpost.right"), + SIGNPOST_RIGHT_AND_LEFT("signpost.right.and.left"), + SIGNPOST_RIGHT_AND_LEFT_CIRCLE("signpost.right.and.left.circle"), + SIGNPOST_RIGHT_AND_LEFT_CIRCLE_FILL("signpost.right.and.left.circle.fill"), + SIGNPOST_RIGHT_AND_LEFT_FILL("signpost.right.and.left.fill"), + SIGNPOST_RIGHT_CIRCLE("signpost.right.circle"), + SIGNPOST_RIGHT_CIRCLE_FILL("signpost.right.circle.fill"), + SIGNPOST_RIGHT_FILL("signpost.right.fill"), + SIMCARD("simcard"), + SIMCARD_2("simcard.2"), + SIMCARD_2_FILL("simcard.2.fill"), + SIMCARD_FILL("simcard.fill"), + SINGAPOREDOLLARSIGN("singaporedollarsign"), + SINGAPOREDOLLARSIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("singaporedollarsign.arrow.trianglehead.counterclockwise.rotate.90"), + SINGAPOREDOLLARSIGN_BANK_BUILDING("singaporedollarsign.bank.building"), + SINGAPOREDOLLARSIGN_BANK_BUILDING_FILL("singaporedollarsign.bank.building.fill"), + SINGAPOREDOLLARSIGN_CIRCLE("singaporedollarsign.circle"), + SINGAPOREDOLLARSIGN_CIRCLE_FILL("singaporedollarsign.circle.fill"), + SINGAPOREDOLLARSIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("singaporedollarsign.gauge.chart.lefthalf.righthalf"), + SINGAPOREDOLLARSIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("singaporedollarsign.gauge.chart.leftthird.topthird.rightthird"), + SINGAPOREDOLLARSIGN_SQUARE("singaporedollarsign.square"), + SINGAPOREDOLLARSIGN_SQUARE_FILL("singaporedollarsign.square.fill"), + SKATEBOARD("skateboard"), + SKATEBOARD_FILL("skateboard.fill"), + SKEW("skew"), + SKIS("skis"), + SKIS_FILL("skis.fill"), + SLASH_CIRCLE("slash.circle"), + SLASH_CIRCLE_FILL("slash.circle.fill"), + SLEEP("sleep"), + SLEEP_CIRCLE("sleep.circle"), + SLEEP_CIRCLE_FILL("sleep.circle.fill"), + SLIDER_HORIZONTAL_2_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("slider.horizontal.2.arrow.trianglehead.counterclockwise"), + SLIDER_HORIZONTAL_2_RECTANGLE_AND_ARROW_TRIANGLEHEAD_2_CLOCKWISE_ROTATE_90("slider.horizontal.2.rectangle.and.arrow.trianglehead.2.clockwise.rotate.90"), + SLIDER_HORIZONTAL_2_SQUARE("slider.horizontal.2.square"), + SLIDER_HORIZONTAL_2_SQUARE_BADGE_ARROW_DOWN("slider.horizontal.2.square.badge.arrow.down"), + SLIDER_HORIZONTAL_2_SQUARE_ON_SQUARE("slider.horizontal.2.square.on.square"), + SLIDER_HORIZONTAL_3("slider.horizontal.3"), + SLIDER_HORIZONTAL_BELOW_RECTANGLE("slider.horizontal.below.rectangle"), + SLIDER_HORIZONTAL_BELOW_SQUARE_AND_SQUARE_FILLED("slider.horizontal.below.square.and.square.filled"), + SLIDER_HORIZONTAL_BELOW_SQUARE_FILLED_AND_SQUARE("slider.horizontal.below.square.filled.and.square"), + SLIDER_HORIZONTAL_BELOW_SUN_MAX("slider.horizontal.below.sun.max"), + SLIDER_VERTICAL_3("slider.vertical.3"), + SLOWMO("slowmo"), + SMALLCIRCLE_CIRCLE("smallcircle.circle"), + SMALLCIRCLE_CIRCLE_FILL("smallcircle.circle.fill"), + SMALLCIRCLE_FILLED_CIRCLE("smallcircle.filled.circle"), + SMALLCIRCLE_FILLED_CIRCLE_FILL("smallcircle.filled.circle.fill"), + SMARTPHONE("smartphone"), + SOS("sos"), + SOS_CIRCLE("sos.circle"), + SOS_CIRCLE_FILL("sos.circle.fill"), + SPACE("space"), + SPRINKLER("sprinkler"), + SPRINKLER_AND_DROPLETS("sprinkler.and.droplets"), + SPRINKLER_AND_DROPLETS_FILL("sprinkler.and.droplets.fill"), + SPRINKLER_FILL("sprinkler.fill"), + STOREFRONT("storefront"), + STOREFRONT_CIRCLE("storefront.circle"), + STOREFRONT_CIRCLE_FILL("storefront.circle.fill"), + STOREFRONT_FILL("storefront.fill"), + STOVE("stove"), + STOVE_FILL("stove.fill"), + STROLLER("stroller"), + STROLLER_FILL("stroller.fill"), + STUDENTDESK("studentdesk"), + SUITCASE("suitcase"), + SUITCASE_CART("suitcase.cart"), + SUITCASE_CART_FILL("suitcase.cart.fill"), + SUITCASE_FILL("suitcase.fill"), + SUITCASE_ROLLING("suitcase.rolling"), + SUITCASE_ROLLING_FILL("suitcase.rolling.fill"), + SUM("sum"), + SURFBOARD("surfboard"), + SURFBOARD_FILL("surfboard.fill"), + SWATCHPALETTE("swatchpalette"), + SWATCHPALETTE_FILL("swatchpalette.fill"), + SWEDISHKRONASIGN("swedishkronasign"), + SWEDISHKRONASIGN_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("swedishkronasign.arrow.trianglehead.counterclockwise.rotate.90"), + SWEDISHKRONASIGN_BANK_BUILDING("swedishkronasign.bank.building"), + SWEDISHKRONASIGN_BANK_BUILDING_FILL("swedishkronasign.bank.building.fill"), + SWEDISHKRONASIGN_CIRCLE("swedishkronasign.circle"), + SWEDISHKRONASIGN_CIRCLE_FILL("swedishkronasign.circle.fill"), + SWEDISHKRONASIGN_GAUGE_CHART_LEFTHALF_RIGHTHALF("swedishkronasign.gauge.chart.lefthalf.righthalf"), + SWEDISHKRONASIGN_GAUGE_CHART_LEFTTHIRD_TOPTHIRD_RIGHTTHIRD("swedishkronasign.gauge.chart.leftthird.topthird.rightthird"), + SWEDISHKRONASIGN_SQUARE("swedishkronasign.square"), + SWEDISHKRONASIGN_SQUARE_FILL("swedishkronasign.square.fill"), + SWIFT("swift"), + SWIFTDATA("swiftdata"), + SWIRL_CIRCLE_RIGHTHALF_FILLED("swirl.circle.righthalf.filled"), + SWIRL_CIRCLE_RIGHTHALF_FILLED_INVERSE("swirl.circle.righthalf.filled.inverse"), + TACHOMETER("tachometer"), + TAILLIGHT_FOG("taillight.fog"), + TAILLIGHT_FOG_FILL("taillight.fog.fill"), + TAKEOUTBAG_AND_CUP_AND_STRAW("takeoutbag.and.cup.and.straw"), + TAKEOUTBAG_AND_CUP_AND_STRAW_FILL("takeoutbag.and.cup.and.straw.fill"), + TARGET("target"), + TEDDYBEAR("teddybear"), + TEDDYBEAR_FILL("teddybear.fill"), + TESTTUBE_2("testtube.2"), + THEATERMASK_AND_PAINTBRUSH("theatermask.and.paintbrush"), + THEATERMASK_AND_PAINTBRUSH_FILL("theatermask.and.paintbrush.fill"), + THEATERMASKS("theatermasks"), + THEATERMASKS_CIRCLE("theatermasks.circle"), + THEATERMASKS_CIRCLE_FILL("theatermasks.circle.fill"), + THEATERMASKS_FILL("theatermasks.fill"), + TICKET("ticket"), + TICKET_FILL("ticket.fill"), + TIMELAPSE("timelapse"), + TIMELINE_SELECTION("timeline.selection"), + TIRE("tire"), + TIRE_BADGE_SNOWFLAKE("tire.badge.snowflake"), + TIREPRESSURE("tirepressure"), + TOGGLEPOWER("togglepower"), + TORTOISE("tortoise"), + TORTOISE_CIRCLE("tortoise.circle"), + TORTOISE_CIRCLE_FILL("tortoise.circle.fill"), + TORTOISE_FILL("tortoise.fill"), + TORUS("torus"), + TOUCHID("touchid"), + TRACTION_CONTROL_TIREPRESSURE("traction.control.tirepressure"), + TRACTION_CONTROL_TIREPRESSURE_EXCLAMATIONMARK("traction.control.tirepressure.exclamationmark"), + TRACTION_CONTROL_TIREPRESSURE_SLASH("traction.control.tirepressure.slash"), + TRANSLATE("translate"), + TRANSMISSION("transmission"), + TRAPEZOID_AND_LINE_HORIZONTAL("trapezoid.and.line.horizontal"), + TRAPEZOID_AND_LINE_HORIZONTAL_FILL("trapezoid.and.line.horizontal.fill"), + TRAPEZOID_AND_LINE_VERTICAL("trapezoid.and.line.vertical"), + TRAPEZOID_AND_LINE_VERTICAL_FILL("trapezoid.and.line.vertical.fill"), + TRAY("tray"), + TRAY_2("tray.2"), + TRAY_2_FILL("tray.2.fill"), + TRAY_AND_ARROW_DOWN("tray.and.arrow.down"), + TRAY_AND_ARROW_DOWN_FILL("tray.and.arrow.down.fill"), + TRAY_AND_ARROW_UP("tray.and.arrow.up"), + TRAY_AND_ARROW_UP_FILL("tray.and.arrow.up.fill"), + TRAY_CIRCLE("tray.circle"), + TRAY_CIRCLE_FILL("tray.circle.fill"), + TRAY_FILL("tray.fill"), + TRAY_FULL("tray.full"), + TRAY_FULL_FILL("tray.full.fill"), + TREE("tree"), + TREE_CIRCLE("tree.circle"), + TREE_CIRCLE_FILL("tree.circle.fill"), + TREE_FILL("tree.fill"), + TROPHY("trophy"), + TROPHY_CIRCLE("trophy.circle"), + TROPHY_CIRCLE_FILL("trophy.circle.fill"), + TROPHY_FILL("trophy.fill"), + TROPICALSTORM("tropicalstorm"), + TROPICALSTORM_CIRCLE("tropicalstorm.circle"), + TROPICALSTORM_CIRCLE_FILL("tropicalstorm.circle.fill"), + TSHIRT("tshirt"), + TSHIRT_CIRCLE("tshirt.circle"), + TSHIRT_CIRCLE_FILL("tshirt.circle.fill"), + TSHIRT_FILL("tshirt.fill"), + TUNINGFORK("tuningfork"), + UIWINDOW_SPLIT_2X1("uiwindow.split.2x1"), + UMBRELLA("umbrella"), + UMBRELLA_FILL("umbrella.fill"), + UMBRELLA_PERCENT("umbrella.percent"), + UMBRELLA_PERCENT_FILL("umbrella.percent.fill"), + VIAL_VIEWFINDER("vial.viewfinder"), + VIEW_2D("view.2d"), + VIEW_3D("view.3d"), + VIEWFINDER("viewfinder"), + VIEWFINDER_CIRCLE("viewfinder.circle"), + VIEWFINDER_CIRCLE_FILL("viewfinder.circle.fill"), + VIEWFINDER_RECTANGULAR("viewfinder.rectangular"), + VIEWFINDER_TRIANGLEBADGE_EXCLAMATIONMARK("viewfinder.trianglebadge.exclamationmark"), + VISION_PRO("vision.pro"), + VISION_PRO_AND_ARROW_FORWARD("vision.pro.and.arrow.forward"), + VISION_PRO_AND_ARROW_FORWARD_FILL("vision.pro.and.arrow.forward.fill"), + VISION_PRO_BADGE_EXCLAMATIONMARK("vision.pro.badge.exclamationmark"), + VISION_PRO_BADGE_EXCLAMATIONMARK_FILL("vision.pro.badge.exclamationmark.fill"), + VISION_PRO_BADGE_PLAY("vision.pro.badge.play"), + VISION_PRO_BADGE_PLAY_FILL("vision.pro.badge.play.fill"), + VISION_PRO_CIRCLE("vision.pro.circle"), + VISION_PRO_CIRCLE_FILL("vision.pro.circle.fill"), + VISION_PRO_FILL("vision.pro.fill"), + VISION_PRO_SLASH("vision.pro.slash"), + VISION_PRO_SLASH_CIRCLE("vision.pro.slash.circle"), + VISION_PRO_SLASH_CIRCLE_FILL("vision.pro.slash.circle.fill"), + VISION_PRO_SLASH_FILL("vision.pro.slash.fill"), + VISION_PRO_TRIANGLEBADGE_EXCLAMATIONMARK("vision.pro.trianglebadge.exclamationmark"), + VISION_PRO_TRIANGLEBADGE_EXCLAMATIONMARK_FILL("vision.pro.trianglebadge.exclamationmark.fill"), + VOICEOVER("voiceover"), + WAKE("wake"), + WAKE_CIRCLE("wake.circle"), + WAKE_CIRCLE_FILL("wake.circle.fill"), + WALLET_BIFOLD("wallet.bifold"), + WALLET_BIFOLD_FILL("wallet.bifold.fill"), + WALLET_PASS("wallet.pass"), + WALLET_PASS_FILL("wallet.pass.fill"), + WAND_AND_RAYS("wand.and.rays"), + WAND_AND_RAYS_INVERSE("wand.and.rays.inverse"), + WAND_AND_SPARKLES("wand.and.sparkles"), + WAND_AND_SPARKLES_INVERSE("wand.and.sparkles.inverse"), + WARNINGLIGHT("warninglight"), + WARNINGLIGHT_FILL("warninglight.fill"), + WATCH_ANALOG("watch.analog"), + WATCHFACE_APPLEWATCH_CASE("watchface.applewatch.case"), + WATERBOTTLE("waterbottle"), + WATERBOTTLE_FILL("waterbottle.fill"), + WAVE_3_BACKWARD("wave.3.backward"), + WAVE_3_BACKWARD_CIRCLE("wave.3.backward.circle"), + WAVE_3_BACKWARD_CIRCLE_FILL("wave.3.backward.circle.fill"), + WAVE_3_DOWN("wave.3.down"), + WAVE_3_DOWN_CIRCLE("wave.3.down.circle"), + WAVE_3_DOWN_CIRCLE_FILL("wave.3.down.circle.fill"), + WAVE_3_FORWARD("wave.3.forward"), + WAVE_3_FORWARD_CIRCLE("wave.3.forward.circle"), + WAVE_3_FORWARD_CIRCLE_FILL("wave.3.forward.circle.fill"), + WAVE_3_LEFT("wave.3.left"), + WAVE_3_LEFT_CIRCLE("wave.3.left.circle"), + WAVE_3_LEFT_CIRCLE_FILL("wave.3.left.circle.fill"), + WAVE_3_RIGHT("wave.3.right"), + WAVE_3_RIGHT_CIRCLE("wave.3.right.circle"), + WAVE_3_RIGHT_CIRCLE_FILL("wave.3.right.circle.fill"), + WAVE_3_UP("wave.3.up"), + WAVE_3_UP_CIRCLE("wave.3.up.circle"), + WAVE_3_UP_CIRCLE_FILL("wave.3.up.circle.fill"), + WEB_CAMERA("web.camera"), + WEB_CAMERA_FILL("web.camera.fill"), + WHEELCHAIR("wheelchair"), + WIDGET_EXTRALARGE("widget.extralarge"), + WIDGET_EXTRALARGE_BADGE_PLUS("widget.extralarge.badge.plus"), + WIDGET_LARGE("widget.large"), + WIDGET_LARGE_BADGE_PLUS("widget.large.badge.plus"), + WIDGET_MEDIUM("widget.medium"), + WIDGET_MEDIUM_BADGE_PLUS("widget.medium.badge.plus"), + WIDGET_SMALL("widget.small"), + WIDGET_SMALL_BADGE_PLUS("widget.small.badge.plus"), + WINEGLASS("wineglass"), + WINEGLASS_FILL("wineglass.fill"), + WRONGWAYSIGN("wrongwaysign"), + WRONGWAYSIGN_FILL("wrongwaysign.fill"), + XBOX_LOGO("xbox.logo"), + XSERVE("xserve"), + XSERVE_RAID("xserve.raid"), + YIELDSIGN("yieldsign"), + YIELDSIGN_FILL("yieldsign.fill"), + ZIPPER_PAGE("zipper.page"), + ZL_BUTTON_ROUNDEDTOP_HORIZONTAL("zl.button.roundedtop.horizontal"), + ZL_BUTTON_ROUNDEDTOP_HORIZONTAL_FILL("zl.button.roundedtop.horizontal.fill"), + ZR_BUTTON_ROUNDEDTOP_HORIZONTAL("zr.button.roundedtop.horizontal"), + ZR_BUTTON_ROUNDEDTOP_HORIZONTAL_FILL("zr.button.roundedtop.horizontal.fill"), + ZZZ("zzz"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolHealth.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolHealth.kt new file mode 100644 index 00000000..0f314cd5 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolHealth.kt @@ -0,0 +1,64 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Health (57 symbols). */ +enum class SFSymbolHealth( + override val symbolName: String, +) : SFSymbol { + ALLERGENS("allergens"), + ALLERGENS_FILL("allergens.fill"), + BASEBALL("baseball"), + BASEBALL_CIRCLE("baseball.circle"), + BASEBALL_CIRCLE_FILL("baseball.circle.fill"), + BASEBALL_DIAMOND_BASES("baseball.diamond.bases"), + BASEBALL_DIAMOND_BASES_OUTS_INDICATOR("baseball.diamond.bases.outs.indicator"), + BASEBALL_FILL("baseball.fill"), + BASKETBALL("basketball"), + BASKETBALL_CIRCLE("basketball.circle"), + BASKETBALL_CIRCLE_FILL("basketball.circle.fill"), + BASKETBALL_FILL("basketball.fill"), + CRICKET_BALL("cricket.ball"), + CRICKET_BALL_CIRCLE("cricket.ball.circle"), + CRICKET_BALL_CIRCLE_FILL("cricket.ball.circle.fill"), + CRICKET_BALL_FILL("cricket.ball.fill"), + DUMBBELL("dumbbell"), + DUMBBELL_FILL("dumbbell.fill"), + HOCKEY_PUCK("hockey.puck"), + HOCKEY_PUCK_CIRCLE("hockey.puck.circle"), + HOCKEY_PUCK_CIRCLE_FILL("hockey.puck.circle.fill"), + HOCKEY_PUCK_FILL("hockey.puck.fill"), + MEDICAL_THERMOMETER("medical.thermometer"), + MEDICAL_THERMOMETER_FILL("medical.thermometer.fill"), + RUGBYBALL("rugbyball"), + RUGBYBALL_CIRCLE("rugbyball.circle"), + RUGBYBALL_CIRCLE_FILL("rugbyball.circle.fill"), + RUGBYBALL_FILL("rugbyball.fill"), + SOCCERBALL("soccerball"), + SOCCERBALL_CIRCLE("soccerball.circle"), + SOCCERBALL_CIRCLE_FILL("soccerball.circle.fill"), + SOCCERBALL_CIRCLE_FILL_INVERSE("soccerball.circle.fill.inverse"), + SOCCERBALL_CIRCLE_INVERSE("soccerball.circle.inverse"), + SOCCERBALL_INVERSE("soccerball.inverse"), + SPORTSCOURT("sportscourt"), + SPORTSCOURT_CIRCLE("sportscourt.circle"), + SPORTSCOURT_CIRCLE_FILL("sportscourt.circle.fill"), + SPORTSCOURT_FILL("sportscourt.fill"), + STETHOSCOPE("stethoscope"), + STETHOSCOPE_CIRCLE("stethoscope.circle"), + STETHOSCOPE_CIRCLE_FILL("stethoscope.circle.fill"), + TENNIS_RACKET("tennis.racket"), + TENNIS_RACKET_CIRCLE("tennis.racket.circle"), + TENNIS_RACKET_CIRCLE_FILL("tennis.racket.circle.fill"), + TENNISBALL("tennisball"), + TENNISBALL_CIRCLE("tennisball.circle"), + TENNISBALL_CIRCLE_FILL("tennisball.circle.fill"), + TENNISBALL_FILL("tennisball.fill"), + VOLLEYBALL("volleyball"), + VOLLEYBALL_CIRCLE("volleyball.circle"), + VOLLEYBALL_CIRCLE_FILL("volleyball.circle.fill"), + VOLLEYBALL_FILL("volleyball.fill"), + WATER_WAVES("water.waves"), + WATER_WAVES_AND_ARROW_TRIANGLEHEAD_DOWN("water.waves.and.arrow.trianglehead.down"), + WATER_WAVES_AND_ARROW_TRIANGLEHEAD_DOWN_TRIANGLEBADGE_EXCLAMATIONMARK("water.waves.and.arrow.trianglehead.down.trianglebadge.exclamationmark"), + WATER_WAVES_AND_ARROW_TRIANGLEHEAD_UP("water.waves.and.arrow.trianglehead.up"), + WATER_WAVES_SLASH("water.waves.slash"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolHuman.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolHuman.kt new file mode 100644 index 00000000..4c6ee923 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolHuman.kt @@ -0,0 +1,603 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Human (596 symbols). */ +enum class SFSymbolHuman( + override val symbolName: String, +) : SFSymbol { + ACCESSIBILITY("accessibility"), + ACCESSIBILITY_BADGE_ARROW_UP_RIGHT("accessibility.badge.arrow.up.right"), + ACCESSIBILITY_FILL("accessibility.fill"), + BRAIN("brain"), + BRAIN_FILL("brain.fill"), + BRAIN_FILLED_HEAD_PROFILE("brain.filled.head.profile"), + BRAIN_HEAD_PROFILE("brain.head.profile"), + BRAIN_HEAD_PROFILE_FILL("brain.head.profile.fill"), + EAR("ear"), + EAR_BADGE_CHECKMARK("ear.badge.checkmark"), + EAR_BADGE_WAVEFORM("ear.badge.waveform"), + EAR_FILL("ear.fill"), + EAR_TRIANGLEBADGE_EXCLAMATIONMARK("ear.trianglebadge.exclamationmark"), + EARBUDS("earbuds"), + EARBUDS_CASE("earbuds.case"), + EARBUDS_CASE_FILL("earbuds.case.fill"), + EARPODS("earpods"), + EYE("eye"), + EYE_CIRCLE("eye.circle"), + EYE_CIRCLE_FILL("eye.circle.fill"), + EYE_FILL("eye.fill"), + EYE_SLASH("eye.slash"), + EYE_SLASH_CIRCLE("eye.slash.circle"), + EYE_SLASH_CIRCLE_FILL("eye.slash.circle.fill"), + EYE_SLASH_FILL("eye.slash.fill"), + EYE_SQUARE("eye.square"), + EYE_SQUARE_FILL("eye.square.fill"), + EYE_TRIANGLEBADGE_EXCLAMATIONMARK("eye.trianglebadge.exclamationmark"), + EYE_TRIANGLEBADGE_EXCLAMATIONMARK_FILL("eye.trianglebadge.exclamationmark.fill"), + EYEBROW("eyebrow"), + EYEDROPPER("eyedropper"), + EYEDROPPER_FULL("eyedropper.full"), + EYEDROPPER_HALFFULL("eyedropper.halffull"), + EYEGLASSES("eyeglasses"), + EYEGLASSES_SLASH("eyeglasses.slash"), + EYES("eyes"), + EYES_INVERSE("eyes.inverse"), + FACE_DASHED("face.dashed"), + FACE_DASHED_FILL("face.dashed.fill"), + FACE_SMILING("face.smiling"), + FACE_SMILING_INVERSE("face.smiling.inverse"), + FACEID("faceid"), + FACEMASK("facemask"), + FACEMASK_FILL("facemask.fill"), + FIGURE("figure"), + FIGURE_2("figure.2"), + FIGURE_2_AND_CHILD_HOLDINGHANDS("figure.2.and.child.holdinghands"), + FIGURE_2_ARMS_OPEN("figure.2.arms.open"), + FIGURE_2_CIRCLE("figure.2.circle"), + FIGURE_2_CIRCLE_FILL("figure.2.circle.fill"), + FIGURE_2_LEFT_HOLDINGHANDS("figure.2.left.holdinghands"), + FIGURE_2_RIGHT_HOLDINGHANDS("figure.2.right.holdinghands"), + FIGURE_AMERICAN_FOOTBALL("figure.american.football"), + FIGURE_AMERICAN_FOOTBALL_CIRCLE("figure.american.football.circle"), + FIGURE_AMERICAN_FOOTBALL_CIRCLE_FILL("figure.american.football.circle.fill"), + FIGURE_AND_CHILD_HOLDINGHANDS("figure.and.child.holdinghands"), + FIGURE_ARCHERY("figure.archery"), + FIGURE_ARCHERY_CIRCLE("figure.archery.circle"), + FIGURE_ARCHERY_CIRCLE_FILL("figure.archery.circle.fill"), + FIGURE_ARMS_OPEN("figure.arms.open"), + FIGURE_AUSTRALIAN_FOOTBALL("figure.australian.football"), + FIGURE_AUSTRALIAN_FOOTBALL_CIRCLE("figure.australian.football.circle"), + FIGURE_AUSTRALIAN_FOOTBALL_CIRCLE_FILL("figure.australian.football.circle.fill"), + FIGURE_BADMINTON("figure.badminton"), + FIGURE_BADMINTON_CIRCLE("figure.badminton.circle"), + FIGURE_BADMINTON_CIRCLE_FILL("figure.badminton.circle.fill"), + FIGURE_BARRE("figure.barre"), + FIGURE_BARRE_CIRCLE("figure.barre.circle"), + FIGURE_BARRE_CIRCLE_FILL("figure.barre.circle.fill"), + FIGURE_BASEBALL("figure.baseball"), + FIGURE_BASEBALL_CIRCLE("figure.baseball.circle"), + FIGURE_BASEBALL_CIRCLE_FILL("figure.baseball.circle.fill"), + FIGURE_BASKETBALL("figure.basketball"), + FIGURE_BASKETBALL_CIRCLE("figure.basketball.circle"), + FIGURE_BASKETBALL_CIRCLE_FILL("figure.basketball.circle.fill"), + FIGURE_BOWLING("figure.bowling"), + FIGURE_BOWLING_CIRCLE("figure.bowling.circle"), + FIGURE_BOWLING_CIRCLE_FILL("figure.bowling.circle.fill"), + FIGURE_BOXING("figure.boxing"), + FIGURE_BOXING_CIRCLE("figure.boxing.circle"), + FIGURE_BOXING_CIRCLE_FILL("figure.boxing.circle.fill"), + FIGURE_CHILD("figure.child"), + FIGURE_CHILD_AND_LOCK("figure.child.and.lock"), + FIGURE_CHILD_AND_LOCK_FILL("figure.child.and.lock.fill"), + FIGURE_CHILD_AND_LOCK_OPEN("figure.child.and.lock.open"), + FIGURE_CHILD_AND_LOCK_OPEN_FILL("figure.child.and.lock.open.fill"), + FIGURE_CHILD_CIRCLE("figure.child.circle"), + FIGURE_CHILD_CIRCLE_FILL("figure.child.circle.fill"), + FIGURE_CLIMBING("figure.climbing"), + FIGURE_CLIMBING_CIRCLE("figure.climbing.circle"), + FIGURE_CLIMBING_CIRCLE_FILL("figure.climbing.circle.fill"), + FIGURE_COOLDOWN("figure.cooldown"), + FIGURE_COOLDOWN_CIRCLE("figure.cooldown.circle"), + FIGURE_COOLDOWN_CIRCLE_FILL("figure.cooldown.circle.fill"), + FIGURE_CORE_TRAINING("figure.core.training"), + FIGURE_CORE_TRAINING_CIRCLE("figure.core.training.circle"), + FIGURE_CORE_TRAINING_CIRCLE_FILL("figure.core.training.circle.fill"), + FIGURE_CRICKET("figure.cricket"), + FIGURE_CRICKET_CIRCLE("figure.cricket.circle"), + FIGURE_CRICKET_CIRCLE_FILL("figure.cricket.circle.fill"), + FIGURE_CROSS_TRAINING("figure.cross.training"), + FIGURE_CROSS_TRAINING_CIRCLE("figure.cross.training.circle"), + FIGURE_CROSS_TRAINING_CIRCLE_FILL("figure.cross.training.circle.fill"), + FIGURE_CURLING("figure.curling"), + FIGURE_CURLING_CIRCLE("figure.curling.circle"), + FIGURE_CURLING_CIRCLE_FILL("figure.curling.circle.fill"), + FIGURE_DANCE("figure.dance"), + FIGURE_DANCE_CIRCLE("figure.dance.circle"), + FIGURE_DANCE_CIRCLE_FILL("figure.dance.circle.fill"), + FIGURE_DISC_SPORTS("figure.disc.sports"), + FIGURE_DISC_SPORTS_CIRCLE("figure.disc.sports.circle"), + FIGURE_DISC_SPORTS_CIRCLE_FILL("figure.disc.sports.circle.fill"), + FIGURE_ELLIPTICAL("figure.elliptical"), + FIGURE_ELLIPTICAL_CIRCLE("figure.elliptical.circle"), + FIGURE_ELLIPTICAL_CIRCLE_FILL("figure.elliptical.circle.fill"), + FIGURE_EQUESTRIAN_SPORTS("figure.equestrian.sports"), + FIGURE_EQUESTRIAN_SPORTS_CIRCLE("figure.equestrian.sports.circle"), + FIGURE_EQUESTRIAN_SPORTS_CIRCLE_FILL("figure.equestrian.sports.circle.fill"), + FIGURE_FALL("figure.fall"), + FIGURE_FALL_CIRCLE("figure.fall.circle"), + FIGURE_FALL_CIRCLE_FILL("figure.fall.circle.fill"), + FIGURE_FENCING("figure.fencing"), + FIGURE_FENCING_CIRCLE("figure.fencing.circle"), + FIGURE_FENCING_CIRCLE_FILL("figure.fencing.circle.fill"), + FIGURE_FIELD_HOCKEY("figure.field.hockey"), + FIGURE_FIELD_HOCKEY_CIRCLE("figure.field.hockey.circle"), + FIGURE_FIELD_HOCKEY_CIRCLE_FILL("figure.field.hockey.circle.fill"), + FIGURE_FISHING("figure.fishing"), + FIGURE_FISHING_CIRCLE("figure.fishing.circle"), + FIGURE_FISHING_CIRCLE_FILL("figure.fishing.circle.fill"), + FIGURE_FLEXIBILITY("figure.flexibility"), + FIGURE_FLEXIBILITY_CIRCLE("figure.flexibility.circle"), + FIGURE_FLEXIBILITY_CIRCLE_FILL("figure.flexibility.circle.fill"), + FIGURE_GOLF("figure.golf"), + FIGURE_GOLF_CIRCLE("figure.golf.circle"), + FIGURE_GOLF_CIRCLE_FILL("figure.golf.circle.fill"), + FIGURE_GYMNASTICS("figure.gymnastics"), + FIGURE_GYMNASTICS_CIRCLE("figure.gymnastics.circle"), + FIGURE_GYMNASTICS_CIRCLE_FILL("figure.gymnastics.circle.fill"), + FIGURE_HAND_CYCLING("figure.hand.cycling"), + FIGURE_HAND_CYCLING_CIRCLE("figure.hand.cycling.circle"), + FIGURE_HAND_CYCLING_CIRCLE_FILL("figure.hand.cycling.circle.fill"), + FIGURE_HANDBALL("figure.handball"), + FIGURE_HANDBALL_CIRCLE("figure.handball.circle"), + FIGURE_HANDBALL_CIRCLE_FILL("figure.handball.circle.fill"), + FIGURE_HIGHINTENSITY_INTERVALTRAINING("figure.highintensity.intervaltraining"), + FIGURE_HIGHINTENSITY_INTERVALTRAINING_CIRCLE("figure.highintensity.intervaltraining.circle"), + FIGURE_HIGHINTENSITY_INTERVALTRAINING_CIRCLE_FILL("figure.highintensity.intervaltraining.circle.fill"), + FIGURE_HIKING("figure.hiking"), + FIGURE_HIKING_CIRCLE("figure.hiking.circle"), + FIGURE_HIKING_CIRCLE_FILL("figure.hiking.circle.fill"), + FIGURE_HOCKEY("figure.hockey"), + FIGURE_HOCKEY_CIRCLE("figure.hockey.circle"), + FIGURE_HOCKEY_CIRCLE_FILL("figure.hockey.circle.fill"), + FIGURE_HUNTING("figure.hunting"), + FIGURE_HUNTING_CIRCLE("figure.hunting.circle"), + FIGURE_HUNTING_CIRCLE_FILL("figure.hunting.circle.fill"), + FIGURE_ICE_HOCKEY("figure.ice.hockey"), + FIGURE_ICE_HOCKEY_CIRCLE("figure.ice.hockey.circle"), + FIGURE_ICE_HOCKEY_CIRCLE_FILL("figure.ice.hockey.circle.fill"), + FIGURE_ICE_SKATING("figure.ice.skating"), + FIGURE_ICE_SKATING_CIRCLE("figure.ice.skating.circle"), + FIGURE_ICE_SKATING_CIRCLE_FILL("figure.ice.skating.circle.fill"), + FIGURE_INDOOR_CYCLE("figure.indoor.cycle"), + FIGURE_INDOOR_CYCLE_CIRCLE("figure.indoor.cycle.circle"), + FIGURE_INDOOR_CYCLE_CIRCLE_FILL("figure.indoor.cycle.circle.fill"), + FIGURE_INDOOR_ROWING("figure.indoor.rowing"), + FIGURE_INDOOR_ROWING_CIRCLE("figure.indoor.rowing.circle"), + FIGURE_INDOOR_ROWING_CIRCLE_FILL("figure.indoor.rowing.circle.fill"), + FIGURE_INDOOR_SOCCER("figure.indoor.soccer"), + FIGURE_INDOOR_SOCCER_CIRCLE("figure.indoor.soccer.circle"), + FIGURE_INDOOR_SOCCER_CIRCLE_FILL("figure.indoor.soccer.circle.fill"), + FIGURE_JUMPROPE("figure.jumprope"), + FIGURE_JUMPROPE_CIRCLE("figure.jumprope.circle"), + FIGURE_JUMPROPE_CIRCLE_FILL("figure.jumprope.circle.fill"), + FIGURE_KICKBOXING("figure.kickboxing"), + FIGURE_KICKBOXING_CIRCLE("figure.kickboxing.circle"), + FIGURE_KICKBOXING_CIRCLE_FILL("figure.kickboxing.circle.fill"), + FIGURE_LACROSSE("figure.lacrosse"), + FIGURE_LACROSSE_CIRCLE("figure.lacrosse.circle"), + FIGURE_LACROSSE_CIRCLE_FILL("figure.lacrosse.circle.fill"), + FIGURE_MARTIAL_ARTS("figure.martial.arts"), + FIGURE_MARTIAL_ARTS_CIRCLE("figure.martial.arts.circle"), + FIGURE_MARTIAL_ARTS_CIRCLE_FILL("figure.martial.arts.circle.fill"), + FIGURE_MIND_AND_BODY("figure.mind.and.body"), + FIGURE_MIND_AND_BODY_CIRCLE("figure.mind.and.body.circle"), + FIGURE_MIND_AND_BODY_CIRCLE_FILL("figure.mind.and.body.circle.fill"), + FIGURE_MIXED_CARDIO("figure.mixed.cardio"), + FIGURE_MIXED_CARDIO_CIRCLE("figure.mixed.cardio.circle"), + FIGURE_MIXED_CARDIO_CIRCLE_FILL("figure.mixed.cardio.circle.fill"), + FIGURE_OPEN_WATER_SWIM("figure.open.water.swim"), + FIGURE_OPEN_WATER_SWIM_CIRCLE("figure.open.water.swim.circle"), + FIGURE_OPEN_WATER_SWIM_CIRCLE_FILL("figure.open.water.swim.circle.fill"), + FIGURE_OUTDOOR_CYCLE("figure.outdoor.cycle"), + FIGURE_OUTDOOR_CYCLE_CIRCLE("figure.outdoor.cycle.circle"), + FIGURE_OUTDOOR_CYCLE_CIRCLE_FILL("figure.outdoor.cycle.circle.fill"), + FIGURE_OUTDOOR_ROWING("figure.outdoor.rowing"), + FIGURE_OUTDOOR_ROWING_CIRCLE("figure.outdoor.rowing.circle"), + FIGURE_OUTDOOR_ROWING_CIRCLE_FILL("figure.outdoor.rowing.circle.fill"), + FIGURE_OUTDOOR_SOCCER("figure.outdoor.soccer"), + FIGURE_OUTDOOR_SOCCER_CIRCLE("figure.outdoor.soccer.circle"), + FIGURE_OUTDOOR_SOCCER_CIRCLE_FILL("figure.outdoor.soccer.circle.fill"), + FIGURE_PICKLEBALL("figure.pickleball"), + FIGURE_PICKLEBALL_CIRCLE("figure.pickleball.circle"), + FIGURE_PICKLEBALL_CIRCLE_FILL("figure.pickleball.circle.fill"), + FIGURE_PILATES("figure.pilates"), + FIGURE_PILATES_CIRCLE("figure.pilates.circle"), + FIGURE_PILATES_CIRCLE_FILL("figure.pilates.circle.fill"), + FIGURE_PLAY("figure.play"), + FIGURE_PLAY_CIRCLE("figure.play.circle"), + FIGURE_PLAY_CIRCLE_FILL("figure.play.circle.fill"), + FIGURE_POOL_SWIM("figure.pool.swim"), + FIGURE_POOL_SWIM_CIRCLE("figure.pool.swim.circle"), + FIGURE_POOL_SWIM_CIRCLE_FILL("figure.pool.swim.circle.fill"), + FIGURE_RACQUETBALL("figure.racquetball"), + FIGURE_RACQUETBALL_CIRCLE("figure.racquetball.circle"), + FIGURE_RACQUETBALL_CIRCLE_FILL("figure.racquetball.circle.fill"), + FIGURE_ROLL("figure.roll"), + FIGURE_ROLL_CIRCLE("figure.roll.circle"), + FIGURE_ROLL_CIRCLE_FILL("figure.roll.circle.fill"), + FIGURE_ROLL_RUNNINGPACE("figure.roll.runningpace"), + FIGURE_ROLL_RUNNINGPACE_CIRCLE("figure.roll.runningpace.circle"), + FIGURE_ROLL_RUNNINGPACE_CIRCLE_FILL("figure.roll.runningpace.circle.fill"), + FIGURE_ROLLING("figure.rolling"), + FIGURE_ROLLING_CIRCLE("figure.rolling.circle"), + FIGURE_ROLLING_CIRCLE_FILL("figure.rolling.circle.fill"), + FIGURE_RUGBY("figure.rugby"), + FIGURE_RUGBY_CIRCLE("figure.rugby.circle"), + FIGURE_RUGBY_CIRCLE_FILL("figure.rugby.circle.fill"), + FIGURE_RUN("figure.run"), + FIGURE_RUN_CIRCLE("figure.run.circle"), + FIGURE_RUN_CIRCLE_FILL("figure.run.circle.fill"), + FIGURE_RUN_SQUARE_STACK("figure.run.square.stack"), + FIGURE_RUN_SQUARE_STACK_FILL("figure.run.square.stack.fill"), + FIGURE_RUN_TREADMILL("figure.run.treadmill"), + FIGURE_RUN_TREADMILL_CIRCLE("figure.run.treadmill.circle"), + FIGURE_RUN_TREADMILL_CIRCLE_FILL("figure.run.treadmill.circle.fill"), + FIGURE_SAILING("figure.sailing"), + FIGURE_SAILING_CIRCLE("figure.sailing.circle"), + FIGURE_SAILING_CIRCLE_FILL("figure.sailing.circle.fill"), + FIGURE_SEATED_SEATBELT("figure.seated.seatbelt"), + FIGURE_SEATED_SEATBELT_AND_AIRBAG_OFF("figure.seated.seatbelt.and.airbag.off"), + FIGURE_SEATED_SEATBELT_AND_AIRBAG_ON("figure.seated.seatbelt.and.airbag.on"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_1("figure.seated.seatbelt.left.drive.seats.1"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_1_1("figure.seated.seatbelt.left.drive.seats.1.1"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_1_1_FILL("figure.seated.seatbelt.left.drive.seats.1.1.fill"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_1_2("figure.seated.seatbelt.left.drive.seats.1.2"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_1_2_FILL("figure.seated.seatbelt.left.drive.seats.1.2.fill"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_1_FILL("figure.seated.seatbelt.left.drive.seats.1.fill"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2("figure.seated.seatbelt.left.drive.seats.2"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_2("figure.seated.seatbelt.left.drive.seats.2.2"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_2_2("figure.seated.seatbelt.left.drive.seats.2.2.2"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_2_2_FILL("figure.seated.seatbelt.left.drive.seats.2.2.2.fill"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_2_3("figure.seated.seatbelt.left.drive.seats.2.2.3"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_2_3_FILL("figure.seated.seatbelt.left.drive.seats.2.2.3.fill"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_2_FILL("figure.seated.seatbelt.left.drive.seats.2.2.fill"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_3("figure.seated.seatbelt.left.drive.seats.2.3"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_3_2("figure.seated.seatbelt.left.drive.seats.2.3.2"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_3_2_FILL("figure.seated.seatbelt.left.drive.seats.2.3.2.fill"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_3_3("figure.seated.seatbelt.left.drive.seats.2.3.3"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_3_3_FILL("figure.seated.seatbelt.left.drive.seats.2.3.3.fill"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_3_FILL("figure.seated.seatbelt.left.drive.seats.2.3.fill"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_2_FILL("figure.seated.seatbelt.left.drive.seats.2.fill"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_3("figure.seated.seatbelt.left.drive.seats.3"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_3_3("figure.seated.seatbelt.left.drive.seats.3.3"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_3_3_3("figure.seated.seatbelt.left.drive.seats.3.3.3"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_3_3_3_FILL("figure.seated.seatbelt.left.drive.seats.3.3.3.fill"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_3_3_FILL("figure.seated.seatbelt.left.drive.seats.3.3.fill"), + FIGURE_SEATED_SEATBELT_LEFT_DRIVE_SEATS_3_FILL("figure.seated.seatbelt.left.drive.seats.3.fill"), + FIGURE_SEATED_SIDE_LEFT("figure.seated.side.left"), + FIGURE_SEATED_SIDE_LEFT_AIR_DISTRIBUTION_LOWER("figure.seated.side.left.air.distribution.lower"), + FIGURE_SEATED_SIDE_LEFT_AIR_DISTRIBUTION_MIDDLE("figure.seated.side.left.air.distribution.middle"), + FIGURE_SEATED_SIDE_LEFT_AIR_DISTRIBUTION_MIDDLE_AND_LOWER("figure.seated.side.left.air.distribution.middle.and.lower"), + FIGURE_SEATED_SIDE_LEFT_AIR_DISTRIBUTION_MIDDLE_AND_LOWER_ANGLED("figure.seated.side.left.air.distribution.middle.and.lower.angled"), + FIGURE_SEATED_SIDE_LEFT_AIR_DISTRIBUTION_UPPER("figure.seated.side.left.air.distribution.upper"), + FIGURE_SEATED_SIDE_LEFT_AIR_DISTRIBUTION_UPPER_ANGLED_AND_LOWER_ANGLED("figure.seated.side.left.air.distribution.upper.angled.and.lower.angled"), + FIGURE_SEATED_SIDE_LEFT_AIR_DISTRIBUTION_UPPER_ANGLED_AND_MIDDLE("figure.seated.side.left.air.distribution.upper.angled.and.middle"), + FIGURE_SEATED_SIDE_LEFT_AIR_DISTRIBUTION_UPPER_ANGLED_AND_MIDDLE_AND_LOWER_ANGLED("figure.seated.side.left.air.distribution.upper.angled.and.middle.and.lower.angled"), + FIGURE_SEATED_SIDE_LEFT_AIRBAG_OFF("figure.seated.side.left.airbag.off"), + FIGURE_SEATED_SIDE_LEFT_AIRBAG_OFF_2("figure.seated.side.left.airbag.off.2"), + FIGURE_SEATED_SIDE_LEFT_AIRBAG_ON("figure.seated.side.left.airbag.on"), + FIGURE_SEATED_SIDE_LEFT_AIRBAG_ON_2("figure.seated.side.left.airbag.on.2"), + FIGURE_SEATED_SIDE_LEFT_AUTOMATIC("figure.seated.side.left.automatic"), + FIGURE_SEATED_SIDE_LEFT_FAN("figure.seated.side.left.fan"), + FIGURE_SEATED_SIDE_LEFT_STEERINGWHEEL("figure.seated.side.left.steeringwheel"), + FIGURE_SEATED_SIDE_LEFT_WINDSHIELD_FRONT_AND_HEAT_WAVES("figure.seated.side.left.windshield.front.and.heat.waves"), + FIGURE_SEATED_SIDE_LEFT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_LOWER("figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.lower"), + FIGURE_SEATED_SIDE_LEFT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_MIDDLE("figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.middle"), + FIGURE_SEATED_SIDE_LEFT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_MIDDLE_AND_LOWER("figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.middle.and.lower"), + FIGURE_SEATED_SIDE_LEFT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_UPPER("figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.upper"), + FIGURE_SEATED_SIDE_LEFT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_UPPER_AND_LOWER("figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.upper.and.lower"), + FIGURE_SEATED_SIDE_LEFT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_UPPER_AND_MIDDLE("figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.upper.and.middle"), + FIGURE_SEATED_SIDE_LEFT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_UPPER_AND_MIDDLE_AND_LOWER("figure.seated.side.left.windshield.front.and.heat.waves.air.distribution.upper.and.middle.and.lower"), + FIGURE_SEATED_SIDE_RIGHT("figure.seated.side.right"), + FIGURE_SEATED_SIDE_RIGHT_AIR_DISTRIBUTION_LOWER("figure.seated.side.right.air.distribution.lower"), + FIGURE_SEATED_SIDE_RIGHT_AIR_DISTRIBUTION_MIDDLE("figure.seated.side.right.air.distribution.middle"), + FIGURE_SEATED_SIDE_RIGHT_AIR_DISTRIBUTION_MIDDLE_AND_LOWER("figure.seated.side.right.air.distribution.middle.and.lower"), + FIGURE_SEATED_SIDE_RIGHT_AIR_DISTRIBUTION_MIDDLE_AND_LOWER_ANGLED("figure.seated.side.right.air.distribution.middle.and.lower.angled"), + FIGURE_SEATED_SIDE_RIGHT_AIR_DISTRIBUTION_UPPER("figure.seated.side.right.air.distribution.upper"), + FIGURE_SEATED_SIDE_RIGHT_AIR_DISTRIBUTION_UPPER_ANGLED_AND_LOWER_ANGLED("figure.seated.side.right.air.distribution.upper.angled.and.lower.angled"), + FIGURE_SEATED_SIDE_RIGHT_AIR_DISTRIBUTION_UPPER_ANGLED_AND_MIDDLE("figure.seated.side.right.air.distribution.upper.angled.and.middle"), + FIGURE_SEATED_SIDE_RIGHT_AIR_DISTRIBUTION_UPPER_ANGLED_AND_MIDDLE_AND_LOWER_ANGLED("figure.seated.side.right.air.distribution.upper.angled.and.middle.and.lower.angled"), + FIGURE_SEATED_SIDE_RIGHT_AIRBAG_OFF("figure.seated.side.right.airbag.off"), + FIGURE_SEATED_SIDE_RIGHT_AIRBAG_OFF_2("figure.seated.side.right.airbag.off.2"), + FIGURE_SEATED_SIDE_RIGHT_AIRBAG_ON("figure.seated.side.right.airbag.on"), + FIGURE_SEATED_SIDE_RIGHT_AIRBAG_ON_2("figure.seated.side.right.airbag.on.2"), + FIGURE_SEATED_SIDE_RIGHT_AUTOMATIC("figure.seated.side.right.automatic"), + FIGURE_SEATED_SIDE_RIGHT_FAN("figure.seated.side.right.fan"), + FIGURE_SEATED_SIDE_RIGHT_STEERINGWHEEL("figure.seated.side.right.steeringwheel"), + FIGURE_SEATED_SIDE_RIGHT_WINDSHIELD_FRONT_AND_HEAT_WAVES("figure.seated.side.right.windshield.front.and.heat.waves"), + FIGURE_SEATED_SIDE_RIGHT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_LOWER("figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.lower"), + FIGURE_SEATED_SIDE_RIGHT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_MIDDLE("figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.middle"), + FIGURE_SEATED_SIDE_RIGHT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_MIDDLE_AND_LOWER("figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.middle.and.lower"), + FIGURE_SEATED_SIDE_RIGHT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_UPPER("figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.upper"), + FIGURE_SEATED_SIDE_RIGHT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_UPPER_AND_LOWER("figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.upper.and.lower"), + FIGURE_SEATED_SIDE_RIGHT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_UPPER_AND_MIDDLE("figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.upper.and.middle"), + FIGURE_SEATED_SIDE_RIGHT_WINDSHIELD_FRONT_AND_HEAT_WAVES_AIR_DISTRIBUTION_UPPER_AND_MIDDLE_AND_LOWER("figure.seated.side.right.windshield.front.and.heat.waves.air.distribution.upper.and.middle.and.lower"), + FIGURE_SKATEBOARDING("figure.skateboarding"), + FIGURE_SKATEBOARDING_CIRCLE("figure.skateboarding.circle"), + FIGURE_SKATEBOARDING_CIRCLE_FILL("figure.skateboarding.circle.fill"), + FIGURE_SKIING_CROSSCOUNTRY("figure.skiing.crosscountry"), + FIGURE_SKIING_CROSSCOUNTRY_CIRCLE("figure.skiing.crosscountry.circle"), + FIGURE_SKIING_CROSSCOUNTRY_CIRCLE_FILL("figure.skiing.crosscountry.circle.fill"), + FIGURE_SKIING_DOWNHILL("figure.skiing.downhill"), + FIGURE_SKIING_DOWNHILL_CIRCLE("figure.skiing.downhill.circle"), + FIGURE_SKIING_DOWNHILL_CIRCLE_FILL("figure.skiing.downhill.circle.fill"), + FIGURE_SNOWBOARDING("figure.snowboarding"), + FIGURE_SNOWBOARDING_CIRCLE("figure.snowboarding.circle"), + FIGURE_SNOWBOARDING_CIRCLE_FILL("figure.snowboarding.circle.fill"), + FIGURE_SOCIALDANCE("figure.socialdance"), + FIGURE_SOCIALDANCE_CIRCLE("figure.socialdance.circle"), + FIGURE_SOCIALDANCE_CIRCLE_FILL("figure.socialdance.circle.fill"), + FIGURE_SOFTBALL("figure.softball"), + FIGURE_SOFTBALL_CIRCLE("figure.softball.circle"), + FIGURE_SOFTBALL_CIRCLE_FILL("figure.softball.circle.fill"), + FIGURE_SQUASH("figure.squash"), + FIGURE_SQUASH_CIRCLE("figure.squash.circle"), + FIGURE_SQUASH_CIRCLE_FILL("figure.squash.circle.fill"), + FIGURE_STAIR_STEPPER("figure.stair.stepper"), + FIGURE_STAIR_STEPPER_CIRCLE("figure.stair.stepper.circle"), + FIGURE_STAIR_STEPPER_CIRCLE_FILL("figure.stair.stepper.circle.fill"), + FIGURE_STAIRS("figure.stairs"), + FIGURE_STAIRS_CIRCLE("figure.stairs.circle"), + FIGURE_STAIRS_CIRCLE_FILL("figure.stairs.circle.fill"), + FIGURE_STAND("figure.stand"), + FIGURE_STAND_DRESS("figure.stand.dress"), + FIGURE_STAND_DRESS_LINE_VERTICAL_FIGURE("figure.stand.dress.line.vertical.figure"), + FIGURE_STAND_LINE_DOTTED_FIGURE_STAND("figure.stand.line.dotted.figure.stand"), + FIGURE_STEP_TRAINING("figure.step.training"), + FIGURE_STEP_TRAINING_CIRCLE("figure.step.training.circle"), + FIGURE_STEP_TRAINING_CIRCLE_FILL("figure.step.training.circle.fill"), + FIGURE_STRENGTHTRAINING_FUNCTIONAL("figure.strengthtraining.functional"), + FIGURE_STRENGTHTRAINING_FUNCTIONAL_CIRCLE("figure.strengthtraining.functional.circle"), + FIGURE_STRENGTHTRAINING_FUNCTIONAL_CIRCLE_FILL("figure.strengthtraining.functional.circle.fill"), + FIGURE_STRENGTHTRAINING_TRADITIONAL("figure.strengthtraining.traditional"), + FIGURE_STRENGTHTRAINING_TRADITIONAL_CIRCLE("figure.strengthtraining.traditional.circle"), + FIGURE_STRENGTHTRAINING_TRADITIONAL_CIRCLE_FILL("figure.strengthtraining.traditional.circle.fill"), + FIGURE_SURFING("figure.surfing"), + FIGURE_SURFING_CIRCLE("figure.surfing.circle"), + FIGURE_SURFING_CIRCLE_FILL("figure.surfing.circle.fill"), + FIGURE_TABLE_TENNIS("figure.table.tennis"), + FIGURE_TABLE_TENNIS_CIRCLE("figure.table.tennis.circle"), + FIGURE_TABLE_TENNIS_CIRCLE_FILL("figure.table.tennis.circle.fill"), + FIGURE_TAICHI("figure.taichi"), + FIGURE_TAICHI_CIRCLE("figure.taichi.circle"), + FIGURE_TAICHI_CIRCLE_FILL("figure.taichi.circle.fill"), + FIGURE_TENNIS("figure.tennis"), + FIGURE_TENNIS_CIRCLE("figure.tennis.circle"), + FIGURE_TENNIS_CIRCLE_FILL("figure.tennis.circle.fill"), + FIGURE_TRACK_AND_FIELD("figure.track.and.field"), + FIGURE_TRACK_AND_FIELD_CIRCLE("figure.track.and.field.circle"), + FIGURE_TRACK_AND_FIELD_CIRCLE_FILL("figure.track.and.field.circle.fill"), + FIGURE_VOLLEYBALL("figure.volleyball"), + FIGURE_VOLLEYBALL_CIRCLE("figure.volleyball.circle"), + FIGURE_VOLLEYBALL_CIRCLE_FILL("figure.volleyball.circle.fill"), + FIGURE_WALK("figure.walk"), + FIGURE_WALK_ARRIVAL("figure.walk.arrival"), + FIGURE_WALK_CIRCLE("figure.walk.circle"), + FIGURE_WALK_CIRCLE_FILL("figure.walk.circle.fill"), + FIGURE_WALK_DEPARTURE("figure.walk.departure"), + FIGURE_WALK_DIAMOND("figure.walk.diamond"), + FIGURE_WALK_DIAMOND_FILL("figure.walk.diamond.fill"), + FIGURE_WALK_MOTION("figure.walk.motion"), + FIGURE_WALK_MOTION_TRIANGLEBADGE_EXCLAMATIONMARK("figure.walk.motion.trianglebadge.exclamationmark"), + FIGURE_WALK_TREADMILL("figure.walk.treadmill"), + FIGURE_WALK_TREADMILL_CIRCLE("figure.walk.treadmill.circle"), + FIGURE_WALK_TREADMILL_CIRCLE_FILL("figure.walk.treadmill.circle.fill"), + FIGURE_WALK_TRIANGLE("figure.walk.triangle"), + FIGURE_WALK_TRIANGLE_FILL("figure.walk.triangle.fill"), + FIGURE_WATER_FITNESS("figure.water.fitness"), + FIGURE_WATER_FITNESS_CIRCLE("figure.water.fitness.circle"), + FIGURE_WATER_FITNESS_CIRCLE_FILL("figure.water.fitness.circle.fill"), + FIGURE_WATERPOLO("figure.waterpolo"), + FIGURE_WATERPOLO_CIRCLE("figure.waterpolo.circle"), + FIGURE_WATERPOLO_CIRCLE_FILL("figure.waterpolo.circle.fill"), + FIGURE_WAVE("figure.wave"), + FIGURE_WAVE_CIRCLE("figure.wave.circle"), + FIGURE_WAVE_CIRCLE_FILL("figure.wave.circle.fill"), + FIGURE_WRESTLING("figure.wrestling"), + FIGURE_WRESTLING_CIRCLE("figure.wrestling.circle"), + FIGURE_WRESTLING_CIRCLE_FILL("figure.wrestling.circle.fill"), + FIGURE_YOGA("figure.yoga"), + FIGURE_YOGA_CIRCLE("figure.yoga.circle"), + FIGURE_YOGA_CIRCLE_FILL("figure.yoga.circle.fill"), + HAND_DRAW("hand.draw"), + HAND_DRAW_BADGE_ELLIPSIS("hand.draw.badge.ellipsis"), + HAND_DRAW_BADGE_ELLIPSIS_FILL("hand.draw.badge.ellipsis.fill"), + HAND_DRAW_FILL("hand.draw.fill"), + HAND_PALM_FACING("hand.palm.facing"), + HAND_PALM_FACING_FILL("hand.palm.facing.fill"), + HAND_PINCH("hand.pinch"), + HAND_PINCH_FILL("hand.pinch.fill"), + HAND_POINT_DOWN("hand.point.down"), + HAND_POINT_DOWN_FILL("hand.point.down.fill"), + HAND_POINT_LEFT("hand.point.left"), + HAND_POINT_LEFT_FILL("hand.point.left.fill"), + HAND_POINT_RIGHT("hand.point.right"), + HAND_POINT_RIGHT_FILL("hand.point.right.fill"), + HAND_POINT_UP("hand.point.up"), + HAND_POINT_UP_BRAILLE("hand.point.up.braille"), + HAND_POINT_UP_BRAILLE_BADGE_ELLIPSIS("hand.point.up.braille.badge.ellipsis"), + HAND_POINT_UP_BRAILLE_BADGE_ELLIPSIS_FILL("hand.point.up.braille.badge.ellipsis.fill"), + HAND_POINT_UP_BRAILLE_FILL("hand.point.up.braille.fill"), + HAND_POINT_UP_FILL("hand.point.up.fill"), + HAND_POINT_UP_LEFT("hand.point.up.left"), + HAND_POINT_UP_LEFT_AND_TEXT("hand.point.up.left.and.text"), + HAND_POINT_UP_LEFT_AND_TEXT_FILL("hand.point.up.left.and.text.fill"), + HAND_POINT_UP_LEFT_FILL("hand.point.up.left.fill"), + HAND_RAISED("hand.raised"), + HAND_RAISED_APP("hand.raised.app"), + HAND_RAISED_APP_FILL("hand.raised.app.fill"), + HAND_RAISED_BRAKESIGNAL("hand.raised.brakesignal"), + HAND_RAISED_BRAKESIGNAL_SLASH("hand.raised.brakesignal.slash"), + HAND_RAISED_CIRCLE("hand.raised.circle"), + HAND_RAISED_CIRCLE_FILL("hand.raised.circle.fill"), + HAND_RAISED_FILL("hand.raised.fill"), + HAND_RAISED_FINGERS_SPREAD("hand.raised.fingers.spread"), + HAND_RAISED_FINGERS_SPREAD_FILL("hand.raised.fingers.spread.fill"), + HAND_RAISED_PALM_FACING("hand.raised.palm.facing"), + HAND_RAISED_PALM_FACING_FILL("hand.raised.palm.facing.fill"), + HAND_RAISED_SLASH("hand.raised.slash"), + HAND_RAISED_SLASH_FILL("hand.raised.slash.fill"), + HAND_RAISED_SQUARE("hand.raised.square"), + HAND_RAISED_SQUARE_FILL("hand.raised.square.fill"), + HAND_RAISED_SQUARE_ON_SQUARE("hand.raised.square.on.square"), + HAND_RAISED_SQUARE_ON_SQUARE_FILL("hand.raised.square.on.square.fill"), + HAND_TAP("hand.tap"), + HAND_TAP_FILL("hand.tap.fill"), + HAND_THUMBSDOWN("hand.thumbsdown"), + HAND_THUMBSDOWN_CIRCLE("hand.thumbsdown.circle"), + HAND_THUMBSDOWN_CIRCLE_FILL("hand.thumbsdown.circle.fill"), + HAND_THUMBSDOWN_FILL("hand.thumbsdown.fill"), + HAND_THUMBSUP("hand.thumbsup"), + HAND_THUMBSUP_CIRCLE("hand.thumbsup.circle"), + HAND_THUMBSUP_CIRCLE_FILL("hand.thumbsup.circle.fill"), + HAND_THUMBSUP_FILL("hand.thumbsup.fill"), + HAND_WAVE("hand.wave"), + HAND_WAVE_FILL("hand.wave.fill"), + HANDBAG("handbag"), + HANDBAG_CIRCLE("handbag.circle"), + HANDBAG_CIRCLE_FILL("handbag.circle.fill"), + HANDBAG_FILL("handbag.fill"), + HANDS_AND_SPARKLES("hands.and.sparkles"), + HANDS_AND_SPARKLES_FILL("hands.and.sparkles.fill"), + HANDS_CLAP("hands.clap"), + HANDS_CLAP_FILL("hands.clap.fill"), + HEART("heart"), + HEART_CIRCLE("heart.circle"), + HEART_CIRCLE_FILL("heart.circle.fill"), + HEART_FILL("heart.fill"), + HEART_RECTANGLE("heart.rectangle"), + HEART_RECTANGLE_FILL("heart.rectangle.fill"), + HEART_SLASH("heart.slash"), + HEART_SLASH_CIRCLE("heart.slash.circle"), + HEART_SLASH_CIRCLE_FILL("heart.slash.circle.fill"), + HEART_SLASH_FILL("heart.slash.fill"), + HEART_SQUARE("heart.square"), + HEART_SQUARE_FILL("heart.square.fill"), + HEART_TEXT_CLIPBOARD("heart.text.clipboard"), + HEART_TEXT_CLIPBOARD_FILL("heart.text.clipboard.fill"), + HEART_TEXT_SQUARE("heart.text.square"), + HEART_TEXT_SQUARE_FILL("heart.text.square.fill"), + LUNGS("lungs"), + LUNGS_FILL("lungs.fill"), + MOUTH("mouth"), + MOUTH_FILL("mouth.fill"), + NOSE("nose"), + NOSE_FILL("nose.fill"), + PERSON("person"), + PERSON_2("person.2"), + PERSON_2_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("person.2.arrow.trianglehead.counterclockwise"), + PERSON_2_BADGE_GEARSHAPE("person.2.badge.gearshape"), + PERSON_2_BADGE_GEARSHAPE_FILL("person.2.badge.gearshape.fill"), + PERSON_2_BADGE_KEY("person.2.badge.key"), + PERSON_2_BADGE_KEY_FILL("person.2.badge.key.fill"), + PERSON_2_BADGE_MINUS("person.2.badge.minus"), + PERSON_2_BADGE_MINUS_FILL("person.2.badge.minus.fill"), + PERSON_2_BADGE_PLUS("person.2.badge.plus"), + PERSON_2_BADGE_PLUS_FILL("person.2.badge.plus.fill"), + PERSON_2_CIRCLE("person.2.circle"), + PERSON_2_CIRCLE_FILL("person.2.circle.fill"), + PERSON_2_CROP_SQUARE_STACK("person.2.crop.square.stack"), + PERSON_2_CROP_SQUARE_STACK_FILL("person.2.crop.square.stack.fill"), + PERSON_2_FILL("person.2.fill"), + PERSON_2_SLASH("person.2.slash"), + PERSON_2_SLASH_FILL("person.2.slash.fill"), + PERSON_2_WAVE_2("person.2.wave.2"), + PERSON_2_WAVE_2_FILL("person.2.wave.2.fill"), + PERSON_3("person.3"), + PERSON_3_FILL("person.3.fill"), + PERSON_3_SEQUENCE("person.3.sequence"), + PERSON_3_SEQUENCE_FILL("person.3.sequence.fill"), + PERSON_AND_ARROW_LEFT_AND_ARROW_RIGHT_OUTWARD("person.and.arrow.left.and.arrow.right.outward"), + PERSON_AND_BACKGROUND_DOTTED("person.and.background.dotted"), + PERSON_AND_BACKGROUND_STRIPED_HORIZONTAL("person.and.background.striped.horizontal"), + PERSON_BADGE_CLOCK("person.badge.clock"), + PERSON_BADGE_CLOCK_FILL("person.badge.clock.fill"), + PERSON_BADGE_KEY("person.badge.key"), + PERSON_BADGE_KEY_FILL("person.badge.key.fill"), + PERSON_BADGE_MINUS("person.badge.minus"), + PERSON_BADGE_PLUS("person.badge.plus"), + PERSON_BADGE_SHIELD_CHECKMARK("person.badge.shield.checkmark"), + PERSON_BADGE_SHIELD_CHECKMARK_FILL("person.badge.shield.checkmark.fill"), + PERSON_BADGE_SHIELD_EXCLAMATIONMARK("person.badge.shield.exclamationmark"), + PERSON_BADGE_SHIELD_EXCLAMATIONMARK_FILL("person.badge.shield.exclamationmark.fill"), + PERSON_BUBBLE("person.bubble"), + PERSON_BUBBLE_FILL("person.bubble.fill"), + PERSON_BUST("person.bust"), + PERSON_BUST_CIRCLE("person.bust.circle"), + PERSON_BUST_CIRCLE_FILL("person.bust.circle.fill"), + PERSON_BUST_FILL("person.bust.fill"), + PERSON_CIRCLE("person.circle"), + PERSON_CIRCLE_FILL("person.circle.fill"), + PERSON_CROP_ARTFRAME("person.crop.artframe"), + PERSON_CROP_BADGE_MAGNIFYINGGLASS("person.crop.badge.magnifyingglass"), + PERSON_CROP_BADGE_MAGNIFYINGGLASS_FILL("person.crop.badge.magnifyingglass.fill"), + PERSON_CROP_CIRCLE("person.crop.circle"), + PERSON_CROP_CIRCLE_BADGE("person.crop.circle.badge"), + PERSON_CROP_CIRCLE_BADGE_CHECKMARK("person.crop.circle.badge.checkmark"), + PERSON_CROP_CIRCLE_BADGE_CLOCK("person.crop.circle.badge.clock"), + PERSON_CROP_CIRCLE_BADGE_CLOCK_FILL("person.crop.circle.badge.clock.fill"), + PERSON_CROP_CIRCLE_BADGE_EXCLAMATIONMARK("person.crop.circle.badge.exclamationmark"), + PERSON_CROP_CIRCLE_BADGE_EXCLAMATIONMARK_FILL("person.crop.circle.badge.exclamationmark.fill"), + PERSON_CROP_CIRCLE_BADGE_FILL("person.crop.circle.badge.fill"), + PERSON_CROP_CIRCLE_BADGE_MINUS("person.crop.circle.badge.minus"), + PERSON_CROP_CIRCLE_BADGE_MOON("person.crop.circle.badge.moon"), + PERSON_CROP_CIRCLE_BADGE_MOON_FILL("person.crop.circle.badge.moon.fill"), + PERSON_CROP_CIRCLE_BADGE_PLUS("person.crop.circle.badge.plus"), + PERSON_CROP_CIRCLE_BADGE_QUESTIONMARK("person.crop.circle.badge.questionmark"), + PERSON_CROP_CIRCLE_BADGE_QUESTIONMARK_FILL("person.crop.circle.badge.questionmark.fill"), + PERSON_CROP_CIRCLE_BADGE_XMARK("person.crop.circle.badge.xmark"), + PERSON_CROP_CIRCLE_DASHED("person.crop.circle.dashed"), + PERSON_CROP_CIRCLE_DASHED_CIRCLE("person.crop.circle.dashed.circle"), + PERSON_CROP_CIRCLE_DASHED_CIRCLE_FILL("person.crop.circle.dashed.circle.fill"), + PERSON_CROP_CIRCLE_FILL("person.crop.circle.fill"), + PERSON_CROP_CIRCLE_FILL_BADGE_CHECKMARK("person.crop.circle.fill.badge.checkmark"), + PERSON_CROP_CIRCLE_FILL_BADGE_MINUS("person.crop.circle.fill.badge.minus"), + PERSON_CROP_CIRCLE_FILL_BADGE_PLUS("person.crop.circle.fill.badge.plus"), + PERSON_CROP_CIRCLE_FILL_BADGE_XMARK("person.crop.circle.fill.badge.xmark"), + PERSON_CROP_RECTANGLE("person.crop.rectangle"), + PERSON_CROP_RECTANGLE_BADGE_PLUS("person.crop.rectangle.badge.plus"), + PERSON_CROP_RECTANGLE_BADGE_PLUS_FILL("person.crop.rectangle.badge.plus.fill"), + PERSON_CROP_RECTANGLE_FILL("person.crop.rectangle.fill"), + PERSON_CROP_RECTANGLE_STACK("person.crop.rectangle.stack"), + PERSON_CROP_RECTANGLE_STACK_FILL("person.crop.rectangle.stack.fill"), + PERSON_CROP_SQUARE("person.crop.square"), + PERSON_CROP_SQUARE_BADGE_CAMERA("person.crop.square.badge.camera"), + PERSON_CROP_SQUARE_BADGE_CAMERA_FILL("person.crop.square.badge.camera.fill"), + PERSON_CROP_SQUARE_BADGE_VIDEO("person.crop.square.badge.video"), + PERSON_CROP_SQUARE_BADGE_VIDEO_FILL("person.crop.square.badge.video.fill"), + PERSON_CROP_SQUARE_FILL("person.crop.square.fill"), + PERSON_CROP_SQUARE_FILLED_AND_AT_RECTANGLE("person.crop.square.filled.and.at.rectangle"), + PERSON_CROP_SQUARE_FILLED_AND_AT_RECTANGLE_FILL("person.crop.square.filled.and.at.rectangle.fill"), + PERSON_CROP_SQUARE_ON_SQUARE_ANGLED("person.crop.square.on.square.angled"), + PERSON_CROP_SQUARE_ON_SQUARE_ANGLED_FILL("person.crop.square.on.square.angled.fill"), + PERSON_FILL("person.fill"), + PERSON_FILL_AND_ARROW_LEFT_AND_ARROW_RIGHT_OUTWARD("person.fill.and.arrow.left.and.arrow.right.outward"), + PERSON_FILL_BADGE_MINUS("person.fill.badge.minus"), + PERSON_FILL_BADGE_PLUS("person.fill.badge.plus"), + PERSON_FILL_CHECKMARK("person.fill.checkmark"), + PERSON_FILL_QUESTIONMARK("person.fill.questionmark"), + PERSON_FILL_TURN_DOWN("person.fill.turn.down"), + PERSON_FILL_TURN_LEFT("person.fill.turn.left"), + PERSON_FILL_TURN_RIGHT("person.fill.turn.right"), + PERSON_FILL_VIEWFINDER("person.fill.viewfinder"), + PERSON_FILL_XMARK("person.fill.xmark"), + PERSON_ICLOUD("person.icloud"), + PERSON_ICLOUD_FILL("person.icloud.fill"), + PERSON_LINE_DOTTED_PERSON("person.line.dotted.person"), + PERSON_LINE_DOTTED_PERSON_FILL("person.line.dotted.person.fill"), + PERSON_SLASH("person.slash"), + PERSON_SLASH_FILL("person.slash.fill"), + PERSON_TEXT_RECTANGLE("person.text.rectangle"), + PERSON_TEXT_RECTANGLE_FILL("person.text.rectangle.fill"), + PERSON_WAVE_2("person.wave.2"), + PERSON_WAVE_2_FILL("person.wave.2.fill"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolLetters.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolLetters.kt new file mode 100644 index 00000000..02c026e8 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolLetters.kt @@ -0,0 +1,149 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Letters (142 symbols). */ +enum class SFSymbolLetters( + override val symbolName: String, +) : SFSymbol { + A_CIRCLE("a.circle"), + A_CIRCLE_FILL("a.circle.fill"), + A_SQUARE("a.square"), + A_SQUARE_FILL("a.square.fill"), + B_CIRCLE("b.circle"), + B_CIRCLE_FILL("b.circle.fill"), + B_SQUARE("b.square"), + B_SQUARE_FILL("b.square.fill"), + C_CIRCLE("c.circle"), + C_CIRCLE_FILL("c.circle.fill"), + C_SQUARE("c.square"), + C_SQUARE_FILL("c.square.fill"), + D_CIRCLE("d.circle"), + D_CIRCLE_FILL("d.circle.fill"), + D_SQUARE("d.square"), + D_SQUARE_FILL("d.square.fill"), + E_CIRCLE("e.circle"), + E_CIRCLE_FILL("e.circle.fill"), + E_SQUARE("e.square"), + E_SQUARE_FILL("e.square.fill"), + F_CIRCLE("f.circle"), + F_CIRCLE_FILL("f.circle.fill"), + F_CURSIVE("f.cursive"), + F_CURSIVE_CIRCLE("f.cursive.circle"), + F_CURSIVE_CIRCLE_FILL("f.cursive.circle.fill"), + F_SQUARE("f.square"), + F_SQUARE_FILL("f.square.fill"), + G_CIRCLE("g.circle"), + G_CIRCLE_FILL("g.circle.fill"), + G_SQUARE("g.square"), + G_SQUARE_FILL("g.square.fill"), + H_CIRCLE("h.circle"), + H_CIRCLE_FILL("h.circle.fill"), + H_SQUARE("h.square"), + H_SQUARE_FILL("h.square.fill"), + H_SQUARE_ON_SQUARE("h.square.on.square"), + H_SQUARE_ON_SQUARE_FILL("h.square.on.square.fill"), + I_CIRCLE("i.circle"), + I_CIRCLE_FILL("i.circle.fill"), + I_SQUARE("i.square"), + I_SQUARE_FILL("i.square.fill"), + J_CIRCLE("j.circle"), + J_CIRCLE_FILL("j.circle.fill"), + J_SQUARE("j.square"), + J_SQUARE_FILL("j.square.fill"), + J_SQUARE_ON_SQUARE("j.square.on.square"), + J_SQUARE_ON_SQUARE_FILL("j.square.on.square.fill"), + K_CIRCLE("k.circle"), + K_CIRCLE_FILL("k.circle.fill"), + K_SQUARE("k.square"), + K_SQUARE_FILL("k.square.fill"), + L_BUTTON_ROUNDEDBOTTOM_HORIZONTAL("l.button.roundedbottom.horizontal"), + L_BUTTON_ROUNDEDBOTTOM_HORIZONTAL_FILL("l.button.roundedbottom.horizontal.fill"), + L_CIRCLE("l.circle"), + L_CIRCLE_FILL("l.circle.fill"), + L_JOYSTICK("l.joystick"), + L_JOYSTICK_FILL("l.joystick.fill"), + L_JOYSTICK_PRESS_DOWN("l.joystick.press.down"), + L_JOYSTICK_PRESS_DOWN_FILL("l.joystick.press.down.fill"), + L_JOYSTICK_TILT_DOWN("l.joystick.tilt.down"), + L_JOYSTICK_TILT_DOWN_FILL("l.joystick.tilt.down.fill"), + L_JOYSTICK_TILT_LEFT("l.joystick.tilt.left"), + L_JOYSTICK_TILT_LEFT_FILL("l.joystick.tilt.left.fill"), + L_JOYSTICK_TILT_RIGHT("l.joystick.tilt.right"), + L_JOYSTICK_TILT_RIGHT_FILL("l.joystick.tilt.right.fill"), + L_JOYSTICK_TILT_UP("l.joystick.tilt.up"), + L_JOYSTICK_TILT_UP_FILL("l.joystick.tilt.up.fill"), + L_SQUARE("l.square"), + L_SQUARE_FILL("l.square.fill"), + M_CIRCLE("m.circle"), + M_CIRCLE_FILL("m.circle.fill"), + M_SQUARE("m.square"), + M_SQUARE_FILL("m.square.fill"), + N_CIRCLE("n.circle"), + N_CIRCLE_FILL("n.circle.fill"), + N_SQUARE("n.square"), + N_SQUARE_FILL("n.square.fill"), + O_CIRCLE("o.circle"), + O_CIRCLE_FILL("o.circle.fill"), + O_SQUARE("o.square"), + O_SQUARE_FILL("o.square.fill"), + P_CIRCLE("p.circle"), + P_CIRCLE_FILL("p.circle.fill"), + P_SQUARE("p.square"), + P_SQUARE_FILL("p.square.fill"), + Q_CIRCLE("q.circle"), + Q_CIRCLE_FILL("q.circle.fill"), + Q_SQUARE("q.square"), + Q_SQUARE_FILL("q.square.fill"), + R_BUTTON_ROUNDEDBOTTOM_HORIZONTAL("r.button.roundedbottom.horizontal"), + R_BUTTON_ROUNDEDBOTTOM_HORIZONTAL_FILL("r.button.roundedbottom.horizontal.fill"), + R_CIRCLE("r.circle"), + R_CIRCLE_FILL("r.circle.fill"), + R_JOYSTICK("r.joystick"), + R_JOYSTICK_FILL("r.joystick.fill"), + R_JOYSTICK_PRESS_DOWN("r.joystick.press.down"), + R_JOYSTICK_PRESS_DOWN_FILL("r.joystick.press.down.fill"), + R_JOYSTICK_TILT_DOWN("r.joystick.tilt.down"), + R_JOYSTICK_TILT_DOWN_FILL("r.joystick.tilt.down.fill"), + R_JOYSTICK_TILT_LEFT("r.joystick.tilt.left"), + R_JOYSTICK_TILT_LEFT_FILL("r.joystick.tilt.left.fill"), + R_JOYSTICK_TILT_RIGHT("r.joystick.tilt.right"), + R_JOYSTICK_TILT_RIGHT_FILL("r.joystick.tilt.right.fill"), + R_JOYSTICK_TILT_UP("r.joystick.tilt.up"), + R_JOYSTICK_TILT_UP_FILL("r.joystick.tilt.up.fill"), + R_SQUARE("r.square"), + R_SQUARE_FILL("r.square.fill"), + R_SQUARE_ON_SQUARE("r.square.on.square"), + R_SQUARE_ON_SQUARE_FILL("r.square.on.square.fill"), + S_CIRCLE("s.circle"), + S_CIRCLE_FILL("s.circle.fill"), + S_SQUARE("s.square"), + S_SQUARE_FILL("s.square.fill"), + T_CIRCLE("t.circle"), + T_CIRCLE_FILL("t.circle.fill"), + T_SQUARE("t.square"), + T_SQUARE_FILL("t.square.fill"), + U_CIRCLE("u.circle"), + U_CIRCLE_FILL("u.circle.fill"), + U_SQUARE("u.square"), + U_SQUARE_FILL("u.square.fill"), + V_CIRCLE("v.circle"), + V_CIRCLE_FILL("v.circle.fill"), + V_SQUARE("v.square"), + V_SQUARE_FILL("v.square.fill"), + W_CIRCLE("w.circle"), + W_CIRCLE_FILL("w.circle.fill"), + W_SQUARE("w.square"), + W_SQUARE_FILL("w.square.fill"), + X_CIRCLE("x.circle"), + X_CIRCLE_FILL("x.circle.fill"), + X_SQUARE("x.square"), + X_SQUARE_FILL("x.square.fill"), + X_SQUAREROOT("x.squareroot"), + Y_CIRCLE("y.circle"), + Y_CIRCLE_FILL("y.circle.fill"), + Y_SQUARE("y.square"), + Y_SQUARE_FILL("y.square.fill"), + Z_CIRCLE("z.circle"), + Z_CIRCLE_FILL("z.circle.fill"), + Z_SQUARE("z.square"), + Z_SQUARE_FILL("z.square.fill"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolLocation.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolLocation.kt new file mode 100644 index 00000000..9f8ac36d --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolLocation.kt @@ -0,0 +1,54 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Location (47 symbols). */ +enum class SFSymbolLocation( + override val symbolName: String, +) : SFSymbol { + COMPASS_DRAWING("compass.drawing"), + FLAG("flag"), + FLAG_2_CROSSED("flag.2.crossed"), + FLAG_2_CROSSED_CIRCLE("flag.2.crossed.circle"), + FLAG_2_CROSSED_CIRCLE_FILL("flag.2.crossed.circle.fill"), + FLAG_2_CROSSED_FILL("flag.2.crossed.fill"), + FLAG_AND_FLAG_FILLED_CROSSED("flag.and.flag.filled.crossed"), + FLAG_BADGE_ELLIPSIS("flag.badge.ellipsis"), + FLAG_BADGE_ELLIPSIS_FILL("flag.badge.ellipsis.fill"), + FLAG_CIRCLE("flag.circle"), + FLAG_CIRCLE_FILL("flag.circle.fill"), + FLAG_FILL("flag.fill"), + FLAG_FILLED_AND_FLAG_CROSSED("flag.filled.and.flag.crossed"), + FLAG_PATTERN_CHECKERED("flag.pattern.checkered"), + FLAG_PATTERN_CHECKERED_2_CROSSED("flag.pattern.checkered.2.crossed"), + FLAG_PATTERN_CHECKERED_CIRCLE("flag.pattern.checkered.circle"), + FLAG_PATTERN_CHECKERED_CIRCLE_FILL("flag.pattern.checkered.circle.fill"), + FLAG_SLASH("flag.slash"), + FLAG_SLASH_CIRCLE("flag.slash.circle"), + FLAG_SLASH_CIRCLE_FILL("flag.slash.circle.fill"), + FLAG_SLASH_FILL("flag.slash.fill"), + FLAG_SQUARE("flag.square"), + FLAG_SQUARE_FILL("flag.square.fill"), + LOCATION("location"), + LOCATION_APP("location.app"), + LOCATION_APP_FILL("location.app.fill"), + LOCATION_CIRCLE("location.circle"), + LOCATION_CIRCLE_FILL("location.circle.fill"), + LOCATION_FILL("location.fill"), + LOCATION_FILL_VIEWFINDER("location.fill.viewfinder"), + LOCATION_MAGNIFYINGGLASS("location.magnifyingglass"), + LOCATION_NORTH("location.north"), + LOCATION_NORTH_CIRCLE("location.north.circle"), + LOCATION_NORTH_CIRCLE_FILL("location.north.circle.fill"), + LOCATION_NORTH_FILL("location.north.fill"), + LOCATION_NORTH_LINE("location.north.line"), + LOCATION_NORTH_LINE_FILL("location.north.line.fill"), + LOCATION_SLASH("location.slash"), + LOCATION_SLASH_CIRCLE("location.slash.circle"), + LOCATION_SLASH_CIRCLE_FILL("location.slash.circle.fill"), + LOCATION_SLASH_FILL("location.slash.fill"), + LOCATION_SQUARE("location.square"), + LOCATION_SQUARE_FILL("location.square.fill"), + LOCATION_VIEWFINDER("location.viewfinder"), + SAFARI("safari"), + SAFARI_FILL("safari.fill"), + SCOPE("scope"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolMedia.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolMedia.kt new file mode 100644 index 00000000..a44e4e07 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolMedia.kt @@ -0,0 +1,245 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Media (238 symbols). */ +enum class SFSymbolMedia( + override val symbolName: String, +) : SFSymbol { + AIRPLAY_AUDIO("airplay.audio"), + AIRPLAY_AUDIO_BADGE_EXCLAMATIONMARK("airplay.audio.badge.exclamationmark"), + AIRPLAY_AUDIO_CIRCLE("airplay.audio.circle"), + AIRPLAY_AUDIO_CIRCLE_FILL("airplay.audio.circle.fill"), + AIRPLAY_VIDEO("airplay.video"), + AIRPLAY_VIDEO_BADGE_EXCLAMATIONMARK("airplay.video.badge.exclamationmark"), + AIRPLAY_VIDEO_CIRCLE("airplay.video.circle"), + AIRPLAY_VIDEO_CIRCLE_FILL("airplay.video.circle.fill"), + BACKWARD("backward"), + BACKWARD_CIRCLE("backward.circle"), + BACKWARD_CIRCLE_FILL("backward.circle.fill"), + BACKWARD_END("backward.end"), + BACKWARD_END_ALT("backward.end.alt"), + BACKWARD_END_ALT_FILL("backward.end.alt.fill"), + BACKWARD_END_CIRCLE("backward.end.circle"), + BACKWARD_END_CIRCLE_FILL("backward.end.circle.fill"), + BACKWARD_END_FILL("backward.end.fill"), + BACKWARD_FILL("backward.fill"), + BACKWARD_FRAME("backward.frame"), + BACKWARD_FRAME_FILL("backward.frame.fill"), + CAMERA("camera"), + CAMERA_APERTURE("camera.aperture"), + CAMERA_BADGE_CLOCK("camera.badge.clock"), + CAMERA_BADGE_CLOCK_FILL("camera.badge.clock.fill"), + CAMERA_BADGE_ELLIPSIS("camera.badge.ellipsis"), + CAMERA_BADGE_ELLIPSIS_FILL("camera.badge.ellipsis.fill"), + CAMERA_CIRCLE("camera.circle"), + CAMERA_CIRCLE_FILL("camera.circle.fill"), + CAMERA_FILL("camera.fill"), + CAMERA_FILTERS("camera.filters"), + CAMERA_MACRO("camera.macro"), + CAMERA_MACRO_CIRCLE("camera.macro.circle"), + CAMERA_MACRO_CIRCLE_FILL("camera.macro.circle.fill"), + CAMERA_MACRO_SLASH("camera.macro.slash"), + CAMERA_MACRO_SLASH_CIRCLE("camera.macro.slash.circle"), + CAMERA_MACRO_SLASH_CIRCLE_FILL("camera.macro.slash.circle.fill"), + CAMERA_METERING_CENTER_WEIGHTED("camera.metering.center.weighted"), + CAMERA_METERING_CENTER_WEIGHTED_AVERAGE("camera.metering.center.weighted.average"), + CAMERA_METERING_MATRIX("camera.metering.matrix"), + CAMERA_METERING_MULTISPOT("camera.metering.multispot"), + CAMERA_METERING_NONE("camera.metering.none"), + CAMERA_METERING_PARTIAL("camera.metering.partial"), + CAMERA_METERING_SPOT("camera.metering.spot"), + CAMERA_METERING_UNKNOWN("camera.metering.unknown"), + CAMERA_ON_RECTANGLE("camera.on.rectangle"), + CAMERA_ON_RECTANGLE_FILL("camera.on.rectangle.fill"), + CAMERA_SHUTTER_BUTTON("camera.shutter.button"), + CAMERA_SHUTTER_BUTTON_FILL("camera.shutter.button.fill"), + CAMERA_VIEWFINDER("camera.viewfinder"), + FILM("film"), + FILM_CIRCLE("film.circle"), + FILM_CIRCLE_FILL("film.circle.fill"), + FILM_FILL("film.fill"), + FILM_STACK("film.stack"), + FILM_STACK_FILL("film.stack.fill"), + FORWARD("forward"), + FORWARD_CIRCLE("forward.circle"), + FORWARD_CIRCLE_FILL("forward.circle.fill"), + FORWARD_END("forward.end"), + FORWARD_END_ALT("forward.end.alt"), + FORWARD_END_ALT_FILL("forward.end.alt.fill"), + FORWARD_END_CIRCLE("forward.end.circle"), + FORWARD_END_CIRCLE_FILL("forward.end.circle.fill"), + FORWARD_END_FILL("forward.end.fill"), + FORWARD_FILL("forward.fill"), + FORWARD_FRAME("forward.frame"), + FORWARD_FRAME_FILL("forward.frame.fill"), + HEADPHONES("headphones"), + HEADPHONES_CIRCLE("headphones.circle"), + HEADPHONES_CIRCLE_FILL("headphones.circle.fill"), + HEADPHONES_SLASH("headphones.slash"), + LIVEPHOTO("livephoto"), + LIVEPHOTO_BADGE_AUTOMATIC("livephoto.badge.automatic"), + LIVEPHOTO_PLAY("livephoto.play"), + LIVEPHOTO_SLASH("livephoto.slash"), + MICROBE("microbe"), + MICROBE_CIRCLE("microbe.circle"), + MICROBE_CIRCLE_FILL("microbe.circle.fill"), + MICROBE_FILL("microbe.fill"), + MICROPHONE("microphone"), + MICROPHONE_AND_SIGNAL_METER("microphone.and.signal.meter"), + MICROPHONE_AND_SIGNAL_METER_FILL("microphone.and.signal.meter.fill"), + MICROPHONE_BADGE_ELLIPSIS("microphone.badge.ellipsis"), + MICROPHONE_BADGE_ELLIPSIS_FILL("microphone.badge.ellipsis.fill"), + MICROPHONE_BADGE_PLUS("microphone.badge.plus"), + MICROPHONE_BADGE_PLUS_FILL("microphone.badge.plus.fill"), + MICROPHONE_BADGE_XMARK("microphone.badge.xmark"), + MICROPHONE_BADGE_XMARK_FILL("microphone.badge.xmark.fill"), + MICROPHONE_CIRCLE("microphone.circle"), + MICROPHONE_CIRCLE_FILL("microphone.circle.fill"), + MICROPHONE_FILL("microphone.fill"), + MICROPHONE_SLASH("microphone.slash"), + MICROPHONE_SLASH_CIRCLE("microphone.slash.circle"), + MICROPHONE_SLASH_CIRCLE_FILL("microphone.slash.circle.fill"), + MICROPHONE_SLASH_FILL("microphone.slash.fill"), + MICROPHONE_SQUARE("microphone.square"), + MICROPHONE_SQUARE_FILL("microphone.square.fill"), + MICROWAVE("microwave"), + MICROWAVE_FILL("microwave.fill"), + MUSIC_MICROPHONE("music.microphone"), + MUSIC_MICROPHONE_CIRCLE("music.microphone.circle"), + MUSIC_MICROPHONE_CIRCLE_FILL("music.microphone.circle.fill"), + MUSIC_NOTE("music.note"), + MUSIC_NOTE_HOUSE("music.note.house"), + MUSIC_NOTE_HOUSE_FILL("music.note.house.fill"), + MUSIC_NOTE_LIST("music.note.list"), + MUSIC_NOTE_TV("music.note.tv"), + MUSIC_NOTE_TV_FILL("music.note.tv.fill"), + MUSIC_QUARTERNOTE_3("music.quarternote.3"), + PAUSE("pause"), + PAUSE_CIRCLE("pause.circle"), + PAUSE_CIRCLE_FILL("pause.circle.fill"), + PAUSE_FILL("pause.fill"), + PAUSE_RECTANGLE("pause.rectangle"), + PAUSE_RECTANGLE_FILL("pause.rectangle.fill"), + PHOTO("photo"), + PHOTO_ARTFRAME("photo.artframe"), + PHOTO_ARTFRAME_CIRCLE("photo.artframe.circle"), + PHOTO_ARTFRAME_CIRCLE_FILL("photo.artframe.circle.fill"), + PHOTO_BADGE_ARROW_DOWN("photo.badge.arrow.down"), + PHOTO_BADGE_ARROW_DOWN_FILL("photo.badge.arrow.down.fill"), + PHOTO_BADGE_CHECKMARK("photo.badge.checkmark"), + PHOTO_BADGE_CHECKMARK_FILL("photo.badge.checkmark.fill"), + PHOTO_BADGE_EXCLAMATIONMARK("photo.badge.exclamationmark"), + PHOTO_BADGE_EXCLAMATIONMARK_FILL("photo.badge.exclamationmark.fill"), + PHOTO_BADGE_PLUS("photo.badge.plus"), + PHOTO_BADGE_PLUS_FILL("photo.badge.plus.fill"), + PHOTO_CIRCLE("photo.circle"), + PHOTO_CIRCLE_FILL("photo.circle.fill"), + PHOTO_FILL("photo.fill"), + PHOTO_FILL_ON_RECTANGLE_FILL("photo.fill.on.rectangle.fill"), + PHOTO_ON_RECTANGLE("photo.on.rectangle"), + PHOTO_ON_RECTANGLE_ANGLED("photo.on.rectangle.angled"), + PHOTO_ON_RECTANGLE_ANGLED_FILL("photo.on.rectangle.angled.fill"), + PHOTO_STACK("photo.stack"), + PHOTO_STACK_FILL("photo.stack.fill"), + PHOTO_TV("photo.tv"), + PLAY("play"), + PLAY_CIRCLE("play.circle"), + PLAY_CIRCLE_FILL("play.circle.fill"), + PLAY_DESKTOPCOMPUTER("play.desktopcomputer"), + PLAY_DISPLAY("play.display"), + PLAY_FILL("play.fill"), + PLAY_HOUSE("play.house"), + PLAY_HOUSE_FILL("play.house.fill"), + PLAY_LAPTOPCOMPUTER("play.laptopcomputer"), + PLAY_RECTANGLE("play.rectangle"), + PLAY_RECTANGLE_FILL("play.rectangle.fill"), + PLAY_RECTANGLE_ON_RECTANGLE("play.rectangle.on.rectangle"), + PLAY_RECTANGLE_ON_RECTANGLE_CIRCLE("play.rectangle.on.rectangle.circle"), + PLAY_RECTANGLE_ON_RECTANGLE_CIRCLE_FILL("play.rectangle.on.rectangle.circle.fill"), + PLAY_RECTANGLE_ON_RECTANGLE_FILL("play.rectangle.on.rectangle.fill"), + PLAY_SLASH("play.slash"), + PLAY_SLASH_FILL("play.slash.fill"), + PLAY_SQUARE("play.square"), + PLAY_SQUARE_FILL("play.square.fill"), + PLAY_SQUARE_STACK("play.square.stack"), + PLAY_SQUARE_STACK_FILL("play.square.stack.fill"), + PLAY_TV("play.tv"), + PLAY_TV_FILL("play.tv.fill"), + PLAYPAUSE("playpause"), + PLAYPAUSE_CIRCLE("playpause.circle"), + PLAYPAUSE_CIRCLE_FILL("playpause.circle.fill"), + PLAYPAUSE_FILL("playpause.fill"), + PLAYSTATION_LOGO("playstation.logo"), + RECORD_CIRCLE("record.circle"), + RECORD_CIRCLE_FILL("record.circle.fill"), + RECORDINGTAPE("recordingtape"), + RECORDINGTAPE_CIRCLE("recordingtape.circle"), + RECORDINGTAPE_CIRCLE_FILL("recordingtape.circle.fill"), + REPEAT("repeat"), + REPEAT_1("repeat.1"), + REPEAT_1_CIRCLE("repeat.1.circle"), + REPEAT_1_CIRCLE_FILL("repeat.1.circle.fill"), + REPEAT_CIRCLE("repeat.circle"), + REPEAT_CIRCLE_FILL("repeat.circle.fill"), + SHUFFLE("shuffle"), + SHUFFLE_CIRCLE("shuffle.circle"), + SHUFFLE_CIRCLE_FILL("shuffle.circle.fill"), + SPEAKER("speaker"), + SPEAKER_BADGE_EXCLAMATIONMARK("speaker.badge.exclamationmark"), + SPEAKER_BADGE_EXCLAMATIONMARK_FILL("speaker.badge.exclamationmark.fill"), + SPEAKER_CIRCLE("speaker.circle"), + SPEAKER_CIRCLE_FILL("speaker.circle.fill"), + SPEAKER_FILL("speaker.fill"), + SPEAKER_MINUS("speaker.minus"), + SPEAKER_MINUS_FILL("speaker.minus.fill"), + SPEAKER_PLUS("speaker.plus"), + SPEAKER_PLUS_FILL("speaker.plus.fill"), + SPEAKER_SLASH("speaker.slash"), + SPEAKER_SLASH_CIRCLE("speaker.slash.circle"), + SPEAKER_SLASH_CIRCLE_FILL("speaker.slash.circle.fill"), + SPEAKER_SLASH_FILL("speaker.slash.fill"), + SPEAKER_SQUARE("speaker.square"), + SPEAKER_SQUARE_FILL("speaker.square.fill"), + SPEAKER_WAVE_1("speaker.wave.1"), + SPEAKER_WAVE_1_ARROWTRIANGLES_UP_RIGHT_DOWN_LEFT("speaker.wave.1.arrowtriangles.up.right.down.left"), + SPEAKER_WAVE_1_FILL("speaker.wave.1.fill"), + SPEAKER_WAVE_2("speaker.wave.2"), + SPEAKER_WAVE_2_BUBBLE("speaker.wave.2.bubble"), + SPEAKER_WAVE_2_BUBBLE_FILL("speaker.wave.2.bubble.fill"), + SPEAKER_WAVE_2_CIRCLE("speaker.wave.2.circle"), + SPEAKER_WAVE_2_CIRCLE_FILL("speaker.wave.2.circle.fill"), + SPEAKER_WAVE_2_FILL("speaker.wave.2.fill"), + SPEAKER_WAVE_3("speaker.wave.3"), + SPEAKER_WAVE_3_FILL("speaker.wave.3.fill"), + SPEAKER_ZZZ("speaker.zzz"), + SPEAKER_ZZZ_FILL("speaker.zzz.fill"), + STOP("stop"), + STOP_CIRCLE("stop.circle"), + STOP_CIRCLE_FILL("stop.circle.fill"), + STOP_FILL("stop.fill"), + STOPWATCH("stopwatch"), + STOPWATCH_FILL("stopwatch.fill"), + VIDEO("video"), + VIDEO_BADGE_CHECKMARK("video.badge.checkmark"), + VIDEO_BADGE_ELLIPSIS("video.badge.ellipsis"), + VIDEO_BADGE_PLUS("video.badge.plus"), + VIDEO_BADGE_WAVEFORM("video.badge.waveform"), + VIDEO_BADGE_WAVEFORM_FILL("video.badge.waveform.fill"), + VIDEO_BUBBLE("video.bubble"), + VIDEO_BUBBLE_FILL("video.bubble.fill"), + VIDEO_CIRCLE("video.circle"), + VIDEO_CIRCLE_FILL("video.circle.fill"), + VIDEO_DOORBELL("video.doorbell"), + VIDEO_DOORBELL_FILL("video.doorbell.fill"), + VIDEO_FILL("video.fill"), + VIDEO_FILL_BADGE_CHECKMARK("video.fill.badge.checkmark"), + VIDEO_FILL_BADGE_ELLIPSIS("video.fill.badge.ellipsis"), + VIDEO_FILL_BADGE_PLUS("video.fill.badge.plus"), + VIDEO_SLASH("video.slash"), + VIDEO_SLASH_CIRCLE("video.slash.circle"), + VIDEO_SLASH_CIRCLE_FILL("video.slash.circle.fill"), + VIDEO_SLASH_FILL("video.slash.fill"), + VIDEO_SQUARE("video.square"), + VIDEO_SQUARE_FILL("video.square.fill"), + VIDEOPROJECTOR("videoprojector"), + VIDEOPROJECTOR_FILL("videoprojector.fill"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolNumbers.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolNumbers.kt new file mode 100644 index 00000000..c45bd3eb --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolNumbers.kt @@ -0,0 +1,308 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Numbers (301 symbols). */ +enum class SFSymbolNumbers( + override val symbolName: String, +) : SFSymbol { + _0_CIRCLE("0.circle"), + _00_CIRCLE("00.circle"), + _0_CIRCLE_FILL("0.circle.fill"), + _00_CIRCLE_FILL("00.circle.fill"), + _0_SQUARE("0.square"), + _00_SQUARE("00.square"), + _0_SQUARE_FILL("0.square.fill"), + _00_SQUARE_FILL("00.square.fill"), + _1_BRAKESIGNAL("1.brakesignal"), + _1_CIRCLE("1.circle"), + _01_CIRCLE("01.circle"), + _1_CIRCLE_FILL("1.circle.fill"), + _01_CIRCLE_FILL("01.circle.fill"), + _1_LANE("1.lane"), + _1_MAGNIFYINGGLASS("1.magnifyingglass"), + _1_SQUARE("1.square"), + _01_SQUARE("01.square"), + _1_SQUARE_FILL("1.square.fill"), + _01_SQUARE_FILL("01.square.fill"), + _2_BRAKESIGNAL("2.brakesignal"), + _2_CIRCLE("2.circle"), + _02_CIRCLE("02.circle"), + _2_CIRCLE_FILL("2.circle.fill"), + _02_CIRCLE_FILL("02.circle.fill"), + _2_LANE("2.lane"), + _2_SQUARE("2.square"), + _02_SQUARE("02.square"), + _2_SQUARE_FILL("2.square.fill"), + _02_SQUARE_FILL("02.square.fill"), + _2H("2h"), + _2H_CIRCLE("2h.circle"), + _2H_CIRCLE_FILL("2h.circle.fill"), + _3_CIRCLE("3.circle"), + _03_CIRCLE("03.circle"), + _3_CIRCLE_FILL("3.circle.fill"), + _03_CIRCLE_FILL("03.circle.fill"), + _3_LANE("3.lane"), + _3_SQUARE("3.square"), + _03_SQUARE("03.square"), + _3_SQUARE_FILL("3.square.fill"), + _03_SQUARE_FILL("03.square.fill"), + _4_ALT_CIRCLE("4.alt.circle"), + _4_ALT_CIRCLE_FILL("4.alt.circle.fill"), + _4_ALT_SQUARE("4.alt.square"), + _4_ALT_SQUARE_FILL("4.alt.square.fill"), + _4_CIRCLE("4.circle"), + _04_CIRCLE("04.circle"), + _4_CIRCLE_FILL("4.circle.fill"), + _04_CIRCLE_FILL("04.circle.fill"), + _4_LANE("4.lane"), + _4_SQUARE("4.square"), + _04_SQUARE("04.square"), + _4_SQUARE_FILL("4.square.fill"), + _04_SQUARE_FILL("04.square.fill"), + _4A("4a"), + _4A_CIRCLE("4a.circle"), + _4A_CIRCLE_FILL("4a.circle.fill"), + _4H("4h"), + _4H_CIRCLE("4h.circle"), + _4H_CIRCLE_FILL("4h.circle.fill"), + _4K_TV("4k.tv"), + _4K_TV_FILL("4k.tv.fill"), + _4L("4l"), + _4L_CIRCLE("4l.circle"), + _4L_CIRCLE_FILL("4l.circle.fill"), + _5_ARROW_TRIANGLEHEAD_CLOCKWISE("5.arrow.trianglehead.clockwise"), + _5_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("5.arrow.trianglehead.counterclockwise"), + _5_CIRCLE("5.circle"), + _05_CIRCLE("05.circle"), + _5_CIRCLE_FILL("5.circle.fill"), + _05_CIRCLE_FILL("05.circle.fill"), + _5_LANE("5.lane"), + _5_SQUARE("5.square"), + _05_SQUARE("05.square"), + _5_SQUARE_FILL("5.square.fill"), + _05_SQUARE_FILL("05.square.fill"), + _6_ALT_CIRCLE("6.alt.circle"), + _6_ALT_CIRCLE_FILL("6.alt.circle.fill"), + _6_ALT_SQUARE("6.alt.square"), + _6_ALT_SQUARE_FILL("6.alt.square.fill"), + _6_CIRCLE("6.circle"), + _06_CIRCLE("06.circle"), + _6_CIRCLE_FILL("6.circle.fill"), + _06_CIRCLE_FILL("06.circle.fill"), + _6_LANE("6.lane"), + _6_SQUARE("6.square"), + _06_SQUARE("06.square"), + _6_SQUARE_FILL("6.square.fill"), + _06_SQUARE_FILL("06.square.fill"), + _7_CIRCLE("7.circle"), + _07_CIRCLE("07.circle"), + _7_CIRCLE_FILL("7.circle.fill"), + _07_CIRCLE_FILL("07.circle.fill"), + _7_LANE("7.lane"), + _7_SQUARE("7.square"), + _07_SQUARE("07.square"), + _7_SQUARE_FILL("7.square.fill"), + _07_SQUARE_FILL("07.square.fill"), + _8_CIRCLE("8.circle"), + _08_CIRCLE("08.circle"), + _8_CIRCLE_FILL("8.circle.fill"), + _08_CIRCLE_FILL("08.circle.fill"), + _8_LANE("8.lane"), + _8_SQUARE("8.square"), + _08_SQUARE("08.square"), + _8_SQUARE_FILL("8.square.fill"), + _08_SQUARE_FILL("08.square.fill"), + _9_ALT_CIRCLE("9.alt.circle"), + _9_ALT_CIRCLE_FILL("9.alt.circle.fill"), + _9_ALT_SQUARE("9.alt.square"), + _9_ALT_SQUARE_FILL("9.alt.square.fill"), + _9_CIRCLE("9.circle"), + _09_CIRCLE("09.circle"), + _9_CIRCLE_FILL("9.circle.fill"), + _09_CIRCLE_FILL("09.circle.fill"), + _9_LANE("9.lane"), + _9_SQUARE("9.square"), + _09_SQUARE("09.square"), + _9_SQUARE_FILL("9.square.fill"), + _09_SQUARE_FILL("09.square.fill"), + _10_ARROW_TRIANGLEHEAD_CLOCKWISE("10.arrow.trianglehead.clockwise"), + _10_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("10.arrow.trianglehead.counterclockwise"), + _10_CIRCLE("10.circle"), + _10_CIRCLE_FILL("10.circle.fill"), + _10_LANE("10.lane"), + _10_SQUARE("10.square"), + _10_SQUARE_FILL("10.square.fill"), + _11_CIRCLE("11.circle"), + _11_CIRCLE_FILL("11.circle.fill"), + _11_LANE("11.lane"), + _11_SQUARE("11.square"), + _11_SQUARE_FILL("11.square.fill"), + _12_CIRCLE("12.circle"), + _12_CIRCLE_FILL("12.circle.fill"), + _12_LANE("12.lane"), + _12_SQUARE("12.square"), + _12_SQUARE_FILL("12.square.fill"), + _13_CIRCLE("13.circle"), + _13_CIRCLE_FILL("13.circle.fill"), + _13_SQUARE("13.square"), + _13_SQUARE_FILL("13.square.fill"), + _14_CIRCLE("14.circle"), + _14_CIRCLE_FILL("14.circle.fill"), + _14_SQUARE("14.square"), + _14_SQUARE_FILL("14.square.fill"), + _15_ARROW_TRIANGLEHEAD_CLOCKWISE("15.arrow.trianglehead.clockwise"), + _15_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("15.arrow.trianglehead.counterclockwise"), + _15_CIRCLE("15.circle"), + _15_CIRCLE_FILL("15.circle.fill"), + _15_SQUARE("15.square"), + _15_SQUARE_FILL("15.square.fill"), + _16_CIRCLE("16.circle"), + _16_CIRCLE_FILL("16.circle.fill"), + _16_SQUARE("16.square"), + _16_SQUARE_FILL("16.square.fill"), + _17_CIRCLE("17.circle"), + _17_CIRCLE_FILL("17.circle.fill"), + _17_SQUARE("17.square"), + _17_SQUARE_FILL("17.square.fill"), + _18_CIRCLE("18.circle"), + _18_CIRCLE_FILL("18.circle.fill"), + _18_SQUARE("18.square"), + _18_SQUARE_FILL("18.square.fill"), + _19_CIRCLE("19.circle"), + _19_CIRCLE_FILL("19.circle.fill"), + _19_SQUARE("19.square"), + _19_SQUARE_FILL("19.square.fill"), + _20_CIRCLE("20.circle"), + _20_CIRCLE_FILL("20.circle.fill"), + _20_SQUARE("20.square"), + _20_SQUARE_FILL("20.square.fill"), + _21_CIRCLE("21.circle"), + _21_CIRCLE_FILL("21.circle.fill"), + _21_SQUARE("21.square"), + _21_SQUARE_FILL("21.square.fill"), + _22_CIRCLE("22.circle"), + _22_CIRCLE_FILL("22.circle.fill"), + _22_SQUARE("22.square"), + _22_SQUARE_FILL("22.square.fill"), + _23_CIRCLE("23.circle"), + _23_CIRCLE_FILL("23.circle.fill"), + _23_SQUARE("23.square"), + _23_SQUARE_FILL("23.square.fill"), + _24_CIRCLE("24.circle"), + _24_CIRCLE_FILL("24.circle.fill"), + _24_SQUARE("24.square"), + _24_SQUARE_FILL("24.square.fill"), + _25_CIRCLE("25.circle"), + _25_CIRCLE_FILL("25.circle.fill"), + _25_SQUARE("25.square"), + _25_SQUARE_FILL("25.square.fill"), + _26_CIRCLE("26.circle"), + _26_CIRCLE_FILL("26.circle.fill"), + _26_SQUARE("26.square"), + _26_SQUARE_FILL("26.square.fill"), + _27_CIRCLE("27.circle"), + _27_CIRCLE_FILL("27.circle.fill"), + _27_SQUARE("27.square"), + _27_SQUARE_FILL("27.square.fill"), + _28_CIRCLE("28.circle"), + _28_CIRCLE_FILL("28.circle.fill"), + _28_SQUARE("28.square"), + _28_SQUARE_FILL("28.square.fill"), + _29_CIRCLE("29.circle"), + _29_CIRCLE_FILL("29.circle.fill"), + _29_SQUARE("29.square"), + _29_SQUARE_FILL("29.square.fill"), + _30_ARROW_TRIANGLEHEAD_CLOCKWISE("30.arrow.trianglehead.clockwise"), + _30_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("30.arrow.trianglehead.counterclockwise"), + _30_CIRCLE("30.circle"), + _30_CIRCLE_FILL("30.circle.fill"), + _30_SQUARE("30.square"), + _30_SQUARE_FILL("30.square.fill"), + _31_CIRCLE("31.circle"), + _31_CIRCLE_FILL("31.circle.fill"), + _31_SQUARE("31.square"), + _31_SQUARE_FILL("31.square.fill"), + _32_CIRCLE("32.circle"), + _32_CIRCLE_FILL("32.circle.fill"), + _32_SQUARE("32.square"), + _32_SQUARE_FILL("32.square.fill"), + _33_CIRCLE("33.circle"), + _33_CIRCLE_FILL("33.circle.fill"), + _33_SQUARE("33.square"), + _33_SQUARE_FILL("33.square.fill"), + _34_CIRCLE("34.circle"), + _34_CIRCLE_FILL("34.circle.fill"), + _34_SQUARE("34.square"), + _34_SQUARE_FILL("34.square.fill"), + _35_CIRCLE("35.circle"), + _35_CIRCLE_FILL("35.circle.fill"), + _35_SQUARE("35.square"), + _35_SQUARE_FILL("35.square.fill"), + _36_CIRCLE("36.circle"), + _36_CIRCLE_FILL("36.circle.fill"), + _36_SQUARE("36.square"), + _36_SQUARE_FILL("36.square.fill"), + _37_CIRCLE("37.circle"), + _37_CIRCLE_FILL("37.circle.fill"), + _37_SQUARE("37.square"), + _37_SQUARE_FILL("37.square.fill"), + _38_CIRCLE("38.circle"), + _38_CIRCLE_FILL("38.circle.fill"), + _38_SQUARE("38.square"), + _38_SQUARE_FILL("38.square.fill"), + _39_CIRCLE("39.circle"), + _39_CIRCLE_FILL("39.circle.fill"), + _39_SQUARE("39.square"), + _39_SQUARE_FILL("39.square.fill"), + _40_CIRCLE("40.circle"), + _40_CIRCLE_FILL("40.circle.fill"), + _40_SQUARE("40.square"), + _40_SQUARE_FILL("40.square.fill"), + _41_CIRCLE("41.circle"), + _41_CIRCLE_FILL("41.circle.fill"), + _41_SQUARE("41.square"), + _41_SQUARE_FILL("41.square.fill"), + _42_CIRCLE("42.circle"), + _42_CIRCLE_FILL("42.circle.fill"), + _42_SQUARE("42.square"), + _42_SQUARE_FILL("42.square.fill"), + _43_CIRCLE("43.circle"), + _43_CIRCLE_FILL("43.circle.fill"), + _43_SQUARE("43.square"), + _43_SQUARE_FILL("43.square.fill"), + _44_CIRCLE("44.circle"), + _44_CIRCLE_FILL("44.circle.fill"), + _44_SQUARE("44.square"), + _44_SQUARE_FILL("44.square.fill"), + _45_ARROW_TRIANGLEHEAD_CLOCKWISE("45.arrow.trianglehead.clockwise"), + _45_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("45.arrow.trianglehead.counterclockwise"), + _45_CIRCLE("45.circle"), + _45_CIRCLE_FILL("45.circle.fill"), + _45_SQUARE("45.square"), + _45_SQUARE_FILL("45.square.fill"), + _46_CIRCLE("46.circle"), + _46_CIRCLE_FILL("46.circle.fill"), + _46_SQUARE("46.square"), + _46_SQUARE_FILL("46.square.fill"), + _47_CIRCLE("47.circle"), + _47_CIRCLE_FILL("47.circle.fill"), + _47_SQUARE("47.square"), + _47_SQUARE_FILL("47.square.fill"), + _48_CIRCLE("48.circle"), + _48_CIRCLE_FILL("48.circle.fill"), + _48_SQUARE("48.square"), + _48_SQUARE_FILL("48.square.fill"), + _49_CIRCLE("49.circle"), + _49_CIRCLE_FILL("49.circle.fill"), + _49_SQUARE("49.square"), + _49_SQUARE_FILL("49.square.fill"), + _50_CIRCLE("50.circle"), + _50_CIRCLE_FILL("50.circle.fill"), + _50_SQUARE("50.square"), + _50_SQUARE_FILL("50.square.fill"), + _60_ARROW_TRIANGLEHEAD_CLOCKWISE("60.arrow.trianglehead.clockwise"), + _60_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("60.arrow.trianglehead.counterclockwise"), + _75_ARROW_TRIANGLEHEAD_CLOCKWISE("75.arrow.trianglehead.clockwise"), + _75_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("75.arrow.trianglehead.counterclockwise"), + _90_ARROW_TRIANGLEHEAD_CLOCKWISE("90.arrow.trianglehead.clockwise"), + _90_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("90.arrow.trianglehead.counterclockwise"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolObjectsAndTools.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolObjectsAndTools.kt new file mode 100644 index 00000000..328da1fb --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolObjectsAndTools.kt @@ -0,0 +1,365 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — ObjectsAndTools (358 symbols). */ +enum class SFSymbolObjectsAndTools( + override val symbolName: String, +) : SFSymbol { + BANDAGE("bandage"), + BANDAGE_FILL("bandage.fill"), + BATHTUB("bathtub"), + BATHTUB_FILL("bathtub.fill"), + BED_DOUBLE("bed.double"), + BED_DOUBLE_CIRCLE("bed.double.circle"), + BED_DOUBLE_CIRCLE_FILL("bed.double.circle.fill"), + BED_DOUBLE_FILL("bed.double.fill"), + BINOCULARS("binoculars"), + BINOCULARS_CIRCLE("binoculars.circle"), + BINOCULARS_CIRCLE_FILL("binoculars.circle.fill"), + BINOCULARS_FILL("binoculars.fill"), + BOOK("book"), + BOOK_AND_WRENCH("book.and.wrench"), + BOOK_AND_WRENCH_FILL("book.and.wrench.fill"), + BOOK_CIRCLE("book.circle"), + BOOK_CIRCLE_FILL("book.circle.fill"), + BOOK_CLOSED("book.closed"), + BOOK_CLOSED_CIRCLE("book.closed.circle"), + BOOK_CLOSED_CIRCLE_FILL("book.closed.circle.fill"), + BOOK_CLOSED_FILL("book.closed.fill"), + BOOK_FILL("book.fill"), + BOOK_PAGES("book.pages"), + BOOK_PAGES_FILL("book.pages.fill"), + BOOKMARK("bookmark"), + BOOKMARK_CIRCLE("bookmark.circle"), + BOOKMARK_CIRCLE_FILL("bookmark.circle.fill"), + BOOKMARK_FILL("bookmark.fill"), + BOOKMARK_SLASH("bookmark.slash"), + BOOKMARK_SLASH_FILL("bookmark.slash.fill"), + BOOKMARK_SQUARE("bookmark.square"), + BOOKMARK_SQUARE_FILL("bookmark.square.fill"), + BOOKS_VERTICAL("books.vertical"), + BOOKS_VERTICAL_CIRCLE("books.vertical.circle"), + BOOKS_VERTICAL_CIRCLE_FILL("books.vertical.circle.fill"), + BOOKS_VERTICAL_FILL("books.vertical.fill"), + BUILDING("building"), + BUILDING_2("building.2"), + BUILDING_2_CROP_CIRCLE("building.2.crop.circle"), + BUILDING_2_CROP_CIRCLE_FILL("building.2.crop.circle.fill"), + BUILDING_2_FILL("building.2.fill"), + BUILDING_COLUMNS("building.columns"), + BUILDING_COLUMNS_CIRCLE("building.columns.circle"), + BUILDING_COLUMNS_CIRCLE_FILL("building.columns.circle.fill"), + BUILDING_COLUMNS_FILL("building.columns.fill"), + BUILDING_FILL("building.fill"), + CABINET("cabinet"), + CABINET_FILL("cabinet.fill"), + CHAIR("chair"), + CHAIR_FILL("chair.fill"), + CHAIR_LOUNGE("chair.lounge"), + CHAIR_LOUNGE_FILL("chair.lounge.fill"), + CHANDELIER("chandelier"), + CHANDELIER_FILL("chandelier.fill"), + COOKTOP("cooktop"), + COOKTOP_FILL("cooktop.fill"), + CROSS("cross"), + CROSS_CASE("cross.case"), + CROSS_CASE_CIRCLE("cross.case.circle"), + CROSS_CASE_CIRCLE_FILL("cross.case.circle.fill"), + CROSS_CASE_FILL("cross.case.fill"), + CROSS_CIRCLE("cross.circle"), + CROSS_CIRCLE_FILL("cross.circle.fill"), + CROSS_FILL("cross.fill"), + CROSS_VIAL("cross.vial"), + CROSS_VIAL_FILL("cross.vial.fill"), + CURTAINS_CLOSED("curtains.closed"), + CURTAINS_OPEN("curtains.open"), + DISHWASHER("dishwasher"), + DISHWASHER_CIRCLE("dishwasher.circle"), + DISHWASHER_CIRCLE_FILL("dishwasher.circle.fill"), + DISHWASHER_FILL("dishwasher.fill"), + DOCK_ARROW_DOWN_RECTANGLE("dock.arrow.down.rectangle"), + DOCK_ARROW_UP_RECTANGLE("dock.arrow.up.rectangle"), + DOCK_RECTANGLE("dock.rectangle"), + DOCUMENT("document"), + DOCUMENT_BADGE_ARROW_UP("document.badge.arrow.up"), + DOCUMENT_BADGE_ARROW_UP_FILL("document.badge.arrow.up.fill"), + DOCUMENT_BADGE_CLOCK("document.badge.clock"), + DOCUMENT_BADGE_CLOCK_FILL("document.badge.clock.fill"), + DOCUMENT_BADGE_ELLIPSIS("document.badge.ellipsis"), + DOCUMENT_BADGE_ELLIPSIS_FILL("document.badge.ellipsis.fill"), + DOCUMENT_BADGE_GEARSHAPE("document.badge.gearshape"), + DOCUMENT_BADGE_GEARSHAPE_FILL("document.badge.gearshape.fill"), + DOCUMENT_BADGE_PLUS("document.badge.plus"), + DOCUMENT_BADGE_PLUS_FILL("document.badge.plus.fill"), + DOCUMENT_CIRCLE("document.circle"), + DOCUMENT_CIRCLE_FILL("document.circle.fill"), + DOCUMENT_FILL("document.fill"), + DOCUMENT_ON_CLIPBOARD("document.on.clipboard"), + DOCUMENT_ON_CLIPBOARD_FILL("document.on.clipboard.fill"), + DOCUMENT_ON_DOCUMENT("document.on.document"), + DOCUMENT_ON_DOCUMENT_FILL("document.on.document.fill"), + DOCUMENT_VIEWFINDER("document.viewfinder"), + DOCUMENT_VIEWFINDER_FILL("document.viewfinder.fill"), + DOOR_FRENCH_CLOSED("door.french.closed"), + DOOR_FRENCH_OPEN("door.french.open"), + DOOR_GARAGE_CLOSED("door.garage.closed"), + DOOR_GARAGE_CLOSED_TRIANGLEBADGE_EXCLAMATIONMARK("door.garage.closed.trianglebadge.exclamationmark"), + DOOR_GARAGE_DOUBLE_BAY_CLOSED("door.garage.double.bay.closed"), + DOOR_GARAGE_DOUBLE_BAY_CLOSED_TRIANGLEBADGE_EXCLAMATIONMARK("door.garage.double.bay.closed.trianglebadge.exclamationmark"), + DOOR_GARAGE_DOUBLE_BAY_OPEN("door.garage.double.bay.open"), + DOOR_GARAGE_DOUBLE_BAY_OPEN_TRIANGLEBADGE_EXCLAMATIONMARK("door.garage.double.bay.open.trianglebadge.exclamationmark"), + DOOR_GARAGE_OPEN("door.garage.open"), + DOOR_GARAGE_OPEN_TRIANGLEBADGE_EXCLAMATIONMARK("door.garage.open.trianglebadge.exclamationmark"), + DOOR_LEFT_HAND_CLOSED("door.left.hand.closed"), + DOOR_LEFT_HAND_OPEN("door.left.hand.open"), + DOOR_RIGHT_HAND_CLOSED("door.right.hand.closed"), + DOOR_RIGHT_HAND_OPEN("door.right.hand.open"), + DOOR_SLIDING_LEFT_HAND_CLOSED("door.sliding.left.hand.closed"), + DOOR_SLIDING_LEFT_HAND_OPEN("door.sliding.left.hand.open"), + DOOR_SLIDING_RIGHT_HAND_CLOSED("door.sliding.right.hand.closed"), + DOOR_SLIDING_RIGHT_HAND_OPEN("door.sliding.right.hand.open"), + DRYER("dryer"), + DRYER_CIRCLE("dryer.circle"), + DRYER_CIRCLE_FILL("dryer.circle.fill"), + DRYER_FILL("dryer.fill"), + ERASER("eraser"), + ERASER_FILL("eraser.fill"), + ERASER_LINE_DASHED("eraser.line.dashed"), + ERASER_LINE_DASHED_FILL("eraser.line.dashed.fill"), + FIREPLACE("fireplace"), + FIREPLACE_FILL("fireplace.fill"), + FLASHLIGHT_OFF_CIRCLE("flashlight.off.circle"), + FLASHLIGHT_OFF_CIRCLE_FILL("flashlight.off.circle.fill"), + FLASHLIGHT_OFF_FILL("flashlight.off.fill"), + FLASHLIGHT_ON_CIRCLE("flashlight.on.circle"), + FLASHLIGHT_ON_CIRCLE_FILL("flashlight.on.circle.fill"), + FLASHLIGHT_ON_FILL("flashlight.on.fill"), + FLASHLIGHT_SLASH("flashlight.slash"), + FLASHLIGHT_SLASH_CIRCLE("flashlight.slash.circle"), + FLASHLIGHT_SLASH_CIRCLE_FILL("flashlight.slash.circle.fill"), + FOLDER("folder"), + FOLDER_BADGE_GEARSHAPE("folder.badge.gearshape"), + FOLDER_BADGE_MINUS("folder.badge.minus"), + FOLDER_BADGE_PERSON_CROP("folder.badge.person.crop"), + FOLDER_BADGE_PLUS("folder.badge.plus"), + FOLDER_BADGE_QUESTIONMARK("folder.badge.questionmark"), + FOLDER_CIRCLE("folder.circle"), + FOLDER_CIRCLE_FILL("folder.circle.fill"), + FOLDER_FILL("folder.fill"), + FOLDER_FILL_BADGE_GEARSHAPE("folder.fill.badge.gearshape"), + FOLDER_FILL_BADGE_MINUS("folder.fill.badge.minus"), + FOLDER_FILL_BADGE_PERSON_CROP("folder.fill.badge.person.crop"), + FOLDER_FILL_BADGE_PLUS("folder.fill.badge.plus"), + FOLDER_FILL_BADGE_QUESTIONMARK("folder.fill.badge.questionmark"), + GLOBE("globe"), + GLOBE_AMERICAS("globe.americas"), + GLOBE_AMERICAS_FILL("globe.americas.fill"), + GLOBE_ASIA_AUSTRALIA("globe.asia.australia"), + GLOBE_ASIA_AUSTRALIA_FILL("globe.asia.australia.fill"), + GLOBE_BADGE_CHEVRON_BACKWARD("globe.badge.chevron.backward"), + GLOBE_CENTRAL_SOUTH_ASIA("globe.central.south.asia"), + GLOBE_CENTRAL_SOUTH_ASIA_FILL("globe.central.south.asia.fill"), + GLOBE_DESK("globe.desk"), + GLOBE_DESK_FILL("globe.desk.fill"), + GLOBE_EUROPE_AFRICA("globe.europe.africa"), + GLOBE_EUROPE_AFRICA_FILL("globe.europe.africa.fill"), + HAMMER("hammer"), + HAMMER_CIRCLE("hammer.circle"), + HAMMER_CIRCLE_FILL("hammer.circle.fill"), + HAMMER_FILL("hammer.fill"), + HOUSE("house"), + HOUSE_AND_FLAG("house.and.flag"), + HOUSE_AND_FLAG_CIRCLE("house.and.flag.circle"), + HOUSE_AND_FLAG_CIRCLE_FILL("house.and.flag.circle.fill"), + HOUSE_AND_FLAG_FILL("house.and.flag.fill"), + HOUSE_BADGE_EXCLAMATIONMARK("house.badge.exclamationmark"), + HOUSE_BADGE_EXCLAMATIONMARK_FILL("house.badge.exclamationmark.fill"), + HOUSE_BADGE_WIFI("house.badge.wifi"), + HOUSE_BADGE_WIFI_FILL("house.badge.wifi.fill"), + HOUSE_CIRCLE("house.circle"), + HOUSE_CIRCLE_FILL("house.circle.fill"), + HOUSE_FILL("house.fill"), + HOUSE_LODGE("house.lodge"), + HOUSE_LODGE_CIRCLE("house.lodge.circle"), + HOUSE_LODGE_CIRCLE_FILL("house.lodge.circle.fill"), + HOUSE_LODGE_FILL("house.lodge.fill"), + HOUSE_SLASH("house.slash"), + HOUSE_SLASH_FILL("house.slash.fill"), + LAMP_CEILING("lamp.ceiling"), + LAMP_CEILING_FILL("lamp.ceiling.fill"), + LAMP_CEILING_INVERSE("lamp.ceiling.inverse"), + LAMP_DESK("lamp.desk"), + LAMP_DESK_FILL("lamp.desk.fill"), + LAMP_FLOOR("lamp.floor"), + LAMP_FLOOR_FILL("lamp.floor.fill"), + LAMP_TABLE("lamp.table"), + LAMP_TABLE_FILL("lamp.table.fill"), + LIGHT_BEACON_MAX("light.beacon.max"), + LIGHT_BEACON_MAX_FILL("light.beacon.max.fill"), + LIGHT_BEACON_MIN("light.beacon.min"), + LIGHT_BEACON_MIN_FILL("light.beacon.min.fill"), + LIGHT_CYLINDRICAL_CEILING("light.cylindrical.ceiling"), + LIGHT_CYLINDRICAL_CEILING_FILL("light.cylindrical.ceiling.fill"), + LIGHT_CYLINDRICAL_CEILING_INVERSE("light.cylindrical.ceiling.inverse"), + LIGHT_MAX("light.max"), + LIGHT_MIN("light.min"), + LIGHT_OVERHEAD_LEFT("light.overhead.left"), + LIGHT_OVERHEAD_LEFT_FILL("light.overhead.left.fill"), + LIGHT_OVERHEAD_RIGHT("light.overhead.right"), + LIGHT_OVERHEAD_RIGHT_FILL("light.overhead.right.fill"), + LIGHT_PANEL("light.panel"), + LIGHT_PANEL_FILL("light.panel.fill"), + LIGHT_RECESSED("light.recessed"), + LIGHT_RECESSED_3("light.recessed.3"), + LIGHT_RECESSED_3_FILL("light.recessed.3.fill"), + LIGHT_RECESSED_3_INVERSE("light.recessed.3.inverse"), + LIGHT_RECESSED_FILL("light.recessed.fill"), + LIGHT_RECESSED_INVERSE("light.recessed.inverse"), + LIGHT_RIBBON("light.ribbon"), + LIGHT_RIBBON_FILL("light.ribbon.fill"), + LIGHT_STRIP_2("light.strip.2"), + LIGHT_STRIP_2_FILL("light.strip.2.fill"), + LIGHTSWITCH_OFF("lightswitch.off"), + LIGHTSWITCH_OFF_FILL("lightswitch.off.fill"), + LIGHTSWITCH_OFF_SQUARE("lightswitch.off.square"), + LIGHTSWITCH_OFF_SQUARE_FILL("lightswitch.off.square.fill"), + LIGHTSWITCH_ON("lightswitch.on"), + LIGHTSWITCH_ON_FILL("lightswitch.on.fill"), + LIGHTSWITCH_ON_SQUARE("lightswitch.on.square"), + LIGHTSWITCH_ON_SQUARE_FILL("lightswitch.on.square.fill"), + LINK("link"), + LINK_BADGE_PLUS("link.badge.plus"), + LINK_CIRCLE("link.circle"), + LINK_CIRCLE_FILL("link.circle.fill"), + LINK_ICLOUD("link.icloud"), + LINK_ICLOUD_FILL("link.icloud.fill"), + MAGNIFYINGGLASS("magnifyingglass"), + MAGNIFYINGGLASS_CIRCLE("magnifyingglass.circle"), + MAGNIFYINGGLASS_CIRCLE_FILL("magnifyingglass.circle.fill"), + MAP("map"), + MAP_CIRCLE("map.circle"), + MAP_CIRCLE_FILL("map.circle.fill"), + MAP_FILL("map.fill"), + MAPPIN("mappin"), + MAPPIN_AND_ELLIPSE("mappin.and.ellipse"), + MAPPIN_AND_ELLIPSE_CIRCLE("mappin.and.ellipse.circle"), + MAPPIN_AND_ELLIPSE_CIRCLE_FILL("mappin.and.ellipse.circle.fill"), + MAPPIN_CIRCLE("mappin.circle"), + MAPPIN_CIRCLE_FILL("mappin.circle.fill"), + MAPPIN_SLASH("mappin.slash"), + MAPPIN_SLASH_CIRCLE("mappin.slash.circle"), + MAPPIN_SLASH_CIRCLE_FILL("mappin.slash.circle.fill"), + MAPPIN_SQUARE("mappin.square"), + MAPPIN_SQUARE_FILL("mappin.square.fill"), + NEWSPAPER("newspaper"), + NEWSPAPER_CIRCLE("newspaper.circle"), + NEWSPAPER_CIRCLE_FILL("newspaper.circle.fill"), + NEWSPAPER_FILL("newspaper.fill"), + OVEN("oven"), + OVEN_FILL("oven.fill"), + PAINTBRUSH("paintbrush"), + PAINTBRUSH_FILL("paintbrush.fill"), + PAINTBRUSH_POINTED("paintbrush.pointed"), + PAINTBRUSH_POINTED_FILL("paintbrush.pointed.fill"), + PAPERCLIP("paperclip"), + PAPERCLIP_BADGE_ELLIPSIS("paperclip.badge.ellipsis"), + PAPERCLIP_CIRCLE("paperclip.circle"), + PAPERCLIP_CIRCLE_FILL("paperclip.circle.fill"), + PENCIL("pencil"), + PENCIL_AND_LIST_CLIPBOARD("pencil.and.list.clipboard"), + PENCIL_AND_OUTLINE("pencil.and.outline"), + PENCIL_AND_RULER("pencil.and.ruler"), + PENCIL_AND_RULER_FILL("pencil.and.ruler.fill"), + PENCIL_AND_SCRIBBLE("pencil.and.scribble"), + PENCIL_CIRCLE("pencil.circle"), + PENCIL_CIRCLE_FILL("pencil.circle.fill"), + PENCIL_LINE("pencil.line"), + PENCIL_SLASH("pencil.slash"), + PENCIL_TIP("pencil.tip"), + PENCIL_TIP_CROP_CIRCLE("pencil.tip.crop.circle"), + PENCIL_TIP_CROP_CIRCLE_BADGE_ARROW_FORWARD("pencil.tip.crop.circle.badge.arrow.forward"), + PENCIL_TIP_CROP_CIRCLE_BADGE_ARROW_FORWARD_FILL("pencil.tip.crop.circle.badge.arrow.forward.fill"), + PENCIL_TIP_CROP_CIRCLE_BADGE_MINUS("pencil.tip.crop.circle.badge.minus"), + PENCIL_TIP_CROP_CIRCLE_BADGE_MINUS_FILL("pencil.tip.crop.circle.badge.minus.fill"), + PENCIL_TIP_CROP_CIRCLE_BADGE_PLUS("pencil.tip.crop.circle.badge.plus"), + PENCIL_TIP_CROP_CIRCLE_BADGE_PLUS_FILL("pencil.tip.crop.circle.badge.plus.fill"), + PENCIL_TIP_CROP_CIRCLE_FILL("pencil.tip.crop.circle.fill"), + PILL("pill"), + PILL_CIRCLE("pill.circle"), + PILL_CIRCLE_FILL("pill.circle.fill"), + PILL_FILL("pill.fill"), + PILLS("pills"), + PILLS_CIRCLE("pills.circle"), + PILLS_CIRCLE_FILL("pills.circle.fill"), + PILLS_FILL("pills.fill"), + PIN("pin"), + PIN_CIRCLE("pin.circle"), + PIN_CIRCLE_FILL("pin.circle.fill"), + PIN_FILL("pin.fill"), + PIN_SLASH("pin.slash"), + PIN_SLASH_FILL("pin.slash.fill"), + PIN_SQUARE("pin.square"), + PIN_SQUARE_FILL("pin.square.fill"), + PIPE_AND_DROP("pipe.and.drop"), + PIPE_AND_DROP_FILL("pipe.and.drop.fill"), + REFRIGERATOR("refrigerator"), + REFRIGERATOR_FILL("refrigerator.fill"), + SCISSORS("scissors"), + SCISSORS_BADGE_ELLIPSIS("scissors.badge.ellipsis"), + SCISSORS_CIRCLE("scissors.circle"), + SCISSORS_CIRCLE_FILL("scissors.circle.fill"), + SCREWDRIVER("screwdriver"), + SCREWDRIVER_FILL("screwdriver.fill"), + SHOWER("shower"), + SHOWER_FILL("shower.fill"), + SHOWER_HANDHELD("shower.handheld"), + SHOWER_HANDHELD_FILL("shower.handheld.fill"), + SHOWER_SIDEJET("shower.sidejet"), + SHOWER_SIDEJET_FILL("shower.sidejet.fill"), + SINK("sink"), + SINK_FILL("sink.fill"), + SOFA("sofa"), + SOFA_FILL("sofa.fill"), + SPIGOT("spigot"), + SPIGOT_FILL("spigot.fill"), + STAIRS("stairs"), + SYRINGE("syringe"), + SYRINGE_FILL("syringe.fill"), + TABLE_FURNITURE("table.furniture"), + TABLE_FURNITURE_FILL("table.furniture.fill"), + TABLECELLS("tablecells"), + TABLECELLS_BADGE_ELLIPSIS("tablecells.badge.ellipsis"), + TABLECELLS_FILL("tablecells.fill"), + TABLECELLS_FILL_BADGE_ELLIPSIS("tablecells.fill.badge.ellipsis"), + TENT("tent"), + TENT_2("tent.2"), + TENT_2_CIRCLE("tent.2.circle"), + TENT_2_CIRCLE_FILL("tent.2.circle.fill"), + TENT_2_FILL("tent.2.fill"), + TENT_CIRCLE("tent.circle"), + TENT_CIRCLE_FILL("tent.circle.fill"), + TENT_FILL("tent.fill"), + TOILET("toilet"), + TOILET_CIRCLE("toilet.circle"), + TOILET_CIRCLE_FILL("toilet.circle.fill"), + TOILET_FILL("toilet.fill"), + TRASH("trash"), + TRASH_CIRCLE("trash.circle"), + TRASH_CIRCLE_FILL("trash.circle.fill"), + TRASH_FILL("trash.fill"), + TRASH_SLASH("trash.slash"), + TRASH_SLASH_CIRCLE("trash.slash.circle"), + TRASH_SLASH_CIRCLE_FILL("trash.slash.circle.fill"), + TRASH_SLASH_FILL("trash.slash.fill"), + TRASH_SLASH_SQUARE("trash.slash.square"), + TRASH_SLASH_SQUARE_FILL("trash.slash.square.fill"), + TRASH_SQUARE("trash.square"), + TRASH_SQUARE_FILL("trash.square.fill"), + WASHER("washer"), + WASHER_CIRCLE("washer.circle"), + WASHER_CIRCLE_FILL("washer.circle.fill"), + WASHER_FILL("washer.fill"), + WRENCH_ADJUSTABLE("wrench.adjustable"), + WRENCH_ADJUSTABLE_FILL("wrench.adjustable.fill"), + WRENCH_AND_SCREWDRIVER("wrench.and.screwdriver"), + WRENCH_AND_SCREWDRIVER_FILL("wrench.and.screwdriver.fill"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolPower.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolPower.kt new file mode 100644 index 00000000..b9f165d4 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolPower.kt @@ -0,0 +1,83 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Power (76 symbols). */ +enum class SFSymbolPower( + override val symbolName: String, +) : SFSymbol { + POWER("power"), + POWER_CIRCLE("power.circle"), + POWER_CIRCLE_FILL("power.circle.fill"), + POWER_DOTTED("power.dotted"), + POWERCORD("powercord"), + POWERCORD_FILL("powercord.fill"), + POWERMETER("powermeter"), + POWEROFF("poweroff"), + POWERON("poweron"), + POWEROUTLET_STRIP("poweroutlet.strip"), + POWEROUTLET_STRIP_FILL("poweroutlet.strip.fill"), + POWEROUTLET_TYPE_A("poweroutlet.type.a"), + POWEROUTLET_TYPE_A_FILL("poweroutlet.type.a.fill"), + POWEROUTLET_TYPE_A_SQUARE("poweroutlet.type.a.square"), + POWEROUTLET_TYPE_A_SQUARE_FILL("poweroutlet.type.a.square.fill"), + POWEROUTLET_TYPE_B("poweroutlet.type.b"), + POWEROUTLET_TYPE_B_FILL("poweroutlet.type.b.fill"), + POWEROUTLET_TYPE_B_SQUARE("poweroutlet.type.b.square"), + POWEROUTLET_TYPE_B_SQUARE_FILL("poweroutlet.type.b.square.fill"), + POWEROUTLET_TYPE_C("poweroutlet.type.c"), + POWEROUTLET_TYPE_C_FILL("poweroutlet.type.c.fill"), + POWEROUTLET_TYPE_C_SQUARE("poweroutlet.type.c.square"), + POWEROUTLET_TYPE_C_SQUARE_FILL("poweroutlet.type.c.square.fill"), + POWEROUTLET_TYPE_D("poweroutlet.type.d"), + POWEROUTLET_TYPE_D_FILL("poweroutlet.type.d.fill"), + POWEROUTLET_TYPE_D_SQUARE("poweroutlet.type.d.square"), + POWEROUTLET_TYPE_D_SQUARE_FILL("poweroutlet.type.d.square.fill"), + POWEROUTLET_TYPE_E("poweroutlet.type.e"), + POWEROUTLET_TYPE_E_FILL("poweroutlet.type.e.fill"), + POWEROUTLET_TYPE_E_SQUARE("poweroutlet.type.e.square"), + POWEROUTLET_TYPE_E_SQUARE_FILL("poweroutlet.type.e.square.fill"), + POWEROUTLET_TYPE_F("poweroutlet.type.f"), + POWEROUTLET_TYPE_F_FILL("poweroutlet.type.f.fill"), + POWEROUTLET_TYPE_F_SQUARE("poweroutlet.type.f.square"), + POWEROUTLET_TYPE_F_SQUARE_FILL("poweroutlet.type.f.square.fill"), + POWEROUTLET_TYPE_G("poweroutlet.type.g"), + POWEROUTLET_TYPE_G_FILL("poweroutlet.type.g.fill"), + POWEROUTLET_TYPE_G_SQUARE("poweroutlet.type.g.square"), + POWEROUTLET_TYPE_G_SQUARE_FILL("poweroutlet.type.g.square.fill"), + POWEROUTLET_TYPE_H("poweroutlet.type.h"), + POWEROUTLET_TYPE_H_FILL("poweroutlet.type.h.fill"), + POWEROUTLET_TYPE_H_SQUARE("poweroutlet.type.h.square"), + POWEROUTLET_TYPE_H_SQUARE_FILL("poweroutlet.type.h.square.fill"), + POWEROUTLET_TYPE_I("poweroutlet.type.i"), + POWEROUTLET_TYPE_I_FILL("poweroutlet.type.i.fill"), + POWEROUTLET_TYPE_I_SQUARE("poweroutlet.type.i.square"), + POWEROUTLET_TYPE_I_SQUARE_FILL("poweroutlet.type.i.square.fill"), + POWEROUTLET_TYPE_J("poweroutlet.type.j"), + POWEROUTLET_TYPE_J_FILL("poweroutlet.type.j.fill"), + POWEROUTLET_TYPE_J_SQUARE("poweroutlet.type.j.square"), + POWEROUTLET_TYPE_J_SQUARE_FILL("poweroutlet.type.j.square.fill"), + POWEROUTLET_TYPE_K("poweroutlet.type.k"), + POWEROUTLET_TYPE_K_FILL("poweroutlet.type.k.fill"), + POWEROUTLET_TYPE_K_SQUARE("poweroutlet.type.k.square"), + POWEROUTLET_TYPE_K_SQUARE_FILL("poweroutlet.type.k.square.fill"), + POWEROUTLET_TYPE_L("poweroutlet.type.l"), + POWEROUTLET_TYPE_L_FILL("poweroutlet.type.l.fill"), + POWEROUTLET_TYPE_L_SQUARE("poweroutlet.type.l.square"), + POWEROUTLET_TYPE_L_SQUARE_FILL("poweroutlet.type.l.square.fill"), + POWEROUTLET_TYPE_M("poweroutlet.type.m"), + POWEROUTLET_TYPE_M_FILL("poweroutlet.type.m.fill"), + POWEROUTLET_TYPE_M_SQUARE("poweroutlet.type.m.square"), + POWEROUTLET_TYPE_M_SQUARE_FILL("poweroutlet.type.m.square.fill"), + POWEROUTLET_TYPE_N("poweroutlet.type.n"), + POWEROUTLET_TYPE_N_FILL("poweroutlet.type.n.fill"), + POWEROUTLET_TYPE_N_SQUARE("poweroutlet.type.n.square"), + POWEROUTLET_TYPE_N_SQUARE_FILL("poweroutlet.type.n.square.fill"), + POWEROUTLET_TYPE_O("poweroutlet.type.o"), + POWEROUTLET_TYPE_O_FILL("poweroutlet.type.o.fill"), + POWEROUTLET_TYPE_O_SQUARE("poweroutlet.type.o.square"), + POWEROUTLET_TYPE_O_SQUARE_FILL("poweroutlet.type.o.square.fill"), + POWERPLUG("powerplug"), + POWERPLUG_FILL("powerplug.fill"), + POWERPLUG_PORTRAIT("powerplug.portrait"), + POWERPLUG_PORTRAIT_FILL("powerplug.portrait.fill"), + POWERSLEEP("powersleep"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolSecurity.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolSecurity.kt new file mode 100644 index 00000000..c30d8db3 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolSecurity.kt @@ -0,0 +1,69 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Security (62 symbols). */ +enum class SFSymbolSecurity( + override val symbolName: String, +) : SFSymbol { + KEY("key"), + KEY_2_ON_RING("key.2.on.ring"), + KEY_2_ON_RING_FILL("key.2.on.ring.fill"), + KEY_FILL("key.fill"), + KEY_HORIZONTAL("key.horizontal"), + KEY_HORIZONTAL_FILL("key.horizontal.fill"), + KEY_ICLOUD("key.icloud"), + KEY_ICLOUD_FILL("key.icloud.fill"), + KEY_RADIOWAVES_FORWARD("key.radiowaves.forward"), + KEY_RADIOWAVES_FORWARD_FILL("key.radiowaves.forward.fill"), + KEY_RADIOWAVES_FORWARD_SLASH("key.radiowaves.forward.slash"), + KEY_RADIOWAVES_FORWARD_SLASH_FILL("key.radiowaves.forward.slash.fill"), + KEY_SLASH("key.slash"), + KEY_SLASH_FILL("key.slash.fill"), + KEY_VIEWFINDER("key.viewfinder"), + LOCK("lock"), + LOCK_APP_DASHED("lock.app.dashed"), + LOCK_APPLEWATCH("lock.applewatch"), + LOCK_BADGE_CLOCK("lock.badge.clock"), + LOCK_BADGE_CLOCK_FILL("lock.badge.clock.fill"), + LOCK_CIRCLE("lock.circle"), + LOCK_CIRCLE_DOTTED("lock.circle.dotted"), + LOCK_CIRCLE_FILL("lock.circle.fill"), + LOCK_DESKTOPCOMPUTER("lock.desktopcomputer"), + LOCK_DISPLAY("lock.display"), + LOCK_DOCUMENT("lock.document"), + LOCK_DOCUMENT_FILL("lock.document.fill"), + LOCK_FILL("lock.fill"), + LOCK_ICLOUD("lock.icloud"), + LOCK_ICLOUD_FILL("lock.icloud.fill"), + LOCK_IPAD("lock.ipad"), + LOCK_IPHONE("lock.iphone"), + LOCK_LAPTOPCOMPUTER("lock.laptopcomputer"), + LOCK_OPEN("lock.open"), + LOCK_OPEN_APPLEWATCH("lock.open.applewatch"), + LOCK_OPEN_DESKTOPCOMPUTER("lock.open.desktopcomputer"), + LOCK_OPEN_DISPLAY("lock.open.display"), + LOCK_OPEN_FILL("lock.open.fill"), + LOCK_OPEN_IPAD("lock.open.ipad"), + LOCK_OPEN_IPHONE("lock.open.iphone"), + LOCK_OPEN_LAPTOPCOMPUTER("lock.open.laptopcomputer"), + LOCK_OPEN_ROTATION("lock.open.rotation"), + LOCK_OPEN_TRIANGLEBADGE_EXCLAMATIONMARK("lock.open.trianglebadge.exclamationmark"), + LOCK_OPEN_TRIANGLEBADGE_EXCLAMATIONMARK_FILL("lock.open.trianglebadge.exclamationmark.fill"), + LOCK_RECTANGLE("lock.rectangle"), + LOCK_RECTANGLE_FILL("lock.rectangle.fill"), + LOCK_RECTANGLE_ON_RECTANGLE("lock.rectangle.on.rectangle"), + LOCK_RECTANGLE_ON_RECTANGLE_DASHED("lock.rectangle.on.rectangle.dashed"), + LOCK_RECTANGLE_ON_RECTANGLE_FILL("lock.rectangle.on.rectangle.fill"), + LOCK_RECTANGLE_STACK("lock.rectangle.stack"), + LOCK_RECTANGLE_STACK_FILL("lock.rectangle.stack.fill"), + LOCK_ROTATION("lock.rotation"), + LOCK_SHIELD("lock.shield"), + LOCK_SHIELD_FILL("lock.shield.fill"), + LOCK_SLASH("lock.slash"), + LOCK_SLASH_FILL("lock.slash.fill"), + LOCK_SQUARE("lock.square"), + LOCK_SQUARE_FILL("lock.square.fill"), + LOCK_SQUARE_STACK("lock.square.stack"), + LOCK_SQUARE_STACK_FILL("lock.square.stack.fill"), + LOCK_TRIANGLEBADGE_EXCLAMATIONMARK("lock.trianglebadge.exclamationmark"), + LOCK_TRIANGLEBADGE_EXCLAMATIONMARK_FILL("lock.trianglebadge.exclamationmark.fill"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolShapes.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolShapes.kt new file mode 100644 index 00000000..f32671d2 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolShapes.kt @@ -0,0 +1,549 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Shapes (542 symbols). */ +enum class SFSymbolShapes( + override val symbolName: String, +) : SFSymbol { + APP("app"), + APP_BADGE("app.badge"), + APP_BADGE_CHECKMARK("app.badge.checkmark"), + APP_BADGE_CHECKMARK_FILL("app.badge.checkmark.fill"), + APP_BADGE_CLOCK("app.badge.clock"), + APP_BADGE_CLOCK_FILL("app.badge.clock.fill"), + APP_BADGE_FILL("app.badge.fill"), + APP_CONNECTED_TO_APP_BELOW_FILL("app.connected.to.app.below.fill"), + APP_DASHED("app.dashed"), + APP_FILL("app.fill"), + APP_GIFT("app.gift"), + APP_GIFT_FILL("app.gift.fill"), + APPCLIP("appclip"), + APPEND_PAGE("append.page"), + APPEND_PAGE_FILL("append.page.fill"), + APPS_IPAD("apps.ipad"), + APPS_IPAD_LANDSCAPE("apps.ipad.landscape"), + APPS_IPHONE("apps.iphone"), + APPS_IPHONE_BADGE_PLUS("apps.iphone.badge.plus"), + APPS_IPHONE_LANDSCAPE("apps.iphone.landscape"), + APPWINDOW_SWIPE_RECTANGLE("appwindow.swipe.rectangle"), + CAPSULE("capsule"), + CAPSULE_BOTTOMHALF_FILLED("capsule.bottomhalf.filled"), + CAPSULE_FILL("capsule.fill"), + CAPSULE_LEFTHALF_FILLED("capsule.lefthalf.filled"), + CAPSULE_ON_CAPSULE("capsule.on.capsule"), + CAPSULE_ON_CAPSULE_FILL("capsule.on.capsule.fill"), + CAPSULE_ON_RECTANGLE("capsule.on.rectangle"), + CAPSULE_ON_RECTANGLE_FILL("capsule.on.rectangle.fill"), + CAPSULE_PORTRAIT("capsule.portrait"), + CAPSULE_PORTRAIT_BOTTOMHALF_FILLED("capsule.portrait.bottomhalf.filled"), + CAPSULE_PORTRAIT_FILL("capsule.portrait.fill"), + CAPSULE_PORTRAIT_LEFTHALF_FILLED("capsule.portrait.lefthalf.filled"), + CAPSULE_PORTRAIT_RIGHTHALF_FILLED("capsule.portrait.righthalf.filled"), + CAPSULE_PORTRAIT_TOPHALF_FILLED("capsule.portrait.tophalf.filled"), + CAPSULE_RIGHTHALF_FILLED("capsule.righthalf.filled"), + CAPSULE_TOPHALF_FILLED("capsule.tophalf.filled"), + CIRCLE("circle"), + CIRCLE_AND_LINE_HORIZONTAL("circle.and.line.horizontal"), + CIRCLE_AND_LINE_HORIZONTAL_FILL("circle.and.line.horizontal.fill"), + CIRCLE_BADGE_CHECKMARK("circle.badge.checkmark"), + CIRCLE_BADGE_CHECKMARK_FILL("circle.badge.checkmark.fill"), + CIRCLE_BADGE_EXCLAMATIONMARK("circle.badge.exclamationmark"), + CIRCLE_BADGE_EXCLAMATIONMARK_FILL("circle.badge.exclamationmark.fill"), + CIRCLE_BADGE_MINUS("circle.badge.minus"), + CIRCLE_BADGE_MINUS_FILL("circle.badge.minus.fill"), + CIRCLE_BADGE_PLUS("circle.badge.plus"), + CIRCLE_BADGE_PLUS_FILL("circle.badge.plus.fill"), + CIRCLE_BADGE_QUESTIONMARK("circle.badge.questionmark"), + CIRCLE_BADGE_QUESTIONMARK_FILL("circle.badge.questionmark.fill"), + CIRCLE_BADGE_XMARK("circle.badge.xmark"), + CIRCLE_BADGE_XMARK_FILL("circle.badge.xmark.fill"), + CIRCLE_BOTTOMHALF_FILLED("circle.bottomhalf.filled"), + CIRCLE_BOTTOMHALF_FILLED_INVERSE("circle.bottomhalf.filled.inverse"), + CIRCLE_BOTTOMRIGHTHALF_PATTERN_CHECKERED("circle.bottomrighthalf.pattern.checkered"), + CIRCLE_CIRCLE("circle.circle"), + CIRCLE_CIRCLE_FILL("circle.circle.fill"), + CIRCLE_DASHED("circle.dashed"), + CIRCLE_DASHED_RECTANGLE("circle.dashed.rectangle"), + CIRCLE_DOTTED("circle.dotted"), + CIRCLE_DOTTED_AND_CIRCLE("circle.dotted.and.circle"), + CIRCLE_DOTTED_CIRCLE("circle.dotted.circle"), + CIRCLE_DOTTED_CIRCLE_FILL("circle.dotted.circle.fill"), + CIRCLE_FILL("circle.fill"), + CIRCLE_FILLED_IPAD("circle.filled.ipad"), + CIRCLE_FILLED_IPAD_FILL("circle.filled.ipad.fill"), + CIRCLE_FILLED_IPAD_LANDSCAPE("circle.filled.ipad.landscape"), + CIRCLE_FILLED_IPAD_LANDSCAPE_FILL("circle.filled.ipad.landscape.fill"), + CIRCLE_FILLED_IPHONE("circle.filled.iphone"), + CIRCLE_FILLED_IPHONE_FILL("circle.filled.iphone.fill"), + CIRCLE_FILLED_PATTERN_DIAGONALLINE_RECTANGLE("circle.filled.pattern.diagonalline.rectangle"), + CIRCLE_GRID_2X1("circle.grid.2x1"), + CIRCLE_GRID_2X1_FILL("circle.grid.2x1.fill"), + CIRCLE_GRID_2X1_LEFT_FILLED("circle.grid.2x1.left.filled"), + CIRCLE_GRID_2X1_RIGHT_FILLED("circle.grid.2x1.right.filled"), + CIRCLE_GRID_2X2("circle.grid.2x2"), + CIRCLE_GRID_2X2_FILL("circle.grid.2x2.fill"), + CIRCLE_GRID_3X3("circle.grid.3x3"), + CIRCLE_GRID_3X3_CIRCLE("circle.grid.3x3.circle"), + CIRCLE_GRID_3X3_CIRCLE_FILL("circle.grid.3x3.circle.fill"), + CIRCLE_GRID_3X3_FILL("circle.grid.3x3.fill"), + CIRCLE_GRID_CROSS("circle.grid.cross"), + CIRCLE_GRID_CROSS_DOWN_FILLED("circle.grid.cross.down.filled"), + CIRCLE_GRID_CROSS_FILL("circle.grid.cross.fill"), + CIRCLE_GRID_CROSS_LEFT_FILLED("circle.grid.cross.left.filled"), + CIRCLE_GRID_CROSS_RIGHT_FILLED("circle.grid.cross.right.filled"), + CIRCLE_GRID_CROSS_UP_FILLED("circle.grid.cross.up.filled"), + CIRCLE_HEXAGONGRID("circle.hexagongrid"), + CIRCLE_HEXAGONGRID_CIRCLE("circle.hexagongrid.circle"), + CIRCLE_HEXAGONGRID_CIRCLE_FILL("circle.hexagongrid.circle.fill"), + CIRCLE_HEXAGONGRID_FILL("circle.hexagongrid.fill"), + CIRCLE_HEXAGONPATH("circle.hexagonpath"), + CIRCLE_HEXAGONPATH_FILL("circle.hexagonpath.fill"), + CIRCLE_LEFTHALF_FILLED("circle.lefthalf.filled"), + CIRCLE_LEFTHALF_FILLED_INVERSE("circle.lefthalf.filled.inverse"), + CIRCLE_LEFTHALF_FILLED_RIGHTHALF_STRIPED_HORIZONTAL("circle.lefthalf.filled.righthalf.striped.horizontal"), + CIRCLE_LEFTHALF_FILLED_RIGHTHALF_STRIPED_HORIZONTAL_INVERSE("circle.lefthalf.filled.righthalf.striped.horizontal.inverse"), + CIRCLE_LEFTHALF_STRIPED_HORIZONTAL("circle.lefthalf.striped.horizontal"), + CIRCLE_LEFTHALF_STRIPED_HORIZONTAL_INVERSE("circle.lefthalf.striped.horizontal.inverse"), + CIRCLE_RECTANGLE_DASHED("circle.rectangle.dashed"), + CIRCLE_RECTANGLE_FILLED_PATTERN_DIAGONALLINE("circle.rectangle.filled.pattern.diagonalline"), + CIRCLE_RIGHTHALF_FILLED("circle.righthalf.filled"), + CIRCLE_RIGHTHALF_FILLED_INVERSE("circle.righthalf.filled.inverse"), + CIRCLE_SLASH("circle.slash"), + CIRCLE_SLASH_FILL("circle.slash.fill"), + CIRCLE_SQUARE("circle.square"), + CIRCLE_SQUARE_FILL("circle.square.fill"), + CIRCLE_TOPHALF_FILLED("circle.tophalf.filled"), + CIRCLE_TOPHALF_FILLED_INVERSE("circle.tophalf.filled.inverse"), + CIRCLEBADGE("circlebadge"), + CIRCLEBADGE_2("circlebadge.2"), + CIRCLEBADGE_2_FILL("circlebadge.2.fill"), + CIRCLEBADGE_FILL("circlebadge.fill"), + DIAMOND("diamond"), + DIAMOND_BOTTOMHALF_FILLED("diamond.bottomhalf.filled"), + DIAMOND_CIRCLE("diamond.circle"), + DIAMOND_CIRCLE_FILL("diamond.circle.fill"), + DIAMOND_FILL("diamond.fill"), + DIAMOND_LEFTHALF_FILLED("diamond.lefthalf.filled"), + DIAMOND_RIGHTHALF_FILLED("diamond.righthalf.filled"), + DIAMOND_TOPHALF_FILLED("diamond.tophalf.filled"), + HEXAGON("hexagon"), + HEXAGON_BOTTOMHALF_FILLED("hexagon.bottomhalf.filled"), + HEXAGON_FILL("hexagon.fill"), + HEXAGON_LEFTHALF_FILLED("hexagon.lefthalf.filled"), + HEXAGON_RIGHTHALF_FILLED("hexagon.righthalf.filled"), + HEXAGON_TOPHALF_FILLED("hexagon.tophalf.filled"), + INSET_FILLED_APPLEWATCH_CASE("inset.filled.applewatch.case"), + INSET_FILLED_BOTTOMHALF_RECTANGLE("inset.filled.bottomhalf.rectangle"), + INSET_FILLED_BOTTOMHALF_RECTANGLE_PORTRAIT("inset.filled.bottomhalf.rectangle.portrait"), + INSET_FILLED_BOTTOMHALF_TOPHALF_RECTANGLE("inset.filled.bottomhalf.tophalf.rectangle"), + INSET_FILLED_BOTTOMLEADING_RECTANGLE("inset.filled.bottomleading.rectangle"), + INSET_FILLED_BOTTOMLEADING_RECTANGLE_PORTRAIT("inset.filled.bottomleading.rectangle.portrait"), + INSET_FILLED_BOTTOMLEFT_RECTANGLE("inset.filled.bottomleft.rectangle"), + INSET_FILLED_BOTTOMLEFT_RECTANGLE_PORTRAIT("inset.filled.bottomleft.rectangle.portrait"), + INSET_FILLED_BOTTOMRIGHT_RECTANGLE("inset.filled.bottomright.rectangle"), + INSET_FILLED_BOTTOMRIGHT_RECTANGLE_PORTRAIT("inset.filled.bottomright.rectangle.portrait"), + INSET_FILLED_BOTTOMTHIRD_RECTANGLE("inset.filled.bottomthird.rectangle"), + INSET_FILLED_BOTTOMTHIRD_RECTANGLE_PORTRAIT("inset.filled.bottomthird.rectangle.portrait"), + INSET_FILLED_BOTTOMTHIRD_SQUARE("inset.filled.bottomthird.square"), + INSET_FILLED_BOTTOMTRAILING_RECTANGLE("inset.filled.bottomtrailing.rectangle"), + INSET_FILLED_BOTTOMTRAILING_RECTANGLE_PORTRAIT("inset.filled.bottomtrailing.rectangle.portrait"), + INSET_FILLED_CAPSULE("inset.filled.capsule"), + INSET_FILLED_CAPSULE_PORTRAIT("inset.filled.capsule.portrait"), + INSET_FILLED_CENTER_RECTANGLE("inset.filled.center.rectangle"), + INSET_FILLED_CENTER_RECTANGLE_BADGE_PLUS("inset.filled.center.rectangle.badge.plus"), + INSET_FILLED_CENTER_RECTANGLE_PORTRAIT("inset.filled.center.rectangle.portrait"), + INSET_FILLED_CIRCLE("inset.filled.circle"), + INSET_FILLED_CIRCLE_DASHED("inset.filled.circle.dashed"), + INSET_FILLED_DIAMOND("inset.filled.diamond"), + INSET_FILLED_LEADINGHALF_ARROW_LEADING_RECTANGLE("inset.filled.leadinghalf.arrow.leading.rectangle"), + INSET_FILLED_LEADINGHALF_RECTANGLE("inset.filled.leadinghalf.rectangle"), + INSET_FILLED_LEADINGHALF_RECTANGLE_PORTRAIT("inset.filled.leadinghalf.rectangle.portrait"), + INSET_FILLED_LEADINGHALF_TOPTRAILING_BOTTOMTRAILING_RECTANGLE("inset.filled.leadinghalf.toptrailing.bottomtrailing.rectangle"), + INSET_FILLED_LEADINGHALF_TRAILINGHALF_RECTANGLE("inset.filled.leadinghalf.trailinghalf.rectangle"), + INSET_FILLED_LEADINGTHIRD_RECTANGLE("inset.filled.leadingthird.rectangle"), + INSET_FILLED_LEADINGTHIRD_RECTANGLE_PORTRAIT("inset.filled.leadingthird.rectangle.portrait"), + INSET_FILLED_LEADINGTHIRD_SQUARE("inset.filled.leadingthird.square"), + INSET_FILLED_LEFTHALF_ARROW_LEFT_RECTANGLE("inset.filled.lefthalf.arrow.left.rectangle"), + INSET_FILLED_LEFTHALF_RECTANGLE("inset.filled.lefthalf.rectangle"), + INSET_FILLED_LEFTHALF_RECTANGLE_PORTRAIT("inset.filled.lefthalf.rectangle.portrait"), + INSET_FILLED_LEFTHALF_RIGHTHALF_RECTANGLE("inset.filled.lefthalf.righthalf.rectangle"), + INSET_FILLED_LEFTHALF_TOPRIGHT_BOTTOMRIGHT_RECTANGLE("inset.filled.lefthalf.topright.bottomright.rectangle"), + INSET_FILLED_LEFTTHIRD_RECTANGLE("inset.filled.leftthird.rectangle"), + INSET_FILLED_LEFTTHIRD_RECTANGLE_PORTRAIT("inset.filled.leftthird.rectangle.portrait"), + INSET_FILLED_LEFTTHIRD_SQUARE("inset.filled.leftthird.square"), + INSET_FILLED_OVAL("inset.filled.oval"), + INSET_FILLED_OVAL_PORTRAIT("inset.filled.oval.portrait"), + INSET_FILLED_RECTANGLE("inset.filled.rectangle"), + INSET_FILLED_RECTANGLE_AND_CURSORARROW("inset.filled.rectangle.and.cursorarrow"), + INSET_FILLED_RECTANGLE_AND_PERSON_FILLED("inset.filled.rectangle.and.person.filled"), + INSET_FILLED_RECTANGLE_BADGE_RECORD("inset.filled.rectangle.badge.record"), + INSET_FILLED_RECTANGLE_ON_RECTANGLE("inset.filled.rectangle.on.rectangle"), + INSET_FILLED_RECTANGLE_PORTRAIT("inset.filled.rectangle.portrait"), + INSET_FILLED_RIGHTHALF_ARROW_RIGHT_RECTANGLE("inset.filled.righthalf.arrow.right.rectangle"), + INSET_FILLED_RIGHTHALF_LEFTHALF_RECTANGLE("inset.filled.righthalf.lefthalf.rectangle"), + INSET_FILLED_RIGHTHALF_RECTANGLE("inset.filled.righthalf.rectangle"), + INSET_FILLED_RIGHTHALF_RECTANGLE_PORTRAIT("inset.filled.righthalf.rectangle.portrait"), + INSET_FILLED_RIGHTTHIRD_RECTANGLE("inset.filled.rightthird.rectangle"), + INSET_FILLED_RIGHTTHIRD_RECTANGLE_PORTRAIT("inset.filled.rightthird.rectangle.portrait"), + INSET_FILLED_RIGHTTHIRD_SQUARE("inset.filled.rightthird.square"), + INSET_FILLED_SQUARE("inset.filled.square"), + INSET_FILLED_SQUARE_DASHED("inset.filled.square.dashed"), + INSET_FILLED_TOPHALF_BOTTOMHALF_RECTANGLE("inset.filled.tophalf.bottomhalf.rectangle"), + INSET_FILLED_TOPHALF_BOTTOMLEFT_BOTTOMRIGHT_RECTANGLE("inset.filled.tophalf.bottomleft.bottomright.rectangle"), + INSET_FILLED_TOPHALF_RECTANGLE("inset.filled.tophalf.rectangle"), + INSET_FILLED_TOPHALF_RECTANGLE_PORTRAIT("inset.filled.tophalf.rectangle.portrait"), + INSET_FILLED_TOPLEADING_BOTTOMLEADING_TRAILINGHALF_RECTANGLE("inset.filled.topleading.bottomleading.trailinghalf.rectangle"), + INSET_FILLED_TOPLEADING_RECTANGLE("inset.filled.topleading.rectangle"), + INSET_FILLED_TOPLEADING_RECTANGLE_PORTRAIT("inset.filled.topleading.rectangle.portrait"), + INSET_FILLED_TOPLEFT_BOTTOMLEFT_RIGHTHALF_RECTANGLE("inset.filled.topleft.bottomleft.righthalf.rectangle"), + INSET_FILLED_TOPLEFT_RECTANGLE("inset.filled.topleft.rectangle"), + INSET_FILLED_TOPLEFT_RECTANGLE_PORTRAIT("inset.filled.topleft.rectangle.portrait"), + INSET_FILLED_TOPLEFT_TOPRIGHT_BOTTOMHALF_RECTANGLE("inset.filled.topleft.topright.bottomhalf.rectangle"), + INSET_FILLED_TOPLEFT_TOPRIGHT_BOTTOMLEFT_BOTTOMRIGHT_RECTANGLE("inset.filled.topleft.topright.bottomleft.bottomright.rectangle"), + INSET_FILLED_TOPRIGHT_RECTANGLE("inset.filled.topright.rectangle"), + INSET_FILLED_TOPRIGHT_RECTANGLE_PORTRAIT("inset.filled.topright.rectangle.portrait"), + INSET_FILLED_TOPTHIRD_RECTANGLE("inset.filled.topthird.rectangle"), + INSET_FILLED_TOPTHIRD_RECTANGLE_PORTRAIT("inset.filled.topthird.rectangle.portrait"), + INSET_FILLED_TOPTHIRD_SQUARE("inset.filled.topthird.square"), + INSET_FILLED_TOPTRAILING_RECTANGLE("inset.filled.toptrailing.rectangle"), + INSET_FILLED_TOPTRAILING_RECTANGLE_PORTRAIT("inset.filled.toptrailing.rectangle.portrait"), + INSET_FILLED_TRAILINGHALF_ARROW_TRAILING_RECTANGLE("inset.filled.trailinghalf.arrow.trailing.rectangle"), + INSET_FILLED_TRAILINGHALF_LEADINGHALF_RECTANGLE("inset.filled.trailinghalf.leadinghalf.rectangle"), + INSET_FILLED_TRAILINGHALF_RECTANGLE("inset.filled.trailinghalf.rectangle"), + INSET_FILLED_TRAILINGHALF_RECTANGLE_PORTRAIT("inset.filled.trailinghalf.rectangle.portrait"), + INSET_FILLED_TRAILINGTHIRD_RECTANGLE("inset.filled.trailingthird.rectangle"), + INSET_FILLED_TRAILINGTHIRD_RECTANGLE_PORTRAIT("inset.filled.trailingthird.rectangle.portrait"), + INSET_FILLED_TRAILINGTHIRD_SQUARE("inset.filled.trailingthird.square"), + INSET_FILLED_TRIANGLE("inset.filled.triangle"), + INSET_FILLED_TV("inset.filled.tv"), + OCTAGON("octagon"), + OCTAGON_BOTTOMHALF_FILLED("octagon.bottomhalf.filled"), + OCTAGON_FILL("octagon.fill"), + OCTAGON_LEFTHALF_FILLED("octagon.lefthalf.filled"), + OCTAGON_RIGHTHALF_FILLED("octagon.righthalf.filled"), + OCTAGON_TOPHALF_FILLED("octagon.tophalf.filled"), + OVAL("oval"), + OVAL_BOTTOMHALF_FILLED("oval.bottomhalf.filled"), + OVAL_FILL("oval.fill"), + OVAL_LEFTHALF_FILLED("oval.lefthalf.filled"), + OVAL_PORTRAIT("oval.portrait"), + OVAL_PORTRAIT_BOTTOMHALF_FILLED("oval.portrait.bottomhalf.filled"), + OVAL_PORTRAIT_FILL("oval.portrait.fill"), + OVAL_PORTRAIT_LEFTHALF_FILLED("oval.portrait.lefthalf.filled"), + OVAL_PORTRAIT_RIGHTHALF_FILLED("oval.portrait.righthalf.filled"), + OVAL_PORTRAIT_TOPHALF_FILLED("oval.portrait.tophalf.filled"), + OVAL_RIGHTHALF_FILLED("oval.righthalf.filled"), + OVAL_TOPHALF_FILLED("oval.tophalf.filled"), + PENTAGON("pentagon"), + PENTAGON_BOTTOMHALF_FILLED("pentagon.bottomhalf.filled"), + PENTAGON_FILL("pentagon.fill"), + PENTAGON_LEFTHALF_FILLED("pentagon.lefthalf.filled"), + PENTAGON_RIGHTHALF_FILLED("pentagon.righthalf.filled"), + PENTAGON_TOPHALF_FILLED("pentagon.tophalf.filled"), + RECTANGLE("rectangle"), + RECTANGLE_2_SWAP("rectangle.2.swap"), + RECTANGLE_3_GROUP("rectangle.3.group"), + RECTANGLE_3_GROUP_BUBBLE("rectangle.3.group.bubble"), + RECTANGLE_3_GROUP_BUBBLE_FILL("rectangle.3.group.bubble.fill"), + RECTANGLE_3_GROUP_FILL("rectangle.3.group.fill"), + RECTANGLE_AND_ARROW_UP_RIGHT_AND_ARROW_DOWN_LEFT("rectangle.and.arrow.up.right.and.arrow.down.left"), + RECTANGLE_AND_ARROW_UP_RIGHT_AND_ARROW_DOWN_LEFT_SLASH("rectangle.and.arrow.up.right.and.arrow.down.left.slash"), + RECTANGLE_AND_HAND_POINT_UP_LEFT("rectangle.and.hand.point.up.left"), + RECTANGLE_AND_HAND_POINT_UP_LEFT_FILL("rectangle.and.hand.point.up.left.fill"), + RECTANGLE_AND_HAND_POINT_UP_LEFT_FILLED("rectangle.and.hand.point.up.left.filled"), + RECTANGLE_AND_PAPERCLIP("rectangle.and.paperclip"), + RECTANGLE_AND_PENCIL_AND_ELLIPSIS("rectangle.and.pencil.and.ellipsis"), + RECTANGLE_AND_TEXT_MAGNIFYINGGLASS("rectangle.and.text.magnifyingglass"), + RECTANGLE_ARROWTRIANGLE_2_INWARD("rectangle.arrowtriangle.2.inward"), + RECTANGLE_ARROWTRIANGLE_2_OUTWARD("rectangle.arrowtriangle.2.outward"), + RECTANGLE_BADGE_CHECKMARK("rectangle.badge.checkmark"), + RECTANGLE_BADGE_MINUS("rectangle.badge.minus"), + RECTANGLE_BADGE_PERSON_CROP("rectangle.badge.person.crop"), + RECTANGLE_BADGE_PLUS("rectangle.badge.plus"), + RECTANGLE_BADGE_XMARK("rectangle.badge.xmark"), + RECTANGLE_BOTTOMHALF_FILLED("rectangle.bottomhalf.filled"), + RECTANGLE_COMPRESS_VERTICAL("rectangle.compress.vertical"), + RECTANGLE_CONNECTED_TO_LINE_BELOW("rectangle.connected.to.line.below"), + RECTANGLE_DASHED("rectangle.dashed"), + RECTANGLE_DASHED_AND_PAPERCLIP("rectangle.dashed.and.paperclip"), + RECTANGLE_DASHED_BADGE_RECORD("rectangle.dashed.badge.record"), + RECTANGLE_EXPAND_VERTICAL("rectangle.expand.vertical"), + RECTANGLE_FILL("rectangle.fill"), + RECTANGLE_FILL_BADGE_CHECKMARK("rectangle.fill.badge.checkmark"), + RECTANGLE_FILL_BADGE_MINUS("rectangle.fill.badge.minus"), + RECTANGLE_FILL_BADGE_PERSON_CROP("rectangle.fill.badge.person.crop"), + RECTANGLE_FILL_BADGE_PLUS("rectangle.fill.badge.plus"), + RECTANGLE_FILL_BADGE_XMARK("rectangle.fill.badge.xmark"), + RECTANGLE_FILL_ON_RECTANGLE_ANGLED_FILL("rectangle.fill.on.rectangle.angled.fill"), + RECTANGLE_FILL_ON_RECTANGLE_FILL("rectangle.fill.on.rectangle.fill"), + RECTANGLE_FILLED_AND_HAND_POINT_UP_LEFT("rectangle.filled.and.hand.point.up.left"), + RECTANGLE_GRID_1X2("rectangle.grid.1x2"), + RECTANGLE_GRID_1X2_FILL("rectangle.grid.1x2.fill"), + RECTANGLE_GRID_2X2("rectangle.grid.2x2"), + RECTANGLE_GRID_2X2_FILL("rectangle.grid.2x2.fill"), + RECTANGLE_GRID_3X2("rectangle.grid.3x2"), + RECTANGLE_GRID_3X2_FILL("rectangle.grid.3x2.fill"), + RECTANGLE_GRID_3X3("rectangle.grid.3x3"), + RECTANGLE_GRID_3X3_FILL("rectangle.grid.3x3.fill"), + RECTANGLE_LANDSCAPE_ROTATE("rectangle.landscape.rotate"), + RECTANGLE_LEADINGHALF_FILLED("rectangle.leadinghalf.filled"), + RECTANGLE_LEFTHALF_FILLED("rectangle.lefthalf.filled"), + RECTANGLE_ON_RECTANGLE("rectangle.on.rectangle"), + RECTANGLE_ON_RECTANGLE_ANGLED("rectangle.on.rectangle.angled"), + RECTANGLE_ON_RECTANGLE_BADGE_GEARSHAPE("rectangle.on.rectangle.badge.gearshape"), + RECTANGLE_ON_RECTANGLE_BUTTON_ANGLEDTOP_VERTICAL_LEFT("rectangle.on.rectangle.button.angledtop.vertical.left"), + RECTANGLE_ON_RECTANGLE_BUTTON_ANGLEDTOP_VERTICAL_LEFT_FILL("rectangle.on.rectangle.button.angledtop.vertical.left.fill"), + RECTANGLE_ON_RECTANGLE_CIRCLE("rectangle.on.rectangle.circle"), + RECTANGLE_ON_RECTANGLE_CIRCLE_FILL("rectangle.on.rectangle.circle.fill"), + RECTANGLE_ON_RECTANGLE_DASHED("rectangle.on.rectangle.dashed"), + RECTANGLE_ON_RECTANGLE_SLASH("rectangle.on.rectangle.slash"), + RECTANGLE_ON_RECTANGLE_SLASH_CIRCLE("rectangle.on.rectangle.slash.circle"), + RECTANGLE_ON_RECTANGLE_SLASH_CIRCLE_FILL("rectangle.on.rectangle.slash.circle.fill"), + RECTANGLE_ON_RECTANGLE_SLASH_FILL("rectangle.on.rectangle.slash.fill"), + RECTANGLE_ON_RECTANGLE_SQUARE("rectangle.on.rectangle.square"), + RECTANGLE_ON_RECTANGLE_SQUARE_FILL("rectangle.on.rectangle.square.fill"), + RECTANGLE_PATTERN_CHECKERED("rectangle.pattern.checkered"), + RECTANGLE_PORTRAIT("rectangle.portrait"), + RECTANGLE_PORTRAIT_AND_ARROW_FORWARD("rectangle.portrait.and.arrow.forward"), + RECTANGLE_PORTRAIT_AND_ARROW_FORWARD_FILL("rectangle.portrait.and.arrow.forward.fill"), + RECTANGLE_PORTRAIT_AND_ARROW_RIGHT("rectangle.portrait.and.arrow.right"), + RECTANGLE_PORTRAIT_AND_ARROW_RIGHT_FILL("rectangle.portrait.and.arrow.right.fill"), + RECTANGLE_PORTRAIT_ARROWTRIANGLE_2_INWARD("rectangle.portrait.arrowtriangle.2.inward"), + RECTANGLE_PORTRAIT_ARROWTRIANGLE_2_OUTWARD("rectangle.portrait.arrowtriangle.2.outward"), + RECTANGLE_PORTRAIT_BADGE_PLUS("rectangle.portrait.badge.plus"), + RECTANGLE_PORTRAIT_BADGE_PLUS_FILL("rectangle.portrait.badge.plus.fill"), + RECTANGLE_PORTRAIT_BOTTOMHALF_FILLED("rectangle.portrait.bottomhalf.filled"), + RECTANGLE_PORTRAIT_FILL("rectangle.portrait.fill"), + RECTANGLE_PORTRAIT_LEFTHALF_FILLED("rectangle.portrait.lefthalf.filled"), + RECTANGLE_PORTRAIT_ON_RECTANGLE_PORTRAIT("rectangle.portrait.on.rectangle.portrait"), + RECTANGLE_PORTRAIT_ON_RECTANGLE_PORTRAIT_ANGLED("rectangle.portrait.on.rectangle.portrait.angled"), + RECTANGLE_PORTRAIT_ON_RECTANGLE_PORTRAIT_ANGLED_FILL("rectangle.portrait.on.rectangle.portrait.angled.fill"), + RECTANGLE_PORTRAIT_ON_RECTANGLE_PORTRAIT_FILL("rectangle.portrait.on.rectangle.portrait.fill"), + RECTANGLE_PORTRAIT_ON_RECTANGLE_PORTRAIT_SLASH("rectangle.portrait.on.rectangle.portrait.slash"), + RECTANGLE_PORTRAIT_ON_RECTANGLE_PORTRAIT_SLASH_FILL("rectangle.portrait.on.rectangle.portrait.slash.fill"), + RECTANGLE_PORTRAIT_RIGHTHALF_FILLED("rectangle.portrait.righthalf.filled"), + RECTANGLE_PORTRAIT_ROTATE("rectangle.portrait.rotate"), + RECTANGLE_PORTRAIT_SLASH("rectangle.portrait.slash"), + RECTANGLE_PORTRAIT_SLASH_FILL("rectangle.portrait.slash.fill"), + RECTANGLE_PORTRAIT_SPLIT_2X1("rectangle.portrait.split.2x1"), + RECTANGLE_PORTRAIT_SPLIT_2X1_FILL("rectangle.portrait.split.2x1.fill"), + RECTANGLE_PORTRAIT_SPLIT_2X1_SLASH("rectangle.portrait.split.2x1.slash"), + RECTANGLE_PORTRAIT_SPLIT_2X1_SLASH_FILL("rectangle.portrait.split.2x1.slash.fill"), + RECTANGLE_PORTRAIT_TOPHALF_FILLED("rectangle.portrait.tophalf.filled"), + RECTANGLE_RATIO_3_TO_4("rectangle.ratio.3.to.4"), + RECTANGLE_RATIO_3_TO_4_FILL("rectangle.ratio.3.to.4.fill"), + RECTANGLE_RATIO_4_TO_3("rectangle.ratio.4.to.3"), + RECTANGLE_RATIO_4_TO_3_FILL("rectangle.ratio.4.to.3.fill"), + RECTANGLE_RATIO_9_TO_16("rectangle.ratio.9.to.16"), + RECTANGLE_RATIO_9_TO_16_FILL("rectangle.ratio.9.to.16.fill"), + RECTANGLE_RATIO_16_TO_9("rectangle.ratio.16.to.9"), + RECTANGLE_RATIO_16_TO_9_FILL("rectangle.ratio.16.to.9.fill"), + RECTANGLE_RIGHTHALF_FILLED("rectangle.righthalf.filled"), + RECTANGLE_SLASH("rectangle.slash"), + RECTANGLE_SLASH_FILL("rectangle.slash.fill"), + RECTANGLE_SPLIT_1X2("rectangle.split.1x2"), + RECTANGLE_SPLIT_1X2_FILL("rectangle.split.1x2.fill"), + RECTANGLE_SPLIT_2X1("rectangle.split.2x1"), + RECTANGLE_SPLIT_2X1_FILL("rectangle.split.2x1.fill"), + RECTANGLE_SPLIT_2X1_SLASH("rectangle.split.2x1.slash"), + RECTANGLE_SPLIT_2X1_SLASH_FILL("rectangle.split.2x1.slash.fill"), + RECTANGLE_SPLIT_2X2("rectangle.split.2x2"), + RECTANGLE_SPLIT_2X2_FILL("rectangle.split.2x2.fill"), + RECTANGLE_SPLIT_3X1("rectangle.split.3x1"), + RECTANGLE_SPLIT_3X1_FILL("rectangle.split.3x1.fill"), + RECTANGLE_SPLIT_3X3("rectangle.split.3x3"), + RECTANGLE_SPLIT_3X3_FILL("rectangle.split.3x3.fill"), + RECTANGLE_STACK("rectangle.stack"), + RECTANGLE_STACK_BADGE_MINUS("rectangle.stack.badge.minus"), + RECTANGLE_STACK_BADGE_PERSON_CROP("rectangle.stack.badge.person.crop"), + RECTANGLE_STACK_BADGE_PERSON_CROP_FILL("rectangle.stack.badge.person.crop.fill"), + RECTANGLE_STACK_BADGE_PLAY("rectangle.stack.badge.play"), + RECTANGLE_STACK_BADGE_PLAY_FILL("rectangle.stack.badge.play.fill"), + RECTANGLE_STACK_BADGE_PLUS("rectangle.stack.badge.plus"), + RECTANGLE_STACK_FILL("rectangle.stack.fill"), + RECTANGLE_STACK_FILL_BADGE_MINUS("rectangle.stack.fill.badge.minus"), + RECTANGLE_STACK_FILL_BADGE_PLUS("rectangle.stack.fill.badge.plus"), + RECTANGLE_TOPHALF_FILLED("rectangle.tophalf.filled"), + RECTANGLE_TRAILINGHALF_FILLED("rectangle.trailinghalf.filled"), + RHOMBUS("rhombus"), + RHOMBUS_FILL("rhombus.fill"), + SEAL("seal"), + SEAL_FILL("seal.fill"), + SHIELD("shield"), + SHIELD_FILL("shield.fill"), + SHIELD_LEFTHALF_FILLED("shield.lefthalf.filled"), + SHIELD_LEFTHALF_FILLED_BADGE_CHECKMARK("shield.lefthalf.filled.badge.checkmark"), + SHIELD_LEFTHALF_FILLED_SLASH("shield.lefthalf.filled.slash"), + SHIELD_LEFTHALF_FILLED_TRIANGLEBADGE_EXCLAMATIONMARK("shield.lefthalf.filled.trianglebadge.exclamationmark"), + SHIELD_PATTERN_CHECKERED("shield.pattern.checkered"), + SHIELD_RIGHTHALF_FILLED("shield.righthalf.filled"), + SHIELD_SLASH("shield.slash"), + SHIELD_SLASH_FILL("shield.slash.fill"), + SQUARE("square"), + SQUARE_2_LAYERS_3D("square.2.layers.3d"), + SQUARE_2_LAYERS_3D_BOTTOM_FILLED("square.2.layers.3d.bottom.filled"), + SQUARE_2_LAYERS_3D_FILL("square.2.layers.3d.fill"), + SQUARE_2_LAYERS_3D_TOP_FILLED("square.2.layers.3d.top.filled"), + SQUARE_3_LAYERS_3D("square.3.layers.3d"), + SQUARE_3_LAYERS_3D_BOTTOM_FILLED("square.3.layers.3d.bottom.filled"), + SQUARE_3_LAYERS_3D_DOWN_BACKWARD("square.3.layers.3d.down.backward"), + SQUARE_3_LAYERS_3D_DOWN_FORWARD("square.3.layers.3d.down.forward"), + SQUARE_3_LAYERS_3D_DOWN_LEFT("square.3.layers.3d.down.left"), + SQUARE_3_LAYERS_3D_DOWN_LEFT_SLASH("square.3.layers.3d.down.left.slash"), + SQUARE_3_LAYERS_3D_DOWN_RIGHT("square.3.layers.3d.down.right"), + SQUARE_3_LAYERS_3D_DOWN_RIGHT_SLASH("square.3.layers.3d.down.right.slash"), + SQUARE_3_LAYERS_3D_MIDDLE_FILLED("square.3.layers.3d.middle.filled"), + SQUARE_3_LAYERS_3D_SLASH("square.3.layers.3d.slash"), + SQUARE_3_LAYERS_3D_TOP_FILLED("square.3.layers.3d.top.filled"), + SQUARE_AND_ARROW_DOWN("square.and.arrow.down"), + SQUARE_AND_ARROW_DOWN_FILL("square.and.arrow.down.fill"), + SQUARE_AND_ARROW_DOWN_ON_SQUARE("square.and.arrow.down.on.square"), + SQUARE_AND_ARROW_DOWN_ON_SQUARE_FILL("square.and.arrow.down.on.square.fill"), + SQUARE_AND_ARROW_UP("square.and.arrow.up"), + SQUARE_AND_ARROW_UP_BADGE_CLOCK("square.and.arrow.up.badge.clock"), + SQUARE_AND_ARROW_UP_BADGE_CLOCK_FILL("square.and.arrow.up.badge.clock.fill"), + SQUARE_AND_ARROW_UP_CIRCLE("square.and.arrow.up.circle"), + SQUARE_AND_ARROW_UP_CIRCLE_FILL("square.and.arrow.up.circle.fill"), + SQUARE_AND_ARROW_UP_FILL("square.and.arrow.up.fill"), + SQUARE_AND_ARROW_UP_ON_SQUARE("square.and.arrow.up.on.square"), + SQUARE_AND_ARROW_UP_ON_SQUARE_FILL("square.and.arrow.up.on.square.fill"), + SQUARE_AND_ARROW_UP_TRIANGLEBADGE_EXCLAMATIONMARK("square.and.arrow.up.trianglebadge.exclamationmark"), + SQUARE_AND_ARROW_UP_TRIANGLEBADGE_EXCLAMATIONMARK_FILL("square.and.arrow.up.trianglebadge.exclamationmark.fill"), + SQUARE_AND_AT_RECTANGLE("square.and.at.rectangle"), + SQUARE_AND_AT_RECTANGLE_FILL("square.and.at.rectangle.fill"), + SQUARE_AND_LINE_VERTICAL_AND_SQUARE("square.and.line.vertical.and.square"), + SQUARE_AND_LINE_VERTICAL_AND_SQUARE_FILLED("square.and.line.vertical.and.square.filled"), + SQUARE_AND_PENCIL("square.and.pencil"), + SQUARE_AND_PENCIL_CIRCLE("square.and.pencil.circle"), + SQUARE_AND_PENCIL_CIRCLE_FILL("square.and.pencil.circle.fill"), + SQUARE_ARROWTRIANGLE_4_OUTWARD("square.arrowtriangle.4.outward"), + SQUARE_BADGE_PLUS("square.badge.plus"), + SQUARE_BADGE_PLUS_FILL("square.badge.plus.fill"), + SQUARE_BOTTOMHALF_FILLED("square.bottomhalf.filled"), + SQUARE_CIRCLE("square.circle"), + SQUARE_CIRCLE_FILL("square.circle.fill"), + SQUARE_DASHED("square.dashed"), + SQUARE_DOTTED("square.dotted"), + SQUARE_FILL("square.fill"), + SQUARE_FILL_AND_LINE_VERTICAL_AND_SQUARE_FILL("square.fill.and.line.vertical.and.square.fill"), + SQUARE_FILL_ON_CIRCLE_FILL("square.fill.on.circle.fill"), + SQUARE_FILL_ON_SQUARE_FILL("square.fill.on.square.fill"), + SQUARE_FILL_TEXT_GRID_1X2("square.fill.text.grid.1x2"), + SQUARE_FILLED_AND_LINE_VERTICAL_AND_SQUARE("square.filled.and.line.vertical.and.square"), + SQUARE_FILLED_ON_SQUARE("square.filled.on.square"), + SQUARE_GRID_2X2("square.grid.2x2"), + SQUARE_GRID_2X2_FILL("square.grid.2x2.fill"), + SQUARE_GRID_3X1_BELOW_LINE_GRID_1X2("square.grid.3x1.below.line.grid.1x2"), + SQUARE_GRID_3X1_BELOW_LINE_GRID_1X2_FILL("square.grid.3x1.below.line.grid.1x2.fill"), + SQUARE_GRID_3X1_FOLDER_BADGE_PLUS("square.grid.3x1.folder.badge.plus"), + SQUARE_GRID_3X1_FOLDER_FILL_BADGE_PLUS("square.grid.3x1.folder.fill.badge.plus"), + SQUARE_GRID_3X2("square.grid.3x2"), + SQUARE_GRID_3X2_FILL("square.grid.3x2.fill"), + SQUARE_GRID_3X3("square.grid.3x3"), + SQUARE_GRID_3X3_BOTTOMLEFT_FILLED("square.grid.3x3.bottomleft.filled"), + SQUARE_GRID_3X3_BOTTOMMIDDLE_FILLED("square.grid.3x3.bottommiddle.filled"), + SQUARE_GRID_3X3_BOTTOMRIGHT_FILLED("square.grid.3x3.bottomright.filled"), + SQUARE_GRID_3X3_FILL("square.grid.3x3.fill"), + SQUARE_GRID_3X3_MIDDLE_FILLED("square.grid.3x3.middle.filled"), + SQUARE_GRID_3X3_MIDDLELEFT_FILLED("square.grid.3x3.middleleft.filled"), + SQUARE_GRID_3X3_MIDDLERIGHT_FILLED("square.grid.3x3.middleright.filled"), + SQUARE_GRID_3X3_SQUARE("square.grid.3x3.square"), + SQUARE_GRID_3X3_SQUARE_BADGE_ELLIPSIS("square.grid.3x3.square.badge.ellipsis"), + SQUARE_GRID_3X3_TOPLEFT_FILLED("square.grid.3x3.topleft.filled"), + SQUARE_GRID_3X3_TOPMIDDLE_FILLED("square.grid.3x3.topmiddle.filled"), + SQUARE_GRID_3X3_TOPRIGHT_FILLED("square.grid.3x3.topright.filled"), + SQUARE_GRID_4X3_FILL("square.grid.4x3.fill"), + SQUARE_LEFTHALF_FILLED("square.lefthalf.filled"), + SQUARE_ON_CIRCLE("square.on.circle"), + SQUARE_ON_SQUARE("square.on.square"), + SQUARE_ON_SQUARE_BADGE_PERSON_CROP("square.on.square.badge.person.crop"), + SQUARE_ON_SQUARE_BADGE_PERSON_CROP_FILL("square.on.square.badge.person.crop.fill"), + SQUARE_ON_SQUARE_DASHED("square.on.square.dashed"), + SQUARE_ON_SQUARE_INTERSECTION_DASHED("square.on.square.intersection.dashed"), + SQUARE_ON_SQUARE_SQUARESHAPE_CONTROLHANDLES("square.on.square.squareshape.controlhandles"), + SQUARE_RESIZE("square.resize"), + SQUARE_RESIZE_DOWN("square.resize.down"), + SQUARE_RESIZE_UP("square.resize.up"), + SQUARE_RIGHTHALF_FILLED("square.righthalf.filled"), + SQUARE_SLASH("square.slash"), + SQUARE_SLASH_FILL("square.slash.fill"), + SQUARE_SPLIT_1X2("square.split.1x2"), + SQUARE_SPLIT_1X2_FILL("square.split.1x2.fill"), + SQUARE_SPLIT_2X1("square.split.2x1"), + SQUARE_SPLIT_2X1_FILL("square.split.2x1.fill"), + SQUARE_SPLIT_2X2("square.split.2x2"), + SQUARE_SPLIT_2X2_FILL("square.split.2x2.fill"), + SQUARE_SPLIT_BOTTOMRIGHTQUARTER("square.split.bottomrightquarter"), + SQUARE_SPLIT_BOTTOMRIGHTQUARTER_FILL("square.split.bottomrightquarter.fill"), + SQUARE_SPLIT_DIAGONAL("square.split.diagonal"), + SQUARE_SPLIT_DIAGONAL_2X2("square.split.diagonal.2x2"), + SQUARE_SPLIT_DIAGONAL_2X2_FILL("square.split.diagonal.2x2.fill"), + SQUARE_SPLIT_DIAGONAL_FILL("square.split.diagonal.fill"), + SQUARE_STACK("square.stack"), + SQUARE_STACK_3D_DOWN_FORWARD("square.stack.3d.down.forward"), + SQUARE_STACK_3D_DOWN_FORWARD_FILL("square.stack.3d.down.forward.fill"), + SQUARE_STACK_3D_DOWN_RIGHT("square.stack.3d.down.right"), + SQUARE_STACK_3D_DOWN_RIGHT_FILL("square.stack.3d.down.right.fill"), + SQUARE_STACK_3D_FORWARD_DOTTEDLINE("square.stack.3d.forward.dottedline"), + SQUARE_STACK_3D_FORWARD_DOTTEDLINE_FILL("square.stack.3d.forward.dottedline.fill"), + SQUARE_STACK_3D_UP("square.stack.3d.up"), + SQUARE_STACK_3D_UP_BADGE_AUTOMATIC("square.stack.3d.up.badge.automatic"), + SQUARE_STACK_3D_UP_BADGE_AUTOMATIC_FILL("square.stack.3d.up.badge.automatic.fill"), + SQUARE_STACK_3D_UP_FILL("square.stack.3d.up.fill"), + SQUARE_STACK_3D_UP_SLASH("square.stack.3d.up.slash"), + SQUARE_STACK_3D_UP_SLASH_FILL("square.stack.3d.up.slash.fill"), + SQUARE_STACK_3D_UP_TRIANGLEBADGE_EXCLAMATIONMARK("square.stack.3d.up.trianglebadge.exclamationmark"), + SQUARE_STACK_3D_UP_TRIANGLEBADGE_EXCLAMATIONMARK_FILL("square.stack.3d.up.trianglebadge.exclamationmark.fill"), + SQUARE_STACK_FILL("square.stack.fill"), + SQUARE_TEXT_SQUARE("square.text.square"), + SQUARE_TEXT_SQUARE_FILL("square.text.square.fill"), + SQUARE_TOPHALF_FILLED("square.tophalf.filled"), + SQUARES_BELOW_RECTANGLE("squares.below.rectangle"), + SQUARES_LEADING_RECTANGLE("squares.leading.rectangle"), + SQUARES_LEADING_RECTANGLE_FILL("squares.leading.rectangle.fill"), + SQUARESHAPE("squareshape"), + SQUARESHAPE_CONTROLHANDLES_ON_SQUARESHAPE_CONTROLHANDLES("squareshape.controlhandles.on.squareshape.controlhandles"), + SQUARESHAPE_DOTTED_SPLIT_2X2("squareshape.dotted.split.2x2"), + SQUARESHAPE_DOTTED_SQUARESHAPE("squareshape.dotted.squareshape"), + SQUARESHAPE_FILL("squareshape.fill"), + SQUARESHAPE_SPLIT_2X2("squareshape.split.2x2"), + SQUARESHAPE_SPLIT_2X2_DOTTED("squareshape.split.2x2.dotted"), + SQUARESHAPE_SPLIT_3X3("squareshape.split.3x3"), + SQUARESHAPE_SQUARESHAPE_DOTTED("squareshape.squareshape.dotted"), + STAR("star"), + STAR_BUBBLE("star.bubble"), + STAR_BUBBLE_FILL("star.bubble.fill"), + STAR_CIRCLE("star.circle"), + STAR_CIRCLE_FILL("star.circle.fill"), + STAR_FILL("star.fill"), + STAR_LEADINGHALF_FILLED("star.leadinghalf.filled"), + STAR_SLASH("star.slash"), + STAR_SLASH_FILL("star.slash.fill"), + STAR_SQUARE("star.square"), + STAR_SQUARE_FILL("star.square.fill"), + STAR_SQUARE_ON_SQUARE("star.square.on.square"), + STAR_SQUARE_ON_SQUARE_FILL("star.square.on.square.fill"), + STAROFLIFE("staroflife"), + STAROFLIFE_CIRCLE("staroflife.circle"), + STAROFLIFE_CIRCLE_FILL("staroflife.circle.fill"), + STAROFLIFE_FILL("staroflife.fill"), + STAROFLIFE_SHIELD("staroflife.shield"), + STAROFLIFE_SHIELD_FILL("staroflife.shield.fill"), + SUIT_CLUB("suit.club"), + SUIT_CLUB_FILL("suit.club.fill"), + SUIT_DIAMOND("suit.diamond"), + SUIT_DIAMOND_FILL("suit.diamond.fill"), + SUIT_HEART("suit.heart"), + SUIT_HEART_FILL("suit.heart.fill"), + SUIT_SPADE("suit.spade"), + SUIT_SPADE_FILL("suit.spade.fill"), + TRIANGLE("triangle"), + TRIANGLE_BOTTOMHALF_FILLED("triangle.bottomhalf.filled"), + TRIANGLE_CIRCLE("triangle.circle"), + TRIANGLE_CIRCLE_FILL("triangle.circle.fill"), + TRIANGLE_FILL("triangle.fill"), + TRIANGLE_LEFTHALF_FILLED("triangle.lefthalf.filled"), + TRIANGLE_RIGHTHALF_FILLED("triangle.righthalf.filled"), + TRIANGLE_TOPHALF_FILLED("triangle.tophalf.filled"), + TRIANGLESHAPE("triangleshape"), + TRIANGLESHAPE_FILL("triangleshape.fill"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolStatus.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolStatus.kt new file mode 100644 index 00000000..3d7ee00a --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolStatus.kt @@ -0,0 +1,280 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Status (273 symbols). */ +enum class SFSymbolStatus( + override val symbolName: String, +) : SFSymbol { + BADGE_PLUS_RADIOWAVES_FORWARD("badge.plus.radiowaves.forward"), + BADGE_PLUS_RADIOWAVES_RIGHT("badge.plus.radiowaves.right"), + BATTERY_0PERCENT("battery.0percent"), + BATTERY_25PERCENT("battery.25percent"), + BATTERY_50PERCENT("battery.50percent"), + BATTERY_75PERCENT("battery.75percent"), + BATTERY_100PERCENT("battery.100percent"), + BATTERY_100PERCENT_BOLT("battery.100percent.bolt"), + BATTERY_100PERCENT_CIRCLE("battery.100percent.circle"), + BATTERY_100PERCENT_CIRCLE_FILL("battery.100percent.circle.fill"), + BATTERYBLOCK("batteryblock"), + BATTERYBLOCK_FILL("batteryblock.fill"), + BATTERYBLOCK_SLASH("batteryblock.slash"), + BATTERYBLOCK_SLASH_FILL("batteryblock.slash.fill"), + BATTERYBLOCK_STACK("batteryblock.stack"), + BATTERYBLOCK_STACK_BADGE_SNOWFLAKE("batteryblock.stack.badge.snowflake"), + BATTERYBLOCK_STACK_BADGE_SNOWFLAKE_FILL("batteryblock.stack.badge.snowflake.fill"), + BATTERYBLOCK_STACK_FILL("batteryblock.stack.fill"), + BATTERYBLOCK_STACK_TRIANGLEBADGE_EXCLAMATIONMARK("batteryblock.stack.trianglebadge.exclamationmark"), + BATTERYBLOCK_STACK_TRIANGLEBADGE_EXCLAMATIONMARK_FILL("batteryblock.stack.trianglebadge.exclamationmark.fill"), + BELL("bell"), + BELL_AND_WAVES_LEFT_AND_RIGHT("bell.and.waves.left.and.right"), + BELL_AND_WAVES_LEFT_AND_RIGHT_FILL("bell.and.waves.left.and.right.fill"), + BELL_BADGE("bell.badge"), + BELL_BADGE_CIRCLE("bell.badge.circle"), + BELL_BADGE_CIRCLE_FILL("bell.badge.circle.fill"), + BELL_BADGE_FILL("bell.badge.fill"), + BELL_BADGE_SLASH("bell.badge.slash"), + BELL_BADGE_SLASH_FILL("bell.badge.slash.fill"), + BELL_BADGE_WAVEFORM("bell.badge.waveform"), + BELL_BADGE_WAVEFORM_FILL("bell.badge.waveform.fill"), + BELL_CIRCLE("bell.circle"), + BELL_CIRCLE_FILL("bell.circle.fill"), + BELL_FILL("bell.fill"), + BELL_SLASH("bell.slash"), + BELL_SLASH_CIRCLE("bell.slash.circle"), + BELL_SLASH_CIRCLE_FILL("bell.slash.circle.fill"), + BELL_SLASH_FILL("bell.slash.fill"), + BELL_SQUARE("bell.square"), + BELL_SQUARE_FILL("bell.square.fill"), + CHART_BAR("chart.bar"), + CHART_BAR_FILL("chart.bar.fill"), + CHART_BAR_HORIZONTAL_PAGE("chart.bar.horizontal.page"), + CHART_BAR_HORIZONTAL_PAGE_FILL("chart.bar.horizontal.page.fill"), + CHART_BAR_XAXIS("chart.bar.xaxis"), + CHART_BAR_XAXIS_ASCENDING("chart.bar.xaxis.ascending"), + CHART_BAR_XAXIS_ASCENDING_BADGE_CLOCK("chart.bar.xaxis.ascending.badge.clock"), + CHART_DOTS_SCATTER("chart.dots.scatter"), + CHART_LINE_DOWNTREND_XYAXIS("chart.line.downtrend.xyaxis"), + CHART_LINE_DOWNTREND_XYAXIS_CIRCLE("chart.line.downtrend.xyaxis.circle"), + CHART_LINE_DOWNTREND_XYAXIS_CIRCLE_FILL("chart.line.downtrend.xyaxis.circle.fill"), + CHART_LINE_FLATTREND_XYAXIS("chart.line.flattrend.xyaxis"), + CHART_LINE_FLATTREND_XYAXIS_CIRCLE("chart.line.flattrend.xyaxis.circle"), + CHART_LINE_FLATTREND_XYAXIS_CIRCLE_FILL("chart.line.flattrend.xyaxis.circle.fill"), + CHART_LINE_UPTREND_XYAXIS("chart.line.uptrend.xyaxis"), + CHART_LINE_UPTREND_XYAXIS_CIRCLE("chart.line.uptrend.xyaxis.circle"), + CHART_LINE_UPTREND_XYAXIS_CIRCLE_FILL("chart.line.uptrend.xyaxis.circle.fill"), + CHART_PIE("chart.pie"), + CHART_PIE_FILL("chart.pie.fill"), + CHART_XYAXIS_LINE("chart.xyaxis.line"), + CHECKMARK("checkmark"), + CHECKMARK_APPLEWATCH("checkmark.applewatch"), + CHECKMARK_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("checkmark.arrow.trianglehead.counterclockwise"), + CHECKMARK_BUBBLE("checkmark.bubble"), + CHECKMARK_BUBBLE_FILL("checkmark.bubble.fill"), + CHECKMARK_CIRCLE("checkmark.circle"), + CHECKMARK_CIRCLE_BADGE_QUESTIONMARK("checkmark.circle.badge.questionmark"), + CHECKMARK_CIRCLE_BADGE_QUESTIONMARK_FILL("checkmark.circle.badge.questionmark.fill"), + CHECKMARK_CIRCLE_BADGE_XMARK("checkmark.circle.badge.xmark"), + CHECKMARK_CIRCLE_BADGE_XMARK_FILL("checkmark.circle.badge.xmark.fill"), + CHECKMARK_CIRCLE_FILL("checkmark.circle.fill"), + CHECKMARK_CIRCLE_TRIANGLEBADGE_EXCLAMATIONMARK("checkmark.circle.trianglebadge.exclamationmark"), + CHECKMARK_DIAMOND("checkmark.diamond"), + CHECKMARK_DIAMOND_FILL("checkmark.diamond.fill"), + CHECKMARK_ICLOUD("checkmark.icloud"), + CHECKMARK_ICLOUD_FILL("checkmark.icloud.fill"), + CHECKMARK_MESSAGE("checkmark.message"), + CHECKMARK_MESSAGE_FILL("checkmark.message.fill"), + CHECKMARK_RECTANGLE("checkmark.rectangle"), + CHECKMARK_RECTANGLE_FILL("checkmark.rectangle.fill"), + CHECKMARK_RECTANGLE_PORTRAIT("checkmark.rectangle.portrait"), + CHECKMARK_RECTANGLE_PORTRAIT_FILL("checkmark.rectangle.portrait.fill"), + CHECKMARK_RECTANGLE_STACK("checkmark.rectangle.stack"), + CHECKMARK_RECTANGLE_STACK_FILL("checkmark.rectangle.stack.fill"), + CHECKMARK_SEAL("checkmark.seal"), + CHECKMARK_SEAL_FILL("checkmark.seal.fill"), + CHECKMARK_SHIELD("checkmark.shield"), + CHECKMARK_SHIELD_FILL("checkmark.shield.fill"), + CHECKMARK_SQUARE("checkmark.square"), + CHECKMARK_SQUARE_FILL("checkmark.square.fill"), + EXCLAMATIONMARK("exclamationmark"), + EXCLAMATIONMARK_2("exclamationmark.2"), + EXCLAMATIONMARK_3("exclamationmark.3"), + EXCLAMATIONMARK_APPLEWATCH("exclamationmark.applewatch"), + EXCLAMATIONMARK_ARROW_TRIANGLEHEAD_2_CLOCKWISE_ROTATE_90("exclamationmark.arrow.trianglehead.2.clockwise.rotate.90"), + EXCLAMATIONMARK_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("exclamationmark.arrow.trianglehead.counterclockwise.rotate.90"), + EXCLAMATIONMARK_BRAKESIGNAL("exclamationmark.brakesignal"), + EXCLAMATIONMARK_BUBBLE("exclamationmark.bubble"), + EXCLAMATIONMARK_BUBBLE_CIRCLE("exclamationmark.bubble.circle"), + EXCLAMATIONMARK_BUBBLE_CIRCLE_FILL("exclamationmark.bubble.circle.fill"), + EXCLAMATIONMARK_BUBBLE_FILL("exclamationmark.bubble.fill"), + EXCLAMATIONMARK_CIRCLE("exclamationmark.circle"), + EXCLAMATIONMARK_CIRCLE_FILL("exclamationmark.circle.fill"), + EXCLAMATIONMARK_ICLOUD("exclamationmark.icloud"), + EXCLAMATIONMARK_ICLOUD_FILL("exclamationmark.icloud.fill"), + EXCLAMATIONMARK_LOCK("exclamationmark.lock"), + EXCLAMATIONMARK_LOCK_FILL("exclamationmark.lock.fill"), + EXCLAMATIONMARK_MAGNIFYINGGLASS("exclamationmark.magnifyingglass"), + EXCLAMATIONMARK_OCTAGON("exclamationmark.octagon"), + EXCLAMATIONMARK_OCTAGON_FILL("exclamationmark.octagon.fill"), + EXCLAMATIONMARK_QUESTIONMARK("exclamationmark.questionmark"), + EXCLAMATIONMARK_SHIELD("exclamationmark.shield"), + EXCLAMATIONMARK_SHIELD_FILL("exclamationmark.shield.fill"), + EXCLAMATIONMARK_SQUARE("exclamationmark.square"), + EXCLAMATIONMARK_SQUARE_FILL("exclamationmark.square.fill"), + EXCLAMATIONMARK_TIREPRESSURE("exclamationmark.tirepressure"), + EXCLAMATIONMARK_TRANSMISSION("exclamationmark.transmission"), + EXCLAMATIONMARK_TRIANGLE("exclamationmark.triangle"), + EXCLAMATIONMARK_TRIANGLE_FILL("exclamationmark.triangle.fill"), + EXCLAMATIONMARK_WARNINGLIGHT("exclamationmark.warninglight"), + EXCLAMATIONMARK_WARNINGLIGHT_FILL("exclamationmark.warninglight.fill"), + GAUGE_OPEN_WITH_LINES_NEEDLE_33PERCENT("gauge.open.with.lines.needle.33percent"), + GAUGE_OPEN_WITH_LINES_NEEDLE_33PERCENT_AND_ARROW_TRIANGLEHEAD_FROM_0PERCENT_TO_50PERCENT("gauge.open.with.lines.needle.33percent.and.arrow.trianglehead.from.0percent.to.50percent"), + GAUGE_OPEN_WITH_LINES_NEEDLE_33PERCENT_AND_ARROWTRIANGLE("gauge.open.with.lines.needle.33percent.and.arrowtriangle"), + GAUGE_OPEN_WITH_LINES_NEEDLE_67PERCENT_AND_ARROWTRIANGLE("gauge.open.with.lines.needle.67percent.and.arrowtriangle"), + GAUGE_OPEN_WITH_LINES_NEEDLE_67PERCENT_AND_ARROWTRIANGLE_AND_CAR("gauge.open.with.lines.needle.67percent.and.arrowtriangle.and.car"), + GAUGE_OPEN_WITH_LINES_NEEDLE_84PERCENT_EXCLAMATION("gauge.open.with.lines.needle.84percent.exclamation"), + GAUGE_WITH_DOTS_NEEDLE_0PERCENT("gauge.with.dots.needle.0percent"), + GAUGE_WITH_DOTS_NEEDLE_33PERCENT("gauge.with.dots.needle.33percent"), + GAUGE_WITH_DOTS_NEEDLE_50PERCENT("gauge.with.dots.needle.50percent"), + GAUGE_WITH_DOTS_NEEDLE_67PERCENT("gauge.with.dots.needle.67percent"), + GAUGE_WITH_DOTS_NEEDLE_100PERCENT("gauge.with.dots.needle.100percent"), + GAUGE_WITH_DOTS_NEEDLE_BOTTOM_0PERCENT("gauge.with.dots.needle.bottom.0percent"), + GAUGE_WITH_DOTS_NEEDLE_BOTTOM_50PERCENT("gauge.with.dots.needle.bottom.50percent"), + GAUGE_WITH_DOTS_NEEDLE_BOTTOM_50PERCENT_BADGE_MINUS("gauge.with.dots.needle.bottom.50percent.badge.minus"), + GAUGE_WITH_DOTS_NEEDLE_BOTTOM_50PERCENT_BADGE_PLUS("gauge.with.dots.needle.bottom.50percent.badge.plus"), + GAUGE_WITH_DOTS_NEEDLE_BOTTOM_100PERCENT("gauge.with.dots.needle.bottom.100percent"), + GAUGE_WITH_NEEDLE("gauge.with.needle"), + GAUGE_WITH_NEEDLE_FILL("gauge.with.needle.fill"), + INFO("info"), + INFO_BUBBLE("info.bubble"), + INFO_BUBBLE_FILL("info.bubble.fill"), + INFO_CIRCLE("info.circle"), + INFO_CIRCLE_FILL("info.circle.fill"), + INFO_SQUARE("info.square"), + INFO_SQUARE_FILL("info.square.fill"), + INFO_WINDSHIELD("info.windshield"), + LEVEL("level"), + LEVEL_FILL("level.fill"), + MINUS("minus"), + MINUS_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE("minus.arrow.trianglehead.counterclockwise"), + MINUS_CIRCLE("minus.circle"), + MINUS_CIRCLE_FILL("minus.circle.fill"), + MINUS_DIAMOND("minus.diamond"), + MINUS_DIAMOND_FILL("minus.diamond.fill"), + MINUS_FORWARDSLASH_PLUS("minus.forwardslash.plus"), + MINUS_MAGNIFYINGGLASS("minus.magnifyingglass"), + MINUS_PLUS_AND_FLUID_BATTERYBLOCK("minus.plus.and.fluid.batteryblock"), + MINUS_PLUS_BATTERYBLOCK("minus.plus.batteryblock"), + MINUS_PLUS_BATTERYBLOCK_EXCLAMATIONMARK("minus.plus.batteryblock.exclamationmark"), + MINUS_PLUS_BATTERYBLOCK_EXCLAMATIONMARK_FILL("minus.plus.batteryblock.exclamationmark.fill"), + MINUS_PLUS_BATTERYBLOCK_FILL("minus.plus.batteryblock.fill"), + MINUS_PLUS_BATTERYBLOCK_SLASH("minus.plus.batteryblock.slash"), + MINUS_PLUS_BATTERYBLOCK_SLASH_FILL("minus.plus.batteryblock.slash.fill"), + MINUS_PLUS_BATTERYBLOCK_STACK("minus.plus.batteryblock.stack"), + MINUS_PLUS_BATTERYBLOCK_STACK_EXCLAMATIONMARK("minus.plus.batteryblock.stack.exclamationmark"), + MINUS_PLUS_BATTERYBLOCK_STACK_EXCLAMATIONMARK_FILL("minus.plus.batteryblock.stack.exclamationmark.fill"), + MINUS_PLUS_BATTERYBLOCK_STACK_FILL("minus.plus.batteryblock.stack.fill"), + MINUS_RECTANGLE("minus.rectangle"), + MINUS_RECTANGLE_FILL("minus.rectangle.fill"), + MINUS_RECTANGLE_PORTRAIT("minus.rectangle.portrait"), + MINUS_RECTANGLE_PORTRAIT_FILL("minus.rectangle.portrait.fill"), + MINUS_SQUARE("minus.square"), + MINUS_SQUARE_FILL("minus.square.fill"), + PLUS("plus"), + PLUS_APP("plus.app"), + PLUS_APP_FILL("plus.app.fill"), + PLUS_ARROW_TRIANGLEHEAD_CLOCKWISE("plus.arrow.trianglehead.clockwise"), + PLUS_BUBBLE("plus.bubble"), + PLUS_BUBBLE_FILL("plus.bubble.fill"), + PLUS_CIRCLE("plus.circle"), + PLUS_CIRCLE_DASHED("plus.circle.dashed"), + PLUS_CIRCLE_FILL("plus.circle.fill"), + PLUS_DIAMOND("plus.diamond"), + PLUS_DIAMOND_FILL("plus.diamond.fill"), + PLUS_FORWARDSLASH_MINUS("plus.forwardslash.minus"), + PLUS_MAGNIFYINGGLASS("plus.magnifyingglass"), + PLUS_MESSAGE("plus.message"), + PLUS_MESSAGE_FILL("plus.message.fill"), + PLUS_RECTANGLE("plus.rectangle"), + PLUS_RECTANGLE_FILL("plus.rectangle.fill"), + PLUS_RECTANGLE_FILL_ON_RECTANGLE_FILL("plus.rectangle.fill.on.rectangle.fill"), + PLUS_RECTANGLE_ON_FOLDER("plus.rectangle.on.folder"), + PLUS_RECTANGLE_ON_FOLDER_FILL("plus.rectangle.on.folder.fill"), + PLUS_RECTANGLE_ON_RECTANGLE("plus.rectangle.on.rectangle"), + PLUS_RECTANGLE_PORTRAIT("plus.rectangle.portrait"), + PLUS_RECTANGLE_PORTRAIT_FILL("plus.rectangle.portrait.fill"), + PLUS_SQUARE("plus.square"), + PLUS_SQUARE_DASHED("plus.square.dashed"), + PLUS_SQUARE_FILL("plus.square.fill"), + PLUS_SQUARE_FILL_ON_SQUARE_FILL("plus.square.fill.on.square.fill"), + PLUS_SQUARE_ON_SQUARE("plus.square.on.square"), + PLUS_VIEWFINDER("plus.viewfinder"), + PLUSMINUS("plusminus"), + PLUSMINUS_CIRCLE("plusminus.circle"), + PLUSMINUS_CIRCLE_FILL("plusminus.circle.fill"), + QUESTIONMARK("questionmark"), + QUESTIONMARK_APP("questionmark.app"), + QUESTIONMARK_APP_DASHED("questionmark.app.dashed"), + QUESTIONMARK_APP_FILL("questionmark.app.fill"), + QUESTIONMARK_BUBBLE("questionmark.bubble"), + QUESTIONMARK_BUBBLE_FILL("questionmark.bubble.fill"), + QUESTIONMARK_CIRCLE("questionmark.circle"), + QUESTIONMARK_CIRCLE_DASHED("questionmark.circle.dashed"), + QUESTIONMARK_CIRCLE_FILL("questionmark.circle.fill"), + QUESTIONMARK_DIAMOND("questionmark.diamond"), + QUESTIONMARK_DIAMOND_FILL("questionmark.diamond.fill"), + QUESTIONMARK_FOLDER("questionmark.folder"), + QUESTIONMARK_FOLDER_FILL("questionmark.folder.fill"), + QUESTIONMARK_KEY_FILLED("questionmark.key.filled"), + QUESTIONMARK_SQUARE("questionmark.square"), + QUESTIONMARK_SQUARE_DASHED("questionmark.square.dashed"), + QUESTIONMARK_SQUARE_FILL("questionmark.square.fill"), + QUESTIONMARK_TEXT_PAGE("questionmark.text.page"), + QUESTIONMARK_TEXT_PAGE_FILL("questionmark.text.page.fill"), + QUESTIONMARK_VIDEO("questionmark.video"), + QUESTIONMARK_VIDEO_FILL("questionmark.video.fill"), + SWITCH_2("switch.2"), + SWITCH_PROGRAMMABLE("switch.programmable"), + SWITCH_PROGRAMMABLE_FILL("switch.programmable.fill"), + SWITCH_PROGRAMMABLE_SQUARE("switch.programmable.square"), + SWITCH_PROGRAMMABLE_SQUARE_FILL("switch.programmable.square.fill"), + WAVEFORM("waveform"), + WAVEFORM_AND_PERSON_FILLED("waveform.and.person.filled"), + WAVEFORM_BADGE_EXCLAMATIONMARK("waveform.badge.exclamationmark"), + WAVEFORM_BADGE_MAGNIFYINGGLASS("waveform.badge.magnifyingglass"), + WAVEFORM_BADGE_MICROPHONE("waveform.badge.microphone"), + WAVEFORM_BADGE_MINUS("waveform.badge.minus"), + WAVEFORM_BADGE_PLUS("waveform.badge.plus"), + WAVEFORM_CIRCLE("waveform.circle"), + WAVEFORM_CIRCLE_FILL("waveform.circle.fill"), + WAVEFORM_PATH("waveform.path"), + WAVEFORM_PATH_BADGE_MINUS("waveform.path.badge.minus"), + WAVEFORM_PATH_BADGE_PLUS("waveform.path.badge.plus"), + WAVEFORM_PATH_ECG("waveform.path.ecg"), + WAVEFORM_PATH_ECG_RECTANGLE("waveform.path.ecg.rectangle"), + WAVEFORM_PATH_ECG_RECTANGLE_FILL("waveform.path.ecg.rectangle.fill"), + WAVEFORM_SLASH("waveform.slash"), + XMARK("xmark"), + XMARK_APP("xmark.app"), + XMARK_APP_FILL("xmark.app.fill"), + XMARK_BIN("xmark.bin"), + XMARK_BIN_CIRCLE("xmark.bin.circle"), + XMARK_BIN_CIRCLE_FILL("xmark.bin.circle.fill"), + XMARK_BIN_FILL("xmark.bin.fill"), + XMARK_CIRCLE("xmark.circle"), + XMARK_CIRCLE_FILL("xmark.circle.fill"), + XMARK_DIAMOND("xmark.diamond"), + XMARK_DIAMOND_FILL("xmark.diamond.fill"), + XMARK_ICLOUD("xmark.icloud"), + XMARK_ICLOUD_FILL("xmark.icloud.fill"), + XMARK_OCTAGON("xmark.octagon"), + XMARK_OCTAGON_FILL("xmark.octagon.fill"), + XMARK_RECTANGLE("xmark.rectangle"), + XMARK_RECTANGLE_FILL("xmark.rectangle.fill"), + XMARK_RECTANGLE_PORTRAIT("xmark.rectangle.portrait"), + XMARK_RECTANGLE_PORTRAIT_FILL("xmark.rectangle.portrait.fill"), + XMARK_SEAL("xmark.seal"), + XMARK_SEAL_FILL("xmark.seal.fill"), + XMARK_SHIELD("xmark.shield"), + XMARK_SHIELD_FILL("xmark.shield.fill"), + XMARK_SQUARE("xmark.square"), + XMARK_SQUARE_FILL("xmark.square.fill"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolTextFormatting.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolTextFormatting.kt new file mode 100644 index 00000000..57fad79b --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolTextFormatting.kt @@ -0,0 +1,124 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — TextFormatting (117 symbols). */ +enum class SFSymbolTextFormatting( + override val symbolName: String, +) : SFSymbol { + BOLD("bold"), + BOLD_ITALIC_UNDERLINE("bold.italic.underline"), + BOLD_UNDERLINE("bold.underline"), + CHARACTER("character"), + CHARACTER_BOOK_CLOSED("character.book.closed"), + CHARACTER_BOOK_CLOSED_FILL("character.book.closed.fill"), + CHARACTER_BUBBLE("character.bubble"), + CHARACTER_BUBBLE_FILL("character.bubble.fill"), + CHARACTER_CIRCLE("character.circle"), + CHARACTER_CIRCLE_FILL("character.circle.fill"), + CHARACTER_CURSOR_IBEAM("character.cursor.ibeam"), + CHARACTER_DUPLOYAN("character.duployan"), + CHARACTER_MAGNIFY("character.magnify"), + CHARACTER_PHONETIC("character.phonetic"), + CHARACTER_SQUARE("character.square"), + CHARACTER_SQUARE_FILL("character.square.fill"), + CHARACTER_SUTTON("character.sutton"), + CHARACTER_TEXTBOX("character.textbox"), + CHARACTERS_LOWERCASE("characters.lowercase"), + CHARACTERS_UPPERCASE("characters.uppercase"), + ITALIC("italic"), + LINE_2_HORIZONTAL_DECREASE_CIRCLE("line.2.horizontal.decrease.circle"), + LINE_2_HORIZONTAL_DECREASE_CIRCLE_FILL("line.2.horizontal.decrease.circle.fill"), + LINE_3_CROSSED_SWIRL_CIRCLE("line.3.crossed.swirl.circle"), + LINE_3_CROSSED_SWIRL_CIRCLE_FILL("line.3.crossed.swirl.circle.fill"), + LINE_3_HORIZONTAL("line.3.horizontal"), + LINE_3_HORIZONTAL_BUTTON_ANGLEDTOP_VERTICAL_RIGHT("line.3.horizontal.button.angledtop.vertical.right"), + LINE_3_HORIZONTAL_BUTTON_ANGLEDTOP_VERTICAL_RIGHT_FILL("line.3.horizontal.button.angledtop.vertical.right.fill"), + LINE_3_HORIZONTAL_CIRCLE("line.3.horizontal.circle"), + LINE_3_HORIZONTAL_CIRCLE_FILL("line.3.horizontal.circle.fill"), + LINE_3_HORIZONTAL_DECREASE("line.3.horizontal.decrease"), + LINE_3_HORIZONTAL_DECREASE_CIRCLE("line.3.horizontal.decrease.circle"), + LINE_3_HORIZONTAL_DECREASE_CIRCLE_FILL("line.3.horizontal.decrease.circle.fill"), + LINE_DIAGONAL("line.diagonal"), + LINE_DIAGONAL_ARROW("line.diagonal.arrow"), + LINE_HORIZONTAL_STAR_FILL_LINE_HORIZONTAL("line.horizontal.star.fill.line.horizontal"), + LINES_MEASUREMENT_HORIZONTAL("lines.measurement.horizontal"), + LINES_MEASUREMENT_VERTICAL("lines.measurement.vertical"), + LINEWEIGHT("lineweight"), + LIST_AND_FILM("list.and.film"), + LIST_BULLET("list.bullet"), + LIST_BULLET_BELOW_RECTANGLE("list.bullet.below.rectangle"), + LIST_BULLET_CIRCLE("list.bullet.circle"), + LIST_BULLET_CIRCLE_FILL("list.bullet.circle.fill"), + LIST_BULLET_CLIPBOARD("list.bullet.clipboard"), + LIST_BULLET_CLIPBOARD_FILL("list.bullet.clipboard.fill"), + LIST_BULLET_INDENT("list.bullet.indent"), + LIST_BULLET_RECTANGLE("list.bullet.rectangle"), + LIST_BULLET_RECTANGLE_FILL("list.bullet.rectangle.fill"), + LIST_BULLET_RECTANGLE_PORTRAIT("list.bullet.rectangle.portrait"), + LIST_BULLET_RECTANGLE_PORTRAIT_FILL("list.bullet.rectangle.portrait.fill"), + LIST_CLIPBOARD("list.clipboard"), + LIST_CLIPBOARD_FILL("list.clipboard.fill"), + LIST_DASH("list.dash"), + LIST_DASH_HEADER_RECTANGLE("list.dash.header.rectangle"), + LIST_NUMBER("list.number"), + LIST_STAR("list.star"), + LIST_TRIANGLE("list.triangle"), + NUMBER("number"), + NUMBER_CIRCLE("number.circle"), + NUMBER_CIRCLE_FILL("number.circle.fill"), + NUMBER_SQUARE("number.square"), + NUMBER_SQUARE_FILL("number.square.fill"), + NUMBERS("numbers"), + NUMBERS_RECTANGLE("numbers.rectangle"), + NUMBERS_RECTANGLE_FILL("numbers.rectangle.fill"), + NUMBERSIGN("numbersign"), + PARAGRAPHSIGN("paragraphsign"), + STRIKETHROUGH("strikethrough"), + TEXT_ALIGNCENTER("text.aligncenter"), + TEXT_ALIGNLEFT("text.alignleft"), + TEXT_ALIGNRIGHT("text.alignright"), + TEXT_AND_COMMAND_MACWINDOW("text.and.command.macwindow"), + TEXT_APPEND("text.append"), + TEXT_BADGE_CHECKMARK("text.badge.checkmark"), + TEXT_BADGE_MINUS("text.badge.minus"), + TEXT_BADGE_PLUS("text.badge.plus"), + TEXT_BADGE_STAR("text.badge.star"), + TEXT_BADGE_XMARK("text.badge.xmark"), + TEXT_BELOW_PHOTO("text.below.photo"), + TEXT_BELOW_PHOTO_FILL("text.below.photo.fill"), + TEXT_BOOK_CLOSED("text.book.closed"), + TEXT_BOOK_CLOSED_FILL("text.book.closed.fill"), + TEXT_BUBBLE("text.bubble"), + TEXT_BUBBLE_FILL("text.bubble.fill"), + TEXT_DOCUMENT("text.document"), + TEXT_DOCUMENT_FILL("text.document.fill"), + TEXT_INSERT("text.insert"), + TEXT_JUSTIFY("text.justify"), + TEXT_JUSTIFY_LEADING("text.justify.leading"), + TEXT_JUSTIFY_LEFT("text.justify.left"), + TEXT_JUSTIFY_RIGHT("text.justify.right"), + TEXT_JUSTIFY_TRAILING("text.justify.trailing"), + TEXT_LINE_FIRST_AND_ARROWTRIANGLE_FORWARD("text.line.first.and.arrowtriangle.forward"), + TEXT_LINE_LAST_AND_ARROWTRIANGLE_FORWARD("text.line.last.and.arrowtriangle.forward"), + TEXT_MAGNIFYINGGLASS("text.magnifyingglass"), + TEXT_PAGE("text.page"), + TEXT_PAGE_BADGE_MAGNIFYINGGLASS("text.page.badge.magnifyingglass"), + TEXT_PAGE_FILL("text.page.fill"), + TEXT_QUOTE("text.quote"), + TEXT_RECTANGLE_PAGE("text.rectangle.page"), + TEXT_RECTANGLE_PAGE_FILL("text.rectangle.page.fill"), + TEXT_REDACTION("text.redaction"), + TEXT_VIEWFINDER("text.viewfinder"), + TEXT_WORD_SPACING("text.word.spacing"), + TEXTFORMAT("textformat"), + TEXTFORMAT_ALT("textformat.alt"), + TEXTFORMAT_CHARACTERS("textformat.characters"), + TEXTFORMAT_CHARACTERS_ARROW_LEFT_AND_RIGHT("textformat.characters.arrow.left.and.right"), + TEXTFORMAT_CHARACTERS_DOTTEDUNDERLINE("textformat.characters.dottedunderline"), + TEXTFORMAT_NUMBERS("textformat.numbers"), + TEXTFORMAT_SIZE("textformat.size"), + TEXTFORMAT_SIZE_LARGER("textformat.size.larger"), + TEXTFORMAT_SIZE_SMALLER("textformat.size.smaller"), + TEXTFORMAT_SUBSCRIPT("textformat.subscript"), + TEXTFORMAT_SUPERSCRIPT("textformat.superscript"), + UNDERLINE("underline"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolTime.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolTime.kt new file mode 100644 index 00000000..73e5f994 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolTime.kt @@ -0,0 +1,52 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Time (45 symbols). */ +enum class SFSymbolTime( + override val symbolName: String, +) : SFSymbol { + ALARM("alarm"), + ALARM_FILL("alarm.fill"), + ALARM_WAVES_LEFT_AND_RIGHT("alarm.waves.left.and.right"), + ALARM_WAVES_LEFT_AND_RIGHT_FILL("alarm.waves.left.and.right.fill"), + CALENDAR("calendar"), + CALENDAR_AND_PERSON("calendar.and.person"), + CALENDAR_BADGE_CHECKMARK("calendar.badge.checkmark"), + CALENDAR_BADGE_CLOCK("calendar.badge.clock"), + CALENDAR_BADGE_EXCLAMATIONMARK("calendar.badge.exclamationmark"), + CALENDAR_BADGE_MINUS("calendar.badge.minus"), + CALENDAR_BADGE_PLUS("calendar.badge.plus"), + CALENDAR_CIRCLE("calendar.circle"), + CALENDAR_CIRCLE_FILL("calendar.circle.fill"), + CALENDAR_DAY_TIMELINE_LEADING("calendar.day.timeline.leading"), + CALENDAR_DAY_TIMELINE_LEFT("calendar.day.timeline.left"), + CALENDAR_DAY_TIMELINE_RIGHT("calendar.day.timeline.right"), + CALENDAR_DAY_TIMELINE_TRAILING("calendar.day.timeline.trailing"), + CLOCK("clock"), + CLOCK_ARROW_TRIANGLEHEAD_2_COUNTERCLOCKWISE_ROTATE_90("clock.arrow.trianglehead.2.counterclockwise.rotate.90"), + CLOCK_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_ROTATE_90("clock.arrow.trianglehead.counterclockwise.rotate.90"), + CLOCK_BADGE("clock.badge"), + CLOCK_BADGE_CHECKMARK("clock.badge.checkmark"), + CLOCK_BADGE_CHECKMARK_FILL("clock.badge.checkmark.fill"), + CLOCK_BADGE_EXCLAMATIONMARK("clock.badge.exclamationmark"), + CLOCK_BADGE_EXCLAMATIONMARK_FILL("clock.badge.exclamationmark.fill"), + CLOCK_BADGE_FILL("clock.badge.fill"), + CLOCK_BADGE_QUESTIONMARK("clock.badge.questionmark"), + CLOCK_BADGE_QUESTIONMARK_FILL("clock.badge.questionmark.fill"), + CLOCK_BADGE_XMARK("clock.badge.xmark"), + CLOCK_BADGE_XMARK_FILL("clock.badge.xmark.fill"), + CLOCK_CIRCLE("clock.circle"), + CLOCK_CIRCLE_FILL("clock.circle.fill"), + CLOCK_FILL("clock.fill"), + HOURGLASS("hourglass"), + HOURGLASS_AND_LOCK("hourglass.and.lock"), + HOURGLASS_BADGE_EYE("hourglass.badge.eye"), + HOURGLASS_BADGE_PLUS("hourglass.badge.plus"), + HOURGLASS_BOTTOMHALF_FILLED("hourglass.bottomhalf.filled"), + HOURGLASS_CIRCLE("hourglass.circle"), + HOURGLASS_CIRCLE_FILL("hourglass.circle.fill"), + HOURGLASS_TOPHALF_FILLED("hourglass.tophalf.filled"), + TIMER("timer"), + TIMER_CIRCLE("timer.circle"), + TIMER_CIRCLE_FILL("timer.circle.fill"), + TIMER_SQUARE("timer.square"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolTransportation.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolTransportation.kt new file mode 100644 index 00000000..4bd92eee --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolTransportation.kt @@ -0,0 +1,424 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Transportation (417 symbols). */ +enum class SFSymbolTransportation( + override val symbolName: String, +) : SFSymbol { + AIRPLANE("airplane"), + AIRPLANE_ARRIVAL("airplane.arrival"), + AIRPLANE_CIRCLE("airplane.circle"), + AIRPLANE_CIRCLE_FILL("airplane.circle.fill"), + AIRPLANE_DEPARTURE("airplane.departure"), + BICYCLE("bicycle"), + BICYCLE_CIRCLE("bicycle.circle"), + BICYCLE_CIRCLE_FILL("bicycle.circle.fill"), + BUS("bus"), + BUS_DOUBLEDECKER("bus.doubledecker"), + BUS_DOUBLEDECKER_FILL("bus.doubledecker.fill"), + BUS_FILL("bus.fill"), + CAR("car"), + CAR_2("car.2"), + CAR_2_FILL("car.2.fill"), + CAR_BADGE_GEARSHAPE("car.badge.gearshape"), + CAR_BADGE_GEARSHAPE_FILL("car.badge.gearshape.fill"), + CAR_CIRCLE("car.circle"), + CAR_CIRCLE_FILL("car.circle.fill"), + CAR_FERRY("car.ferry"), + CAR_FERRY_FILL("car.ferry.fill"), + CAR_FILL("car.fill"), + CAR_FRONT_WAVES_DOWN("car.front.waves.down"), + CAR_FRONT_WAVES_DOWN_FILL("car.front.waves.down.fill"), + CAR_FRONT_WAVES_LEFT_AND_RIGHT_AND_UP("car.front.waves.left.and.right.and.up"), + CAR_FRONT_WAVES_LEFT_AND_RIGHT_AND_UP_FILL("car.front.waves.left.and.right.and.up.fill"), + CAR_FRONT_WAVES_UP("car.front.waves.up"), + CAR_FRONT_WAVES_UP_FILL("car.front.waves.up.fill"), + CAR_REAR("car.rear"), + CAR_REAR_AND_COLLISION_ROAD_LANE("car.rear.and.collision.road.lane"), + CAR_REAR_AND_COLLISION_ROAD_LANE_SLASH("car.rear.and.collision.road.lane.slash"), + CAR_REAR_AND_TIRE_MARKS("car.rear.and.tire.marks"), + CAR_REAR_AND_TIRE_MARKS_SLASH("car.rear.and.tire.marks.slash"), + CAR_REAR_FILL("car.rear.fill"), + CAR_REAR_HAZARDSIGN("car.rear.hazardsign"), + CAR_REAR_HAZARDSIGN_FILL("car.rear.hazardsign.fill"), + CAR_REAR_ROAD_LANE("car.rear.road.lane"), + CAR_REAR_ROAD_LANE_DASHED("car.rear.road.lane.dashed"), + CAR_REAR_ROAD_LANE_WAVE_UP("car.rear.road.lane.wave.up"), + CAR_REAR_TILT_ROAD_LANES_CURVED_RIGHT("car.rear.tilt.road.lanes.curved.right"), + CAR_REAR_WAVES_UP("car.rear.waves.up"), + CAR_REAR_WAVES_UP_FILL("car.rear.waves.up.fill"), + CAR_SIDE("car.side"), + CAR_SIDE_AIR_CIRCULATE("car.side.air.circulate"), + CAR_SIDE_AIR_CIRCULATE_FILL("car.side.air.circulate.fill"), + CAR_SIDE_AIR_FRESH("car.side.air.fresh"), + CAR_SIDE_AIR_FRESH_FILL("car.side.air.fresh.fill"), + CAR_SIDE_AND_EXCLAMATIONMARK("car.side.and.exclamationmark"), + CAR_SIDE_AND_EXCLAMATIONMARK_FILL("car.side.and.exclamationmark.fill"), + CAR_SIDE_ARROWTRIANGLE_DOWN("car.side.arrowtriangle.down"), + CAR_SIDE_ARROWTRIANGLE_DOWN_FILL("car.side.arrowtriangle.down.fill"), + CAR_SIDE_ARROWTRIANGLE_UP("car.side.arrowtriangle.up"), + CAR_SIDE_ARROWTRIANGLE_UP_ARROWTRIANGLE_DOWN("car.side.arrowtriangle.up.arrowtriangle.down"), + CAR_SIDE_ARROWTRIANGLE_UP_ARROWTRIANGLE_DOWN_FILL("car.side.arrowtriangle.up.arrowtriangle.down.fill"), + CAR_SIDE_ARROWTRIANGLE_UP_FILL("car.side.arrowtriangle.up.fill"), + CAR_SIDE_FILL("car.side.fill"), + CAR_SIDE_FRONT_OPEN("car.side.front.open"), + CAR_SIDE_FRONT_OPEN_CROP("car.side.front.open.crop"), + CAR_SIDE_FRONT_OPEN_CROP_FILL("car.side.front.open.crop.fill"), + CAR_SIDE_FRONT_OPEN_FILL("car.side.front.open.fill"), + CAR_SIDE_HILL_DOWN("car.side.hill.down"), + CAR_SIDE_HILL_DOWN_FILL("car.side.hill.down.fill"), + CAR_SIDE_HILL_UP("car.side.hill.up"), + CAR_SIDE_HILL_UP_FILL("car.side.hill.up.fill"), + CAR_SIDE_LOCK("car.side.lock"), + CAR_SIDE_LOCK_FILL("car.side.lock.fill"), + CAR_SIDE_LOCK_OPEN("car.side.lock.open"), + CAR_SIDE_LOCK_OPEN_FILL("car.side.lock.open.fill"), + CAR_SIDE_REAR_AND_COLLISION_AND_CAR_SIDE_FRONT("car.side.rear.and.collision.and.car.side.front"), + CAR_SIDE_REAR_AND_COLLISION_AND_CAR_SIDE_FRONT_SLASH("car.side.rear.and.collision.and.car.side.front.slash"), + CAR_SIDE_REAR_AND_EXCLAMATIONMARK_AND_CAR_SIDE_FRONT("car.side.rear.and.exclamationmark.and.car.side.front"), + CAR_SIDE_REAR_AND_WAVE_3_AND_CAR_SIDE_FRONT("car.side.rear.and.wave.3.and.car.side.front"), + CAR_SIDE_REAR_OPEN("car.side.rear.open"), + CAR_SIDE_REAR_OPEN_CROP("car.side.rear.open.crop"), + CAR_SIDE_REAR_OPEN_CROP_FILL("car.side.rear.open.crop.fill"), + CAR_SIDE_REAR_OPEN_FILL("car.side.rear.open.fill"), + CAR_SIDE_REAR_TOW_HITCH("car.side.rear.tow.hitch"), + CAR_SIDE_REAR_TOW_HITCH_FILL("car.side.rear.tow.hitch.fill"), + CAR_TOP_ARROWTRIANGLE_FRONT_LEFT("car.top.arrowtriangle.front.left"), + CAR_TOP_ARROWTRIANGLE_FRONT_LEFT_FILL("car.top.arrowtriangle.front.left.fill"), + CAR_TOP_ARROWTRIANGLE_FRONT_RIGHT("car.top.arrowtriangle.front.right"), + CAR_TOP_ARROWTRIANGLE_FRONT_RIGHT_FILL("car.top.arrowtriangle.front.right.fill"), + CAR_TOP_ARROWTRIANGLE_REAR_LEFT("car.top.arrowtriangle.rear.left"), + CAR_TOP_ARROWTRIANGLE_REAR_LEFT_FILL("car.top.arrowtriangle.rear.left.fill"), + CAR_TOP_ARROWTRIANGLE_REAR_RIGHT("car.top.arrowtriangle.rear.right"), + CAR_TOP_ARROWTRIANGLE_REAR_RIGHT_FILL("car.top.arrowtriangle.rear.right.fill"), + CAR_TOP_DOOR_FRONT_LEFT_AND_FRONT_RIGHT_AND_REAR_LEFT_AND_REAR_RIGHT_OPEN("car.top.door.front.left.and.front.right.and.rear.left.and.rear.right.open"), + CAR_TOP_DOOR_FRONT_LEFT_AND_FRONT_RIGHT_AND_REAR_LEFT_AND_REAR_RIGHT_OPEN_FILL("car.top.door.front.left.and.front.right.and.rear.left.and.rear.right.open.fill"), + CAR_TOP_DOOR_FRONT_LEFT_AND_FRONT_RIGHT_AND_REAR_LEFT_OPEN("car.top.door.front.left.and.front.right.and.rear.left.open"), + CAR_TOP_DOOR_FRONT_LEFT_AND_FRONT_RIGHT_AND_REAR_LEFT_OPEN_FILL("car.top.door.front.left.and.front.right.and.rear.left.open.fill"), + CAR_TOP_DOOR_FRONT_LEFT_AND_FRONT_RIGHT_AND_REAR_RIGHT_OPEN("car.top.door.front.left.and.front.right.and.rear.right.open"), + CAR_TOP_DOOR_FRONT_LEFT_AND_FRONT_RIGHT_AND_REAR_RIGHT_OPEN_FILL("car.top.door.front.left.and.front.right.and.rear.right.open.fill"), + CAR_TOP_DOOR_FRONT_LEFT_AND_FRONT_RIGHT_OPEN("car.top.door.front.left.and.front.right.open"), + CAR_TOP_DOOR_FRONT_LEFT_AND_FRONT_RIGHT_OPEN_FILL("car.top.door.front.left.and.front.right.open.fill"), + CAR_TOP_DOOR_FRONT_LEFT_AND_REAR_LEFT_AND_REAR_RIGHT_OPEN("car.top.door.front.left.and.rear.left.and.rear.right.open"), + CAR_TOP_DOOR_FRONT_LEFT_AND_REAR_LEFT_AND_REAR_RIGHT_OPEN_FILL("car.top.door.front.left.and.rear.left.and.rear.right.open.fill"), + CAR_TOP_DOOR_FRONT_LEFT_AND_REAR_LEFT_OPEN("car.top.door.front.left.and.rear.left.open"), + CAR_TOP_DOOR_FRONT_LEFT_AND_REAR_LEFT_OPEN_FILL("car.top.door.front.left.and.rear.left.open.fill"), + CAR_TOP_DOOR_FRONT_LEFT_AND_REAR_RIGHT_OPEN("car.top.door.front.left.and.rear.right.open"), + CAR_TOP_DOOR_FRONT_LEFT_AND_REAR_RIGHT_OPEN_FILL("car.top.door.front.left.and.rear.right.open.fill"), + CAR_TOP_DOOR_FRONT_LEFT_OPEN("car.top.door.front.left.open"), + CAR_TOP_DOOR_FRONT_LEFT_OPEN_FILL("car.top.door.front.left.open.fill"), + CAR_TOP_DOOR_FRONT_RIGHT_AND_REAR_LEFT_AND_REAR_RIGHT_OPEN("car.top.door.front.right.and.rear.left.and.rear.right.open"), + CAR_TOP_DOOR_FRONT_RIGHT_AND_REAR_LEFT_AND_REAR_RIGHT_OPEN_FILL("car.top.door.front.right.and.rear.left.and.rear.right.open.fill"), + CAR_TOP_DOOR_FRONT_RIGHT_AND_REAR_LEFT_OPEN("car.top.door.front.right.and.rear.left.open"), + CAR_TOP_DOOR_FRONT_RIGHT_AND_REAR_LEFT_OPEN_FILL("car.top.door.front.right.and.rear.left.open.fill"), + CAR_TOP_DOOR_FRONT_RIGHT_AND_REAR_RIGHT_OPEN("car.top.door.front.right.and.rear.right.open"), + CAR_TOP_DOOR_FRONT_RIGHT_AND_REAR_RIGHT_OPEN_FILL("car.top.door.front.right.and.rear.right.open.fill"), + CAR_TOP_DOOR_FRONT_RIGHT_OPEN("car.top.door.front.right.open"), + CAR_TOP_DOOR_FRONT_RIGHT_OPEN_FILL("car.top.door.front.right.open.fill"), + CAR_TOP_DOOR_REAR_LEFT_AND_REAR_RIGHT_OPEN("car.top.door.rear.left.and.rear.right.open"), + CAR_TOP_DOOR_REAR_LEFT_AND_REAR_RIGHT_OPEN_FILL("car.top.door.rear.left.and.rear.right.open.fill"), + CAR_TOP_DOOR_REAR_LEFT_OPEN("car.top.door.rear.left.open"), + CAR_TOP_DOOR_REAR_LEFT_OPEN_FILL("car.top.door.rear.left.open.fill"), + CAR_TOP_DOOR_REAR_RIGHT_OPEN("car.top.door.rear.right.open"), + CAR_TOP_DOOR_REAR_RIGHT_OPEN_FILL("car.top.door.rear.right.open.fill"), + CAR_TOP_DOOR_SLIDING_LEFT_OPEN("car.top.door.sliding.left.open"), + CAR_TOP_DOOR_SLIDING_LEFT_OPEN_FILL("car.top.door.sliding.left.open.fill"), + CAR_TOP_DOOR_SLIDING_RIGHT_OPEN("car.top.door.sliding.right.open"), + CAR_TOP_DOOR_SLIDING_RIGHT_OPEN_FILL("car.top.door.sliding.right.open.fill"), + CAR_TOP_FRONT_RADIOWAVES_FRONT_LEFT_AND_FRONT_AND_FRONT_RIGHT("car.top.front.radiowaves.front.left.and.front.and.front.right"), + CAR_TOP_FRONT_RADIOWAVES_FRONT_LEFT_AND_FRONT_AND_FRONT_RIGHT_FILL("car.top.front.radiowaves.front.left.and.front.and.front.right.fill"), + CAR_TOP_LANE_DASHED_ARROWTRIANGLE_INWARD("car.top.lane.dashed.arrowtriangle.inward"), + CAR_TOP_LANE_DASHED_ARROWTRIANGLE_INWARD_FILL("car.top.lane.dashed.arrowtriangle.inward.fill"), + CAR_TOP_LANE_DASHED_BADGE_STEERINGWHEEL("car.top.lane.dashed.badge.steeringwheel"), + CAR_TOP_LANE_DASHED_BADGE_STEERINGWHEEL_FILL("car.top.lane.dashed.badge.steeringwheel.fill"), + CAR_TOP_LANE_DASHED_DEPARTURE_LEFT("car.top.lane.dashed.departure.left"), + CAR_TOP_LANE_DASHED_DEPARTURE_LEFT_FILL("car.top.lane.dashed.departure.left.fill"), + CAR_TOP_LANE_DASHED_DEPARTURE_RIGHT("car.top.lane.dashed.departure.right"), + CAR_TOP_LANE_DASHED_DEPARTURE_RIGHT_FILL("car.top.lane.dashed.departure.right.fill"), + CAR_TOP_RADIOWAVES_FRONT("car.top.radiowaves.front"), + CAR_TOP_RADIOWAVES_FRONT_FILL("car.top.radiowaves.front.fill"), + CAR_TOP_RADIOWAVES_REAR("car.top.radiowaves.rear"), + CAR_TOP_RADIOWAVES_REAR_FILL("car.top.radiowaves.rear.fill"), + CAR_TOP_RADIOWAVES_REAR_LEFT("car.top.radiowaves.rear.left"), + CAR_TOP_RADIOWAVES_REAR_LEFT_AND_REAR_RIGHT("car.top.radiowaves.rear.left.and.rear.right"), + CAR_TOP_RADIOWAVES_REAR_LEFT_AND_REAR_RIGHT_FILL("car.top.radiowaves.rear.left.and.rear.right.fill"), + CAR_TOP_RADIOWAVES_REAR_LEFT_CAR_TOP_FRONT("car.top.radiowaves.rear.left.car.top.front"), + CAR_TOP_RADIOWAVES_REAR_LEFT_CAR_TOP_FRONT_FILL("car.top.radiowaves.rear.left.car.top.front.fill"), + CAR_TOP_RADIOWAVES_REAR_LEFT_FILL("car.top.radiowaves.rear.left.fill"), + CAR_TOP_RADIOWAVES_REAR_RIGHT("car.top.radiowaves.rear.right"), + CAR_TOP_RADIOWAVES_REAR_RIGHT_BADGE_EXCLAMATIONMARK("car.top.radiowaves.rear.right.badge.exclamationmark"), + CAR_TOP_RADIOWAVES_REAR_RIGHT_BADGE_EXCLAMATIONMARK_FILL("car.top.radiowaves.rear.right.badge.exclamationmark.fill"), + CAR_TOP_RADIOWAVES_REAR_RIGHT_BADGE_XMARK("car.top.radiowaves.rear.right.badge.xmark"), + CAR_TOP_RADIOWAVES_REAR_RIGHT_BADGE_XMARK_FILL("car.top.radiowaves.rear.right.badge.xmark.fill"), + CAR_TOP_RADIOWAVES_REAR_RIGHT_CAR_TOP_FRONT("car.top.radiowaves.rear.right.car.top.front"), + CAR_TOP_RADIOWAVES_REAR_RIGHT_CAR_TOP_FRONT_FILL("car.top.radiowaves.rear.right.car.top.front.fill"), + CAR_TOP_RADIOWAVES_REAR_RIGHT_FILL("car.top.radiowaves.rear.right.fill"), + CAR_TOP_REAR_RADIOWAVES_REAR_LEFT_AND_REAR_AND_REAR_RIGHT("car.top.rear.radiowaves.rear.left.and.rear.and.rear.right"), + CAR_TOP_REAR_RADIOWAVES_REAR_LEFT_AND_REAR_AND_REAR_RIGHT_FILL("car.top.rear.radiowaves.rear.left.and.rear.and.rear.right.fill"), + CAR_WINDOW_LEFT("car.window.left"), + CAR_WINDOW_LEFT_BADGE_EXCLAMATIONMARK("car.window.left.badge.exclamationmark"), + CAR_WINDOW_LEFT_BADGE_XMARK("car.window.left.badge.xmark"), + CAR_WINDOW_LEFT_EXCLAMATIONMARK("car.window.left.exclamationmark"), + CAR_WINDOW_LEFT_XMARK("car.window.left.xmark"), + CAR_WINDOW_RIGHT("car.window.right"), + CAR_WINDOW_RIGHT_BADGE_EXCLAMATIONMARK("car.window.right.badge.exclamationmark"), + CAR_WINDOW_RIGHT_BADGE_XMARK("car.window.right.badge.xmark"), + CAR_WINDOW_RIGHT_EXCLAMATIONMARK("car.window.right.exclamationmark"), + CAR_WINDOW_RIGHT_XMARK("car.window.right.xmark"), + CARBON_DIOXIDE_CLOUD("carbon.dioxide.cloud"), + CARBON_DIOXIDE_CLOUD_FILL("carbon.dioxide.cloud.fill"), + CARBON_MONOXIDE_CLOUD("carbon.monoxide.cloud"), + CARBON_MONOXIDE_CLOUD_FILL("carbon.monoxide.cloud.fill"), + CARROT("carrot"), + CARROT_FILL("carrot.fill"), + CARSEAT_LEFT("carseat.left"), + CARSEAT_LEFT_1("carseat.left.1"), + CARSEAT_LEFT_1_FILL("carseat.left.1.fill"), + CARSEAT_LEFT_2("carseat.left.2"), + CARSEAT_LEFT_2_FILL("carseat.left.2.fill"), + CARSEAT_LEFT_3("carseat.left.3"), + CARSEAT_LEFT_3_FILL("carseat.left.3.fill"), + CARSEAT_LEFT_AND_HEAT_WAVES("carseat.left.and.heat.waves"), + CARSEAT_LEFT_AND_HEAT_WAVES_FILL("carseat.left.and.heat.waves.fill"), + CARSEAT_LEFT_BACKREST_UP_AND_DOWN("carseat.left.backrest.up.and.down"), + CARSEAT_LEFT_BACKREST_UP_AND_DOWN_FILL("carseat.left.backrest.up.and.down.fill"), + CARSEAT_LEFT_FAN("carseat.left.fan"), + CARSEAT_LEFT_FAN_FILL("carseat.left.fan.fill"), + CARSEAT_LEFT_FILL("carseat.left.fill"), + CARSEAT_LEFT_FORWARD_AND_BACKWARD("carseat.left.forward.and.backward"), + CARSEAT_LEFT_FORWARD_AND_BACKWARD_FILL("carseat.left.forward.and.backward.fill"), + CARSEAT_LEFT_MASSAGE("carseat.left.massage"), + CARSEAT_LEFT_MASSAGE_FILL("carseat.left.massage.fill"), + CARSEAT_LEFT_UP_AND_DOWN("carseat.left.up.and.down"), + CARSEAT_LEFT_UP_AND_DOWN_FILL("carseat.left.up.and.down.fill"), + CARSEAT_RIGHT("carseat.right"), + CARSEAT_RIGHT_1("carseat.right.1"), + CARSEAT_RIGHT_1_FILL("carseat.right.1.fill"), + CARSEAT_RIGHT_2("carseat.right.2"), + CARSEAT_RIGHT_2_FILL("carseat.right.2.fill"), + CARSEAT_RIGHT_3("carseat.right.3"), + CARSEAT_RIGHT_3_FILL("carseat.right.3.fill"), + CARSEAT_RIGHT_AND_HEAT_WAVES("carseat.right.and.heat.waves"), + CARSEAT_RIGHT_AND_HEAT_WAVES_FILL("carseat.right.and.heat.waves.fill"), + CARSEAT_RIGHT_BACKREST_UP_AND_DOWN("carseat.right.backrest.up.and.down"), + CARSEAT_RIGHT_BACKREST_UP_AND_DOWN_FILL("carseat.right.backrest.up.and.down.fill"), + CARSEAT_RIGHT_FAN("carseat.right.fan"), + CARSEAT_RIGHT_FAN_FILL("carseat.right.fan.fill"), + CARSEAT_RIGHT_FILL("carseat.right.fill"), + CARSEAT_RIGHT_FORWARD_AND_BACKWARD("carseat.right.forward.and.backward"), + CARSEAT_RIGHT_FORWARD_AND_BACKWARD_FILL("carseat.right.forward.and.backward.fill"), + CARSEAT_RIGHT_MASSAGE("carseat.right.massage"), + CARSEAT_RIGHT_MASSAGE_FILL("carseat.right.massage.fill"), + CARSEAT_RIGHT_UP_AND_DOWN("carseat.right.up.and.down"), + CARSEAT_RIGHT_UP_AND_DOWN_FILL("carseat.right.up.and.down.fill"), + CART("cart"), + CART_BADGE_MINUS("cart.badge.minus"), + CART_BADGE_PLUS("cart.badge.plus"), + CART_BADGE_QUESTIONMARK("cart.badge.questionmark"), + CART_CIRCLE("cart.circle"), + CART_CIRCLE_FILL("cart.circle.fill"), + CART_FILL("cart.fill"), + CART_FILL_BADGE_MINUS("cart.fill.badge.minus"), + CART_FILL_BADGE_PLUS("cart.fill.badge.plus"), + CART_FILL_BADGE_QUESTIONMARK("cart.fill.badge.questionmark"), + CONVERTIBLE_SIDE("convertible.side"), + CONVERTIBLE_SIDE_AIR_CIRCULATE("convertible.side.air.circulate"), + CONVERTIBLE_SIDE_AIR_CIRCULATE_FILL("convertible.side.air.circulate.fill"), + CONVERTIBLE_SIDE_AIR_FRESH("convertible.side.air.fresh"), + CONVERTIBLE_SIDE_AIR_FRESH_FILL("convertible.side.air.fresh.fill"), + CONVERTIBLE_SIDE_AND_EXCLAMATIONMARK("convertible.side.and.exclamationmark"), + CONVERTIBLE_SIDE_AND_EXCLAMATIONMARK_FILL("convertible.side.and.exclamationmark.fill"), + CONVERTIBLE_SIDE_ARROW_TRIANGLEHEAD_BACKWARD("convertible.side.arrow.trianglehead.backward"), + CONVERTIBLE_SIDE_ARROW_TRIANGLEHEAD_BACKWARD_FILL("convertible.side.arrow.trianglehead.backward.fill"), + CONVERTIBLE_SIDE_ARROW_TRIANGLEHEAD_FORWARD("convertible.side.arrow.trianglehead.forward"), + CONVERTIBLE_SIDE_ARROW_TRIANGLEHEAD_FORWARD_AND_BACKWARD("convertible.side.arrow.trianglehead.forward.and.backward"), + CONVERTIBLE_SIDE_ARROW_TRIANGLEHEAD_FORWARD_AND_BACKWARD_FILL("convertible.side.arrow.trianglehead.forward.and.backward.fill"), + CONVERTIBLE_SIDE_ARROW_TRIANGLEHEAD_FORWARD_FILL("convertible.side.arrow.trianglehead.forward.fill"), + CONVERTIBLE_SIDE_ARROWTRIANGLE_DOWN("convertible.side.arrowtriangle.down"), + CONVERTIBLE_SIDE_ARROWTRIANGLE_DOWN_FILL("convertible.side.arrowtriangle.down.fill"), + CONVERTIBLE_SIDE_ARROWTRIANGLE_UP("convertible.side.arrowtriangle.up"), + CONVERTIBLE_SIDE_ARROWTRIANGLE_UP_ARROWTRIANGLE_DOWN("convertible.side.arrowtriangle.up.arrowtriangle.down"), + CONVERTIBLE_SIDE_ARROWTRIANGLE_UP_ARROWTRIANGLE_DOWN_FILL("convertible.side.arrowtriangle.up.arrowtriangle.down.fill"), + CONVERTIBLE_SIDE_ARROWTRIANGLE_UP_FILL("convertible.side.arrowtriangle.up.fill"), + CONVERTIBLE_SIDE_FILL("convertible.side.fill"), + CONVERTIBLE_SIDE_FRONT_OPEN("convertible.side.front.open"), + CONVERTIBLE_SIDE_FRONT_OPEN_CROP("convertible.side.front.open.crop"), + CONVERTIBLE_SIDE_FRONT_OPEN_CROP_FILL("convertible.side.front.open.crop.fill"), + CONVERTIBLE_SIDE_FRONT_OPEN_FILL("convertible.side.front.open.fill"), + CONVERTIBLE_SIDE_HILL_DOWN("convertible.side.hill.down"), + CONVERTIBLE_SIDE_HILL_DOWN_FILL("convertible.side.hill.down.fill"), + CONVERTIBLE_SIDE_HILL_UP("convertible.side.hill.up"), + CONVERTIBLE_SIDE_HILL_UP_FILL("convertible.side.hill.up.fill"), + CONVERTIBLE_SIDE_LOCK("convertible.side.lock"), + CONVERTIBLE_SIDE_LOCK_FILL("convertible.side.lock.fill"), + CONVERTIBLE_SIDE_LOCK_OPEN("convertible.side.lock.open"), + CONVERTIBLE_SIDE_LOCK_OPEN_FILL("convertible.side.lock.open.fill"), + ENGINE_COMBUSTION("engine.combustion"), + ENGINE_COMBUSTION_BADGE_EXCLAMATIONMARK("engine.combustion.badge.exclamationmark"), + ENGINE_COMBUSTION_BADGE_EXCLAMATIONMARK_FILL("engine.combustion.badge.exclamationmark.fill"), + ENGINE_COMBUSTION_FILL("engine.combustion.fill"), + EV_CHARGER("ev.charger"), + EV_CHARGER_ARROWTRIANGLE_LEFT("ev.charger.arrowtriangle.left"), + EV_CHARGER_ARROWTRIANGLE_LEFT_FILL("ev.charger.arrowtriangle.left.fill"), + EV_CHARGER_ARROWTRIANGLE_RIGHT("ev.charger.arrowtriangle.right"), + EV_CHARGER_ARROWTRIANGLE_RIGHT_FILL("ev.charger.arrowtriangle.right.fill"), + EV_CHARGER_EXCLAMATIONMARK("ev.charger.exclamationmark"), + EV_CHARGER_EXCLAMATIONMARK_FILL("ev.charger.exclamationmark.fill"), + EV_CHARGER_FILL("ev.charger.fill"), + EV_CHARGER_SLASH("ev.charger.slash"), + EV_CHARGER_SLASH_FILL("ev.charger.slash.fill"), + EV_PLUG_AC_GB_T("ev.plug.ac.gb.t"), + EV_PLUG_AC_GB_T_FILL("ev.plug.ac.gb.t.fill"), + EV_PLUG_AC_TYPE_1("ev.plug.ac.type.1"), + EV_PLUG_AC_TYPE_1_FILL("ev.plug.ac.type.1.fill"), + EV_PLUG_AC_TYPE_2("ev.plug.ac.type.2"), + EV_PLUG_AC_TYPE_2_FILL("ev.plug.ac.type.2.fill"), + EV_PLUG_DC_CCS1("ev.plug.dc.ccs1"), + EV_PLUG_DC_CCS1_FILL("ev.plug.dc.ccs1.fill"), + EV_PLUG_DC_CCS2("ev.plug.dc.ccs2"), + EV_PLUG_DC_CCS2_FILL("ev.plug.dc.ccs2.fill"), + EV_PLUG_DC_CHADEMO("ev.plug.dc.chademo"), + EV_PLUG_DC_CHADEMO_FILL("ev.plug.dc.chademo.fill"), + EV_PLUG_DC_GB_T("ev.plug.dc.gb.t"), + EV_PLUG_DC_GB_T_FILL("ev.plug.dc.gb.t.fill"), + EV_PLUG_DC_NACS("ev.plug.dc.nacs"), + EV_PLUG_DC_NACS_FILL("ev.plug.dc.nacs.fill"), + FAN("fan"), + FAN_AND_LIGHT_CEILING("fan.and.light.ceiling"), + FAN_AND_LIGHT_CEILING_FILL("fan.and.light.ceiling.fill"), + FAN_BADGE_AUTOMATIC("fan.badge.automatic"), + FAN_BADGE_AUTOMATIC_FILL("fan.badge.automatic.fill"), + FAN_CEILING("fan.ceiling"), + FAN_CEILING_FILL("fan.ceiling.fill"), + FAN_DESK("fan.desk"), + FAN_DESK_FILL("fan.desk.fill"), + FAN_FILL("fan.fill"), + FAN_FLOOR("fan.floor"), + FAN_FLOOR_FILL("fan.floor.fill"), + FAN_OSCILLATION("fan.oscillation"), + FAN_OSCILLATION_FILL("fan.oscillation.fill"), + FAN_SLASH("fan.slash"), + FAN_SLASH_FILL("fan.slash.fill"), + FERRY("ferry"), + FERRY_FILL("ferry.fill"), + FUELPUMP("fuelpump"), + FUELPUMP_AND_FILTER("fuelpump.and.filter"), + FUELPUMP_ARROWTRIANGLE_LEFT("fuelpump.arrowtriangle.left"), + FUELPUMP_ARROWTRIANGLE_LEFT_FILL("fuelpump.arrowtriangle.left.fill"), + FUELPUMP_ARROWTRIANGLE_RIGHT("fuelpump.arrowtriangle.right"), + FUELPUMP_ARROWTRIANGLE_RIGHT_FILL("fuelpump.arrowtriangle.right.fill"), + FUELPUMP_CIRCLE("fuelpump.circle"), + FUELPUMP_CIRCLE_FILL("fuelpump.circle.fill"), + FUELPUMP_EXCLAMATIONMARK("fuelpump.exclamationmark"), + FUELPUMP_EXCLAMATIONMARK_FILL("fuelpump.exclamationmark.fill"), + FUELPUMP_FILL("fuelpump.fill"), + FUELPUMP_SLASH("fuelpump.slash"), + FUELPUMP_SLASH_FILL("fuelpump.slash.fill"), + OILCAN("oilcan"), + OILCAN_AND_THERMOMETER("oilcan.and.thermometer"), + OILCAN_AND_THERMOMETER_FILL("oilcan.and.thermometer.fill"), + OILCAN_FILL("oilcan.fill"), + PARKINGSIGN("parkingsign"), + PARKINGSIGN_BRAKESIGNAL("parkingsign.brakesignal"), + PARKINGSIGN_BRAKESIGNAL_SLASH("parkingsign.brakesignal.slash"), + PARKINGSIGN_CIRCLE("parkingsign.circle"), + PARKINGSIGN_CIRCLE_FILL("parkingsign.circle.fill"), + PARKINGSIGN_RADIOWAVES_LEFT_AND_RIGHT("parkingsign.radiowaves.left.and.right"), + PARKINGSIGN_RADIOWAVES_LEFT_AND_RIGHT_SLASH("parkingsign.radiowaves.left.and.right.slash"), + PARKINGSIGN_RADIOWAVES_RIGHT_AND_SAFETYCONE("parkingsign.radiowaves.right.and.safetycone"), + PARKINGSIGN_SQUARE("parkingsign.square"), + PARKINGSIGN_SQUARE_FILL("parkingsign.square.fill"), + PARKINGSIGN_STEERINGWHEEL("parkingsign.steeringwheel"), + ROAD_LANE_ARROWTRIANGLE_2_INWARD("road.lane.arrowtriangle.2.inward"), + ROAD_LANES("road.lanes"), + ROAD_LANES_CURVED_LEFT("road.lanes.curved.left"), + ROAD_LANES_CURVED_RIGHT("road.lanes.curved.right"), + SAILBOAT("sailboat"), + SAILBOAT_CIRCLE("sailboat.circle"), + SAILBOAT_CIRCLE_FILL("sailboat.circle.fill"), + SAILBOAT_FILL("sailboat.fill"), + SCOOTER("scooter"), + STEERINGWHEEL("steeringwheel"), + STEERINGWHEEL_AND_HANDS("steeringwheel.and.hands"), + STEERINGWHEEL_AND_HEAT_WAVES("steeringwheel.and.heat.waves"), + STEERINGWHEEL_AND_KEY("steeringwheel.and.key"), + STEERINGWHEEL_AND_LIQUID_WAVE("steeringwheel.and.liquid.wave"), + STEERINGWHEEL_AND_LOCK("steeringwheel.and.lock"), + STEERINGWHEEL_ARROW_TRIANGLEHEAD_COUNTERCLOCKWISE_AND_CLOCKWISE("steeringwheel.arrow.trianglehead.counterclockwise.and.clockwise"), + STEERINGWHEEL_ARROWTRIANGLE_LEFT("steeringwheel.arrowtriangle.left"), + STEERINGWHEEL_ARROWTRIANGLE_RIGHT("steeringwheel.arrowtriangle.right"), + STEERINGWHEEL_BADGE_EXCLAMATIONMARK("steeringwheel.badge.exclamationmark"), + STEERINGWHEEL_CIRCLE("steeringwheel.circle"), + STEERINGWHEEL_CIRCLE_FILL("steeringwheel.circle.fill"), + STEERINGWHEEL_EXCLAMATIONMARK("steeringwheel.exclamationmark"), + STEERINGWHEEL_ROAD_LANE("steeringwheel.road.lane"), + STEERINGWHEEL_ROAD_LANE_DASHED("steeringwheel.road.lane.dashed"), + STEERINGWHEEL_SLASH("steeringwheel.slash"), + SUV_SIDE("suv.side"), + SUV_SIDE_AIR_CIRCULATE("suv.side.air.circulate"), + SUV_SIDE_AIR_CIRCULATE_FILL("suv.side.air.circulate.fill"), + SUV_SIDE_AIR_FRESH("suv.side.air.fresh"), + SUV_SIDE_AIR_FRESH_FILL("suv.side.air.fresh.fill"), + SUV_SIDE_AND_EXCLAMATIONMARK("suv.side.and.exclamationmark"), + SUV_SIDE_AND_EXCLAMATIONMARK_FILL("suv.side.and.exclamationmark.fill"), + SUV_SIDE_ARROWTRIANGLE_DOWN("suv.side.arrowtriangle.down"), + SUV_SIDE_ARROWTRIANGLE_DOWN_FILL("suv.side.arrowtriangle.down.fill"), + SUV_SIDE_ARROWTRIANGLE_UP("suv.side.arrowtriangle.up"), + SUV_SIDE_ARROWTRIANGLE_UP_ARROWTRIANGLE_DOWN("suv.side.arrowtriangle.up.arrowtriangle.down"), + SUV_SIDE_ARROWTRIANGLE_UP_ARROWTRIANGLE_DOWN_FILL("suv.side.arrowtriangle.up.arrowtriangle.down.fill"), + SUV_SIDE_ARROWTRIANGLE_UP_FILL("suv.side.arrowtriangle.up.fill"), + SUV_SIDE_FILL("suv.side.fill"), + SUV_SIDE_FRONT_OPEN("suv.side.front.open"), + SUV_SIDE_FRONT_OPEN_CROP("suv.side.front.open.crop"), + SUV_SIDE_FRONT_OPEN_CROP_FILL("suv.side.front.open.crop.fill"), + SUV_SIDE_FRONT_OPEN_FILL("suv.side.front.open.fill"), + SUV_SIDE_HILL_DOWN("suv.side.hill.down"), + SUV_SIDE_HILL_DOWN_FILL("suv.side.hill.down.fill"), + SUV_SIDE_HILL_UP("suv.side.hill.up"), + SUV_SIDE_HILL_UP_FILL("suv.side.hill.up.fill"), + SUV_SIDE_LOCK("suv.side.lock"), + SUV_SIDE_LOCK_FILL("suv.side.lock.fill"), + SUV_SIDE_LOCK_OPEN("suv.side.lock.open"), + SUV_SIDE_LOCK_OPEN_FILL("suv.side.lock.open.fill"), + SUV_SIDE_REAR_OPEN("suv.side.rear.open"), + SUV_SIDE_REAR_OPEN_CROP("suv.side.rear.open.crop"), + SUV_SIDE_REAR_OPEN_CROP_FILL("suv.side.rear.open.crop.fill"), + SUV_SIDE_REAR_OPEN_FILL("suv.side.rear.open.fill"), + TRAIN_SIDE_FRONT_CAR("train.side.front.car"), + TRAIN_SIDE_MIDDLE_CAR("train.side.middle.car"), + TRAIN_SIDE_REAR_CAR("train.side.rear.car"), + TRAM("tram"), + TRAM_CIRCLE("tram.circle"), + TRAM_CIRCLE_FILL("tram.circle.fill"), + TRAM_FILL("tram.fill"), + TRAM_FILL_TUNNEL("tram.fill.tunnel"), + TRUCK_BOX("truck.box"), + TRUCK_BOX_BADGE_CLOCK("truck.box.badge.clock"), + TRUCK_BOX_BADGE_CLOCK_FILL("truck.box.badge.clock.fill"), + TRUCK_BOX_FILL("truck.box.fill"), + TRUCK_PICKUP_SIDE("truck.pickup.side"), + TRUCK_PICKUP_SIDE_AIR_CIRCULATE("truck.pickup.side.air.circulate"), + TRUCK_PICKUP_SIDE_AIR_CIRCULATE_FILL("truck.pickup.side.air.circulate.fill"), + TRUCK_PICKUP_SIDE_AIR_FRESH("truck.pickup.side.air.fresh"), + TRUCK_PICKUP_SIDE_AIR_FRESH_FILL("truck.pickup.side.air.fresh.fill"), + TRUCK_PICKUP_SIDE_AND_EXCLAMATIONMARK("truck.pickup.side.and.exclamationmark"), + TRUCK_PICKUP_SIDE_AND_EXCLAMATIONMARK_FILL("truck.pickup.side.and.exclamationmark.fill"), + TRUCK_PICKUP_SIDE_ARROWTRIANGLE_DOWN("truck.pickup.side.arrowtriangle.down"), + TRUCK_PICKUP_SIDE_ARROWTRIANGLE_DOWN_FILL("truck.pickup.side.arrowtriangle.down.fill"), + TRUCK_PICKUP_SIDE_ARROWTRIANGLE_UP("truck.pickup.side.arrowtriangle.up"), + TRUCK_PICKUP_SIDE_ARROWTRIANGLE_UP_ARROWTRIANGLE_DOWN("truck.pickup.side.arrowtriangle.up.arrowtriangle.down"), + TRUCK_PICKUP_SIDE_ARROWTRIANGLE_UP_ARROWTRIANGLE_DOWN_FILL("truck.pickup.side.arrowtriangle.up.arrowtriangle.down.fill"), + TRUCK_PICKUP_SIDE_ARROWTRIANGLE_UP_FILL("truck.pickup.side.arrowtriangle.up.fill"), + TRUCK_PICKUP_SIDE_FILL("truck.pickup.side.fill"), + TRUCK_PICKUP_SIDE_FRONT_OPEN("truck.pickup.side.front.open"), + TRUCK_PICKUP_SIDE_FRONT_OPEN_CROP("truck.pickup.side.front.open.crop"), + TRUCK_PICKUP_SIDE_FRONT_OPEN_CROP_FILL("truck.pickup.side.front.open.crop.fill"), + TRUCK_PICKUP_SIDE_FRONT_OPEN_FILL("truck.pickup.side.front.open.fill"), + TRUCK_PICKUP_SIDE_HILL_DOWN("truck.pickup.side.hill.down"), + TRUCK_PICKUP_SIDE_HILL_DOWN_FILL("truck.pickup.side.hill.down.fill"), + TRUCK_PICKUP_SIDE_HILL_UP("truck.pickup.side.hill.up"), + TRUCK_PICKUP_SIDE_HILL_UP_FILL("truck.pickup.side.hill.up.fill"), + TRUCK_PICKUP_SIDE_LOCK("truck.pickup.side.lock"), + TRUCK_PICKUP_SIDE_LOCK_FILL("truck.pickup.side.lock.fill"), + TRUCK_PICKUP_SIDE_LOCK_OPEN("truck.pickup.side.lock.open"), + TRUCK_PICKUP_SIDE_LOCK_OPEN_FILL("truck.pickup.side.lock.open.fill"), +} diff --git a/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolWeather.kt b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolWeather.kt new file mode 100644 index 00000000..5b52b012 --- /dev/null +++ b/sf-symbols/src/main/kotlin/io/github/kdroidfilter/nucleus/sfsymbols/SFSymbolWeather.kt @@ -0,0 +1,293 @@ +package io.github.kdroidfilter.nucleus.sfsymbols + +/** SF Symbols — Weather (286 symbols). */ +enum class SFSymbolWeather( + override val symbolName: String, +) : SFSymbol { + BOLT("bolt"), + BOLT_BADGE_AUTOMATIC("bolt.badge.automatic"), + BOLT_BADGE_AUTOMATIC_FILL("bolt.badge.automatic.fill"), + BOLT_BADGE_CHECKMARK("bolt.badge.checkmark"), + BOLT_BADGE_CHECKMARK_FILL("bolt.badge.checkmark.fill"), + BOLT_BADGE_CLOCK("bolt.badge.clock"), + BOLT_BADGE_CLOCK_FILL("bolt.badge.clock.fill"), + BOLT_BADGE_XMARK("bolt.badge.xmark"), + BOLT_BADGE_XMARK_FILL("bolt.badge.xmark.fill"), + BOLT_BATTERYBLOCK("bolt.batteryblock"), + BOLT_BATTERYBLOCK_FILL("bolt.batteryblock.fill"), + BOLT_BRAKESIGNAL("bolt.brakesignal"), + BOLT_CAR("bolt.car"), + BOLT_CAR_CIRCLE("bolt.car.circle"), + BOLT_CAR_CIRCLE_FILL("bolt.car.circle.fill"), + BOLT_CAR_FILL("bolt.car.fill"), + BOLT_CIRCLE("bolt.circle"), + BOLT_CIRCLE_FILL("bolt.circle.fill"), + BOLT_FILL("bolt.fill"), + BOLT_HEART("bolt.heart"), + BOLT_HEART_FILL("bolt.heart.fill"), + BOLT_HORIZONTAL("bolt.horizontal"), + BOLT_HORIZONTAL_CIRCLE("bolt.horizontal.circle"), + BOLT_HORIZONTAL_CIRCLE_FILL("bolt.horizontal.circle.fill"), + BOLT_HORIZONTAL_FILL("bolt.horizontal.fill"), + BOLT_HORIZONTAL_ICLOUD("bolt.horizontal.icloud"), + BOLT_HORIZONTAL_ICLOUD_FILL("bolt.horizontal.icloud.fill"), + BOLT_RING_CLOSED("bolt.ring.closed"), + BOLT_SHIELD("bolt.shield"), + BOLT_SHIELD_FILL("bolt.shield.fill"), + BOLT_SLASH("bolt.slash"), + BOLT_SLASH_CIRCLE("bolt.slash.circle"), + BOLT_SLASH_CIRCLE_FILL("bolt.slash.circle.fill"), + BOLT_SLASH_FILL("bolt.slash.fill"), + BOLT_SQUARE("bolt.square"), + BOLT_SQUARE_FILL("bolt.square.fill"), + BOLT_TRIANGLEBADGE_EXCLAMATIONMARK("bolt.trianglebadge.exclamationmark"), + BOLT_TRIANGLEBADGE_EXCLAMATIONMARK_FILL("bolt.trianglebadge.exclamationmark.fill"), + CLOUD("cloud"), + CLOUD_BOLT("cloud.bolt"), + CLOUD_BOLT_CIRCLE("cloud.bolt.circle"), + CLOUD_BOLT_CIRCLE_FILL("cloud.bolt.circle.fill"), + CLOUD_BOLT_FILL("cloud.bolt.fill"), + CLOUD_BOLT_RAIN("cloud.bolt.rain"), + CLOUD_BOLT_RAIN_CIRCLE("cloud.bolt.rain.circle"), + CLOUD_BOLT_RAIN_CIRCLE_FILL("cloud.bolt.rain.circle.fill"), + CLOUD_BOLT_RAIN_FILL("cloud.bolt.rain.fill"), + CLOUD_CIRCLE("cloud.circle"), + CLOUD_CIRCLE_FILL("cloud.circle.fill"), + CLOUD_DRIZZLE("cloud.drizzle"), + CLOUD_DRIZZLE_CIRCLE("cloud.drizzle.circle"), + CLOUD_DRIZZLE_CIRCLE_FILL("cloud.drizzle.circle.fill"), + CLOUD_DRIZZLE_FILL("cloud.drizzle.fill"), + CLOUD_FILL("cloud.fill"), + CLOUD_FOG("cloud.fog"), + CLOUD_FOG_CIRCLE("cloud.fog.circle"), + CLOUD_FOG_CIRCLE_FILL("cloud.fog.circle.fill"), + CLOUD_FOG_FILL("cloud.fog.fill"), + CLOUD_HAIL("cloud.hail"), + CLOUD_HAIL_CIRCLE("cloud.hail.circle"), + CLOUD_HAIL_CIRCLE_FILL("cloud.hail.circle.fill"), + CLOUD_HAIL_FILL("cloud.hail.fill"), + CLOUD_HEAVYRAIN("cloud.heavyrain"), + CLOUD_HEAVYRAIN_CIRCLE("cloud.heavyrain.circle"), + CLOUD_HEAVYRAIN_CIRCLE_FILL("cloud.heavyrain.circle.fill"), + CLOUD_HEAVYRAIN_FILL("cloud.heavyrain.fill"), + CLOUD_MOON("cloud.moon"), + CLOUD_MOON_BOLT("cloud.moon.bolt"), + CLOUD_MOON_BOLT_CIRCLE("cloud.moon.bolt.circle"), + CLOUD_MOON_BOLT_CIRCLE_FILL("cloud.moon.bolt.circle.fill"), + CLOUD_MOON_BOLT_FILL("cloud.moon.bolt.fill"), + CLOUD_MOON_CIRCLE("cloud.moon.circle"), + CLOUD_MOON_CIRCLE_FILL("cloud.moon.circle.fill"), + CLOUD_MOON_FILL("cloud.moon.fill"), + CLOUD_MOON_RAIN("cloud.moon.rain"), + CLOUD_MOON_RAIN_CIRCLE("cloud.moon.rain.circle"), + CLOUD_MOON_RAIN_CIRCLE_FILL("cloud.moon.rain.circle.fill"), + CLOUD_MOON_RAIN_FILL("cloud.moon.rain.fill"), + CLOUD_RAIN("cloud.rain"), + CLOUD_RAIN_CIRCLE("cloud.rain.circle"), + CLOUD_RAIN_CIRCLE_FILL("cloud.rain.circle.fill"), + CLOUD_RAIN_FILL("cloud.rain.fill"), + CLOUD_RAINBOW_CROP("cloud.rainbow.crop"), + CLOUD_RAINBOW_CROP_FILL("cloud.rainbow.crop.fill"), + CLOUD_SLEET("cloud.sleet"), + CLOUD_SLEET_CIRCLE("cloud.sleet.circle"), + CLOUD_SLEET_CIRCLE_FILL("cloud.sleet.circle.fill"), + CLOUD_SLEET_FILL("cloud.sleet.fill"), + CLOUD_SNOW("cloud.snow"), + CLOUD_SNOW_CIRCLE("cloud.snow.circle"), + CLOUD_SNOW_CIRCLE_FILL("cloud.snow.circle.fill"), + CLOUD_SNOW_FILL("cloud.snow.fill"), + CLOUD_SUN("cloud.sun"), + CLOUD_SUN_BOLT("cloud.sun.bolt"), + CLOUD_SUN_BOLT_CIRCLE("cloud.sun.bolt.circle"), + CLOUD_SUN_BOLT_CIRCLE_FILL("cloud.sun.bolt.circle.fill"), + CLOUD_SUN_BOLT_FILL("cloud.sun.bolt.fill"), + CLOUD_SUN_CIRCLE("cloud.sun.circle"), + CLOUD_SUN_CIRCLE_FILL("cloud.sun.circle.fill"), + CLOUD_SUN_FILL("cloud.sun.fill"), + CLOUD_SUN_RAIN("cloud.sun.rain"), + CLOUD_SUN_RAIN_CIRCLE("cloud.sun.rain.circle"), + CLOUD_SUN_RAIN_CIRCLE_FILL("cloud.sun.rain.circle.fill"), + CLOUD_SUN_RAIN_FILL("cloud.sun.rain.fill"), + DROP("drop"), + DROP_CIRCLE("drop.circle"), + DROP_CIRCLE_FILL("drop.circle.fill"), + DROP_DEGREESIGN("drop.degreesign"), + DROP_DEGREESIGN_FILL("drop.degreesign.fill"), + DROP_DEGREESIGN_SLASH("drop.degreesign.slash"), + DROP_DEGREESIGN_SLASH_FILL("drop.degreesign.slash.fill"), + DROP_FILL("drop.fill"), + DROP_HALFFULL("drop.halffull"), + DROP_KEYPAD_RECTANGLE("drop.keypad.rectangle"), + DROP_KEYPAD_RECTANGLE_FILL("drop.keypad.rectangle.fill"), + DROP_TRANSMISSION("drop.transmission"), + DROP_TRIANGLE("drop.triangle"), + DROP_TRIANGLE_FILL("drop.triangle.fill"), + FLAME("flame"), + FLAME_CIRCLE("flame.circle"), + FLAME_CIRCLE_FILL("flame.circle.fill"), + FLAME_FILL("flame.fill"), + HUMIDITY("humidity"), + HUMIDITY_FILL("humidity.fill"), + HURRICANE("hurricane"), + HURRICANE_CIRCLE("hurricane.circle"), + HURRICANE_CIRCLE_FILL("hurricane.circle.fill"), + MOON("moon"), + MOON_CIRCLE("moon.circle"), + MOON_CIRCLE_FILL("moon.circle.fill"), + MOON_DUST("moon.dust"), + MOON_DUST_CIRCLE("moon.dust.circle"), + MOON_DUST_CIRCLE_FILL("moon.dust.circle.fill"), + MOON_DUST_FILL("moon.dust.fill"), + MOON_FILL("moon.fill"), + MOON_HAZE("moon.haze"), + MOON_HAZE_CIRCLE("moon.haze.circle"), + MOON_HAZE_CIRCLE_FILL("moon.haze.circle.fill"), + MOON_HAZE_FILL("moon.haze.fill"), + MOON_ROAD_LANES("moon.road.lanes"), + MOON_STARS("moon.stars"), + MOON_STARS_CIRCLE("moon.stars.circle"), + MOON_STARS_CIRCLE_FILL("moon.stars.circle.fill"), + MOON_STARS_FILL("moon.stars.fill"), + MOON_ZZZ("moon.zzz"), + MOON_ZZZ_FILL("moon.zzz.fill"), + MOONPHASE_FIRST_QUARTER("moonphase.first.quarter"), + MOONPHASE_FIRST_QUARTER_INVERSE("moonphase.first.quarter.inverse"), + MOONPHASE_FULL_MOON("moonphase.full.moon"), + MOONPHASE_FULL_MOON_INVERSE("moonphase.full.moon.inverse"), + MOONPHASE_LAST_QUARTER("moonphase.last.quarter"), + MOONPHASE_LAST_QUARTER_INVERSE("moonphase.last.quarter.inverse"), + MOONPHASE_NEW_MOON("moonphase.new.moon"), + MOONPHASE_NEW_MOON_INVERSE("moonphase.new.moon.inverse"), + MOONPHASE_WANING_CRESCENT("moonphase.waning.crescent"), + MOONPHASE_WANING_CRESCENT_INVERSE("moonphase.waning.crescent.inverse"), + MOONPHASE_WANING_GIBBOUS("moonphase.waning.gibbous"), + MOONPHASE_WANING_GIBBOUS_INVERSE("moonphase.waning.gibbous.inverse"), + MOONPHASE_WAXING_CRESCENT("moonphase.waxing.crescent"), + MOONPHASE_WAXING_CRESCENT_INVERSE("moonphase.waxing.crescent.inverse"), + MOONPHASE_WAXING_GIBBOUS("moonphase.waxing.gibbous"), + MOONPHASE_WAXING_GIBBOUS_INVERSE("moonphase.waxing.gibbous.inverse"), + MOONRISE("moonrise"), + MOONRISE_CIRCLE("moonrise.circle"), + MOONRISE_CIRCLE_FILL("moonrise.circle.fill"), + MOONRISE_FILL("moonrise.fill"), + MOONSET("moonset"), + MOONSET_CIRCLE("moonset.circle"), + MOONSET_CIRCLE_FILL("moonset.circle.fill"), + MOONSET_FILL("moonset.fill"), + RAINBOW("rainbow"), + SMOKE("smoke"), + SMOKE_CIRCLE("smoke.circle"), + SMOKE_CIRCLE_FILL("smoke.circle.fill"), + SMOKE_FILL("smoke.fill"), + SNOWBOARD("snowboard"), + SNOWBOARD_FILL("snowboard.fill"), + SNOWFLAKE("snowflake"), + SNOWFLAKE_CIRCLE("snowflake.circle"), + SNOWFLAKE_CIRCLE_FILL("snowflake.circle.fill"), + SNOWFLAKE_ROAD_LANE("snowflake.road.lane"), + SNOWFLAKE_ROAD_LANE_DASHED("snowflake.road.lane.dashed"), + SNOWFLAKE_SLASH("snowflake.slash"), + SPARKLE("sparkle"), + SPARKLE_MAGNIFYINGGLASS("sparkle.magnifyingglass"), + SPARKLES("sparkles"), + SPARKLES_RECTANGLE_STACK("sparkles.rectangle.stack"), + SPARKLES_RECTANGLE_STACK_FILL("sparkles.rectangle.stack.fill"), + SPARKLES_SQUARE_FILLED_ON_SQUARE("sparkles.square.filled.on.square"), + SPARKLES_TV("sparkles.tv"), + SPARKLES_TV_FILL("sparkles.tv.fill"), + SUN_DUST("sun.dust"), + SUN_DUST_CIRCLE("sun.dust.circle"), + SUN_DUST_CIRCLE_FILL("sun.dust.circle.fill"), + SUN_DUST_FILL("sun.dust.fill"), + SUN_HAZE("sun.haze"), + SUN_HAZE_CIRCLE("sun.haze.circle"), + SUN_HAZE_CIRCLE_FILL("sun.haze.circle.fill"), + SUN_HAZE_FILL("sun.haze.fill"), + SUN_HORIZON("sun.horizon"), + SUN_HORIZON_CIRCLE("sun.horizon.circle"), + SUN_HORIZON_CIRCLE_FILL("sun.horizon.circle.fill"), + SUN_HORIZON_FILL("sun.horizon.fill"), + SUN_MAX("sun.max"), + SUN_MAX_CIRCLE("sun.max.circle"), + SUN_MAX_CIRCLE_FILL("sun.max.circle.fill"), + SUN_MAX_FILL("sun.max.fill"), + SUN_MAX_TRIANGLEBADGE_EXCLAMATIONMARK("sun.max.trianglebadge.exclamationmark"), + SUN_MAX_TRIANGLEBADGE_EXCLAMATIONMARK_FILL("sun.max.trianglebadge.exclamationmark.fill"), + SUN_MIN("sun.min"), + SUN_MIN_FILL("sun.min.fill"), + SUN_RAIN("sun.rain"), + SUN_RAIN_CIRCLE("sun.rain.circle"), + SUN_RAIN_CIRCLE_FILL("sun.rain.circle.fill"), + SUN_RAIN_FILL("sun.rain.fill"), + SUN_SNOW("sun.snow"), + SUN_SNOW_CIRCLE("sun.snow.circle"), + SUN_SNOW_CIRCLE_FILL("sun.snow.circle.fill"), + SUN_SNOW_FILL("sun.snow.fill"), + SUNGLASSES("sunglasses"), + SUNGLASSES_FILL("sunglasses.fill"), + SUNRISE("sunrise"), + SUNRISE_CIRCLE("sunrise.circle"), + SUNRISE_CIRCLE_FILL("sunrise.circle.fill"), + SUNRISE_FILL("sunrise.fill"), + SUNSET("sunset"), + SUNSET_CIRCLE("sunset.circle"), + SUNSET_CIRCLE_FILL("sunset.circle.fill"), + SUNSET_FILL("sunset.fill"), + THERMOMETER_AND_LIQUID_WAVES("thermometer.and.liquid.waves"), + THERMOMETER_AND_LIQUID_WAVES_SNOWFLAKE("thermometer.and.liquid.waves.snowflake"), + THERMOMETER_AND_LIQUID_WAVES_TRIANGLEBADGE_EXCLAMATIONMARK("thermometer.and.liquid.waves.trianglebadge.exclamationmark"), + THERMOMETER_BRAKESIGNAL("thermometer.brakesignal"), + THERMOMETER_HIGH("thermometer.high"), + THERMOMETER_LOW("thermometer.low"), + THERMOMETER_MEDIUM("thermometer.medium"), + THERMOMETER_MEDIUM_SLASH("thermometer.medium.slash"), + THERMOMETER_SNOWFLAKE("thermometer.snowflake"), + THERMOMETER_SNOWFLAKE_CIRCLE("thermometer.snowflake.circle"), + THERMOMETER_SNOWFLAKE_CIRCLE_FILL("thermometer.snowflake.circle.fill"), + THERMOMETER_SUN("thermometer.sun"), + THERMOMETER_SUN_CIRCLE("thermometer.sun.circle"), + THERMOMETER_SUN_CIRCLE_FILL("thermometer.sun.circle.fill"), + THERMOMETER_SUN_FILL("thermometer.sun.fill"), + THERMOMETER_TRANSMISSION("thermometer.transmission"), + THERMOMETER_VARIABLE("thermometer.variable"), + THERMOMETER_VARIABLE_AND_FIGURE("thermometer.variable.and.figure"), + THERMOMETER_VARIABLE_AND_FIGURE_CIRCLE("thermometer.variable.and.figure.circle"), + THERMOMETER_VARIABLE_AND_FIGURE_CIRCLE_FILL("thermometer.variable.and.figure.circle.fill"), + TORNADO("tornado"), + TORNADO_CIRCLE("tornado.circle"), + TORNADO_CIRCLE_FILL("tornado.circle.fill"), + WIND("wind"), + WIND_CIRCLE("wind.circle"), + WIND_CIRCLE_FILL("wind.circle.fill"), + WIND_SNOW("wind.snow"), + WIND_SNOW_CIRCLE("wind.snow.circle"), + WIND_SNOW_CIRCLE_FILL("wind.snow.circle.fill"), + WINDOW_AWNING("window.awning"), + WINDOW_AWNING_CLOSED("window.awning.closed"), + WINDOW_CASEMENT("window.casement"), + WINDOW_CASEMENT_CLOSED("window.casement.closed"), + WINDOW_CEILING("window.ceiling"), + WINDOW_CEILING_CLOSED("window.ceiling.closed"), + WINDOW_HORIZONTAL("window.horizontal"), + WINDOW_HORIZONTAL_CLOSED("window.horizontal.closed"), + WINDOW_SHADE_CLOSED("window.shade.closed"), + WINDOW_SHADE_OPEN("window.shade.open"), + WINDOW_VERTICAL_CLOSED("window.vertical.closed"), + WINDOW_VERTICAL_OPEN("window.vertical.open"), + WINDSHIELD_FRONT_AND_FLUID_AND_SPRAY("windshield.front.and.fluid.and.spray"), + WINDSHIELD_FRONT_AND_HEAT_WAVES("windshield.front.and.heat.waves"), + WINDSHIELD_FRONT_AND_SPRAY("windshield.front.and.spray"), + WINDSHIELD_FRONT_AND_WIPER("windshield.front.and.wiper"), + WINDSHIELD_FRONT_AND_WIPER_AND_DROP("windshield.front.and.wiper.and.drop"), + WINDSHIELD_FRONT_AND_WIPER_AND_SPRAY("windshield.front.and.wiper.and.spray"), + WINDSHIELD_FRONT_AND_WIPER_EXCLAMATIONMARK("windshield.front.and.wiper.exclamationmark"), + WINDSHIELD_FRONT_AND_WIPER_INTERMITTENT("windshield.front.and.wiper.intermittent"), + WINDSHIELD_REAR_AND_FLUID_AND_SPRAY("windshield.rear.and.fluid.and.spray"), + WINDSHIELD_REAR_AND_HEAT_WAVES("windshield.rear.and.heat.waves"), + WINDSHIELD_REAR_AND_SPRAY("windshield.rear.and.spray"), + WINDSHIELD_REAR_AND_WIPER("windshield.rear.and.wiper"), + WINDSHIELD_REAR_AND_WIPER_AND_DROP("windshield.rear.and.wiper.and.drop"), + WINDSHIELD_REAR_AND_WIPER_AND_SPRAY("windshield.rear.and.wiper.and.spray"), + WINDSHIELD_REAR_AND_WIPER_EXCLAMATIONMARK("windshield.rear.and.wiper.exclamationmark"), + WINDSHIELD_REAR_AND_WIPER_INTERMITTENT("windshield.rear.and.wiper.intermittent"), +}