GUI native modules and data

Open searchable reader

platinum_core::ui_document

pub struct UiLimits

pub type UiElementId

pub struct UiElement

pub fn live_view_definition(&self) -> Result<crate::live_view::LiveViewDefinition, crate::live_view::LiveViewError>

pub fn number(&self, name: &str, fallback: f32) -> f32

pub fn rect(&self) -> [f32; 4]

pub fn set_rect(&mut self, rect: [f32; 4])

pub struct UiDocument

pub fn parse(xml: &str) -> Result<Self, String>

pub fn parse_with_limits(xml: &str, limits: UiLimits) -> Result<Self, String>

pub fn validate(&self) -> Result<(), String>

pub fn validate_with_limits(&self, limits: UiLimits) -> Result<(), String>

pub fn to_xml(&self) -> Result<String, String>

pub fn next_id(&self) -> u64

pub fn dependencies(&self) -> BTreeSet<String>

pub struct UiStylesheet

pub fn validate(&self) -> Result<(), String>

pub fn parse(css: &str) -> Result<Self, String>

pub fn parse_with_limits(css: &str, limits: UiLimits) -> Result<Self, String>

pub fn resolve(&self, e: &UiElement, state: &str) -> BTreeMap<String, String>

pub struct UiHistory

pub fn commit(&mut self, before: UiDocument, after: &UiDocument) -> Result<bool, String>

pub fn undo(&mut self, doc: &mut UiDocument) -> Result<bool, String>

pub fn redo(&mut self, doc: &mut UiDocument) -> Result<bool, String>

pub struct UiOverrides(pub BTreeMap<UiElementId, BTreeMap<String, String>>)

pub fn instantiate(&self, source: &UiDocument) -> Result<UiDocument, String>

pub fn apply_to(&mut self, source: &mut UiDocument) -> Result<(), String>

pub fn revert(&mut self)

pub struct UiInstanceAsset

pub fn parse_json(json: &str) -> Result<Self, String>

pub fn validate(&self) -> Result<(), String>

pub fn instantiate(&self, source: &UiDocument) -> Result<UiDocument, String>

pub fn between(source: &UiDocument, instance: &UiDocument) -> Result<Self, String>

pub struct UiClipboard

pub fn parse_json(json: &str) -> Result<Self, String>

pub fn validate(&self) -> Result<(), String>

pub enum UiAlignment

pub struct UiTransaction

pub fn begin(document: &UiDocument) -> Result<Self, String>

pub fn preview(&self) -> &UiDocument

pub fn edit(
        &mut self,
        edit: impl FnOnce(&mut UiDocument) -> Result<(), String>,
    ) -> Result<(), String>

pub fn cancel(self) -> UiDocument

pub fn commit(
        self,
        document: &mut UiDocument,
        history: &mut UiHistory,
    ) -> Result<bool, String>

platinum_sdk::contained_layout

pub fn is_usable(ctx: &egui::Context) -> bool

platinum_sdk::ui

pub struct PlatinumTheme

pub const DESKTOP: Color

pub const FACE: Color

pub const LIGHT: Color

pub const SHADOW: Color

pub const INK: Color

pub const BLUE: Color

pub struct PlatinumFonts

pub struct FontLoading

pub struct UiPlugin

pub fn raised() -> BorderColor

pub fn sunken() -> BorderColor

pub fn font(fonts: &PlatinumFonts, size: f32) -> TextFont

pub fn label(
    commands: &mut Commands,
    parent: Entity,
    value: impl Into<String>,
    fonts: &PlatinumFonts,
    size: f32,
) -> Entity

pub fn row(commands: &mut Commands, parent: Entity, gap: f32) -> Entity

pub struct ButtonSelected(pub bool)

pub fn button(
    commands: &mut Commands,
    parent: Entity,
    text: &str,
    command: CommandId,
    fonts: &PlatinumFonts,
) -> Entity

pub struct MenuItem

pub fn menu_bar(
    commands: &mut Commands,
    parent: Entity,
    app_name: &str,
    menus: &[(&str, &[MenuItem])],
    fonts: &PlatinumFonts,
) -> Entity

pub struct WindowParts

pub fn window(
    commands: &mut Commands,
    parent: Entity,
    title: &str,
    close_command: CommandId,
    fonts: &PlatinumFonts,
) -> WindowParts

pub struct WindowTitle

pub fn text_editor(
    commands: &mut Commands,
    parent: Entity,
    value: &str,
    fonts: &PlatinumFonts,
) -> Entity

platinum_sdk::authoring

pub struct Gesture<T>

pub fn begin(value: T) -> Self

pub fn preview(&mut self, value: T)

pub fn current(&self) -> &T

pub fn cancel(self) -> T

pub fn commit(self) -> Option<(T, T)>

platinum_sdk::authoring::hierarchy

pub type ItemId

pub struct Item

pub enum HierarchyError

pub struct Hierarchy<'a>

pub fn new(items: &'a [Item]) -> Result<Self, HierarchyError>

pub fn reparent(
        &self,
        item: ItemId,
        parent: Option<ItemId>,
        allow_cross_root: bool,
    ) -> Result<Reparent, HierarchyError>

pub struct Reparent

pub struct HierarchyView

pub fn show(&mut self, ui: &mut Ui, salt: impl std::hash::Hash, model: &Hierarchy<'_>) -> bool

platinum_sdk::authoring::history

pub enum HistoryError<E>

pub struct History<T>

pub fn new(capacity: usize) -> Self

pub fn can_undo(&self) -> bool

pub fn can_redo(&self) -> bool

pub fn clear(&mut self)

pub fn record<E>(
        &mut self,
        before: T,
        after: T,
        validate: impl Fn(&T) -> Result<(), E>,
    ) -> Result<bool, HistoryError<E>>

pub fn undo<E>(
        &mut self,
        current: &T,
        validate: impl Fn(&T) -> Result<(), E>,
    ) -> Result<Option<T>, HistoryError<E>>

pub fn redo<E>(
        &mut self,
        current: &T,
        validate: impl Fn(&T) -> Result<(), E>,
    ) -> Result<Option<T>, HistoryError<E>>

platinum_sdk::authoring::inspector

pub type PropertyId

pub enum Value

pub enum PropertyKind

pub struct PropertySchema

pub fn accepts(&self, value: &Value) -> bool

pub struct SchemaRegistry

pub enum SchemaError

pub fn register(&mut self, schema: PropertySchema) -> Result<(), SchemaError>

pub fn get(&self, id: PropertyId) -> Option<&PropertySchema>

pub fn iter(&self) -> impl Iterator<Item

pub type PropertyValues

pub enum PropertyEdit

pub struct Inspector

pub fn is_editing(&self) -> bool

pub fn cancel(&mut self) -> Vec<PropertyEdit>

pub fn show(
        &mut self,
        ui: &mut Ui,
        salt: impl std::hash::Hash,
        registry: &SchemaRegistry,
        values: &PropertyValues,
    ) -> Vec<PropertyEdit>

platinum_sdk::authoring::timeline

pub type Tick

pub type KeyId

pub type TrackId

pub enum Interpolation

pub enum LayerMode

pub struct Key

pub struct Track

pub enum TimelineEdit

pub enum TimelineError

pub fn validate(tracks: &[Track]) -> Result<(), TimelineError>

pub fn snap_delta(delta: Tick, grid: Tick) -> Tick

pub fn move_keys(original: &BTreeMap<KeyId, Tick>, delta: Tick) -> BTreeMap<KeyId, Tick>

pub struct Timeline

pub fn is_editing(&self) -> bool

pub fn cancel(&mut self) -> Option<TimelineEdit>

pub fn show(
        &mut self,
        ui: &mut Ui,
        salt: impl std::hash::Hash,
        tracks: &[Track],
        playhead: Tick,
    ) -> Result<Vec<TimelineEdit>, TimelineError>

pub const MAX_CHARACTERS: usize

pub enum Alignment

pub struct CharacterStyle

pub struct StyleRun

pub struct RichDocument

pub fn validate(&self) -> Result<(), String>

pub fn decode(name: &str, content: &str) -> Result<Self, String>

pub fn encode(&self) -> String

pub fn style_at(&self, i: usize) -> CharacterStyle

pub fn format(&mut self, range: Range<usize>, style: CharacterStyle)

pub fn replace_range(&mut self, range: Range<usize>, text: &str, typing: &CharacterStyle)

pub fn sync_text(&mut self, text: String, typing: &CharacterStyle)

pub fn slice(&self, range: Range<usize>) -> Self

pub fn html(&self) -> String

pub struct DocumentHistory

pub fn record(&mut self, d: RichDocument, coalesce: bool)

pub fn undo(&mut self, current: &RichDocument) -> Option<RichDocument>

pub fn redo(&mut self, current: &RichDocument) -> Option<RichDocument>

pub struct RichEditorState

pub fn observe_ime(&mut self, context: &egui::Context, id: egui::Id)

pub fn apply(&mut self, doc: &mut RichDocument, style: CharacterStyle)

pub fn rich_text_editor(
    ui: &mut egui::Ui,
    id: egui::Id,
    doc: &mut RichDocument,
    state: &mut RichEditorState,
    zoom: f32,
) -> egui::Response

pub fn rich_text_editor_sized(
    ui: &mut egui::Ui,
    id: egui::Id,
    doc: &mut RichDocument,
    state: &mut RichEditorState,
    zoom: f32,
    minimum_height: f32,
) -> egui::Response

pub fn rich_text_editor_decorated_sized(
    ui: &mut egui::Ui,
    id: egui::Id,
    doc: &mut RichDocument,
    state: &mut RichEditorState,
    zoom: f32,
    minimum_height: f32,
    decorations: &DecorationLayer,
) -> egui::Response

pub fn rich_text_editor_revisioned_sized(
    ui: &mut egui::Ui,
    id: egui::Id,
    doc: &mut RichDocument,
    state: &mut RichEditorState,
    zoom: f32,
    minimum_height: f32,
    decorations: &DecorationLayer,
    revision: u64,
) -> egui::Response

pub enum ListKind

pub fn apply_list(&mut self, selection: Range<usize>, kind: ListKind)

platinum_sdk::rich_text::decorations

pub struct StyleOverlay

pub struct TextDecoration

pub fn from_byte_range(
        text: &str,
        bytes: Range<usize>,
        priority: i32,
        style: StyleOverlay,
    ) -> Result<Self, &'static str>

pub struct DecorationLayer

pub fn compile(
        character_count: usize,
        decorations: Vec<TextDecoration>,
    ) -> Result<Self, &'static str>

pub fn fingerprint(&self) -> u64

platinum_sdk::editor

pub struct DocumentEditor

pub fn new(doc: RichDocument, name: String) -> Self

pub fn dirty(&self) -> bool

pub fn mark_saved(&mut self, saved: RichDocument)

pub fn record(&mut self, before: RichDocument, time: f64, typing: bool)

pub fn attach_text_source(&mut self, source: SharedTextDocument) -> Result<(), String>

pub fn text_source(&self) -> Option<SharedTextDocument>

pub fn text_conflicted(&self) -> bool

pub fn pump_text(&mut self) -> Result<bool, String>

pub fn observe_restored_projection(&mut self)

pub fn text_ready_to_save(&mut self) -> bool

pub enum EditorCommand

pub fn default_menus() -> office::MenuHost

pub fn command_from_id(id: &str) -> Option<EditorCommand>

pub fn shortcuts(ctx: &egui::Context, actions: &mut Vec<EditorCommand>)

pub fn standard_toolbar(ui: &mut egui::Ui, d: &mut DocumentEditor) -> Vec<EditorCommand>

pub fn insert_text(&mut self, text: &str, time: f64) -> bool

pub fn focus_selection(&mut self)

pub fn find_next(&mut self) -> bool

pub fn replace_all(&mut self, time: f64) -> usize

pub fn execute(&mut self, command: EditorCommand, time: f64) -> bool

pub fn find_bar(ui: &mut egui::Ui, d: &mut DocumentEditor, time: f64)

pub fn status_bar(ui: &mut egui::Ui, d: &DocumentEditor)

pub fn document_view(ui: &mut egui::Ui, id: egui::Id, d: &mut DocumentEditor, time: f64)

pub fn formatting_palette(ui: &mut egui::Ui, d: &mut DocumentEditor, time: f64)

pub fn menu_bar(ui: &mut egui::Ui, menus: &office::MenuHost) -> Vec<CommandId>

platinum_sdk::game::ui

pub enum UiCommand

pub struct UiRequest

pub const DEFAULT_HUD_XML: &str

pub const DEFAULT_PAUSE_XML: &str

pub enum UiProperty

pub fn parse(path: &str) -> Result<Self, String>

pub fn attribute(self) -> &'static str

pub struct UiTarget

pub struct UiAnimationBindings

pub fn set(
        &mut self,
        target: UiTarget,
        property: UiProperty,
        value: f32,
    ) -> Result<(), String>

pub fn clear(&mut self, target: UiTarget)

pub fn clear_screen(&mut self, screen: u64)

pub fn apply_samples(
        &mut self,
        screen: u64,
        samples: &[AnimationSample],
        objects: &BTreeMap<String, UiElementId>,
    ) -> Result<(), String>

pub fn values(&self, target: UiTarget, element: &UiElement) -> BTreeMap<UiProperty, f32>

pub fn effective_opacity(
        &self,
        screen: u64,
        id: u64,
        document: &UiDocument,
        inputs: &BTreeMap<String, String>,
    ) -> f32

pub type UiElementId

pub struct UiElement

pub fn number(&self, name: &str, fallback: f32) -> f32

pub fn rect(&self) -> [f32; 4]

pub fn set_rect(&mut self, rect: [f32; 4])

pub struct UiDocument

pub fn parse(xml: &str) -> Result<Self, String>

pub fn validate(&self) -> Result<(), String>

pub fn to_xml(&self) -> String

pub fn next_id(&self) -> u64

pub fn dependencies(&self) -> BTreeSet<String>

pub struct UiStylesheet

pub fn parse(css: &str) -> Result<Self, String>

pub fn resolve(&self, e: &UiElement, state: &str) -> BTreeMap<String, String>

pub struct UiHistory

pub fn commit(&mut self, before: UiDocument, after: &UiDocument)

pub fn undo(&mut self, doc: &mut UiDocument) -> bool

pub fn redo(&mut self, doc: &mut UiDocument) -> bool

pub struct UiOverrides(pub BTreeMap<UiElementId, BTreeMap<String, String>>)

pub fn instantiate(&self, source: &UiDocument) -> UiDocument

pub fn apply_to(&mut self, source: &mut UiDocument) -> Result<(), String>

pub fn revert(&mut self)

pub struct UiInstanceAsset

pub fn between(source: &UiDocument, instance: &UiDocument) -> Self

pub struct UiClipboard

pub enum UiAlignment

pub struct UiObject

pub struct GameUiRuntime

pub struct UiScreen

pub fn open(
        &mut self,
        document: UiDocument,
        styles: UiStylesheet,
        modal: bool,
    ) -> Result<u64, String>

pub fn open_asset(
        &mut self,
        path: &str,
        document: UiDocument,
        styles: UiStylesheet,
        modal: bool,
    ) -> Result<u64, String>

pub fn screen_for_document(&self, path: &str) -> Option<u64>

pub fn get_widget(&self, target: &UiWidgetRef, property: &str) -> Result<UiScalar, String>

pub fn patch_widget(
        &mut self,
        target: &UiWidgetRef,
        patch: &UiWidgetPatch,
    ) -> Result<(), String>

pub fn apply_persistent(&mut self, state: &UiPlayerState) -> Result<(), String>

pub fn pop(&mut self) -> Option<UiScreen>

pub fn clear(&mut self)

pub fn set_value(&mut self, name: impl Into<String>, value: impl ToString)

pub fn blocks_gameplay(&self) -> bool

pub fn invalidate(&mut self)

pub struct UiAction

pub struct UiActionQueue

pub struct UiActivation(pub UiAction)

pub fn drain(&mut self) -> impl Iterator<Item

pub struct GameUiPlugin

pub fn ui_color(value: &str, fallback: Color) -> Color

pub struct GameUserSettings

pub fn parse(text: &str) -> Result<Self, String>

pub const FRAMEWORK_MAIN_MENU: &str

pub const FRAMEWORK_HUD: &str

pub const FRAMEWORK_PAUSE: &str

pub const FRAMEWORK_LOBBY: &str

pub const FRAMEWORK_SETTINGS: &str

pub const FRAMEWORK_RESULTS: &str

pub struct UiWidgetRef

pub fn validate(&self) -> Result<(), String>

pub enum UiScalar

pub fn to_json(&self) -> serde_json::Value

pub fn text(&self) -> String

pub const WIDGET_PROPERTIES: &[&str]

pub fn widget_property(name: &str) -> Result<&'static str, String>

pub struct UiWidgetPatch

pub fn normalized(&self) -> Result<Self, String>

pub fn validate(&self) -> Result<(), String>

pub fn apply_to_element(&self, element: &mut UiElement)

pub type UiQueryView

pub struct UiPlayerState

pub fn validate(&self) -> Result<(), String>

pub struct UiWidgetState

pub struct UiState

pub fn from_project(root: &Path, project: &crate::game::GameProject) -> Result<Self, String>

pub fn register(&mut self, path: &str, document: UiDocument) -> Result<(), String>

pub fn register_styled(
        &mut self,
        path: &str,
        document: UiDocument,
        styles: UiStylesheet,
    ) -> Result<(), String>

pub fn ensure_document(&mut self, root: &Path, path: &str) -> Result<(), String>

pub fn documents(&self) -> &BTreeMap<String, UiDocument>

pub fn player_snapshot(&self, source: u64) -> UiPlayerState

pub fn apply_player_snapshot(
        &mut self,
        source: u64,
        mut state: UiPlayerState,
    ) -> Result<(), String>

pub fn remove_player(&mut self, source: u64)

pub fn replace_player_snapshots(
        &mut self,
        states: BTreeMap<u64, UiPlayerState>,
    ) -> Result<(), String>

pub fn apply(&mut self, source: u64, command: &UiCommand) -> Result<(), String>

pub fn query_revision(&self, source: u64) -> u64

pub fn query_view(&mut self, source: u64) -> &UiQueryView

pub fn get(
        &mut self,
        source: u64,
        target: &UiWidgetRef,
        property: &str,
    ) -> Result<UiScalar, String>

pub fn widget_properties(
    document: &UiDocument,
    element: &UiElement,
    styles: &UiStylesheet,
    values: &BTreeMap<String, String>,
) -> BTreeMap<String, UiScalar>

pub fn patch_query_view(
    view: &mut UiQueryView,
    target: &UiWidgetRef,
    patch: &UiWidgetPatch,
) -> Result<(), String>

pub fn widget_flag(
    document: &UiDocument,
    id: u64,
    styles: &UiStylesheet,
    values: &BTreeMap<String, String>,
    enabled: bool,
) -> bool

pub enum UiViewportPolicy

pub fn design_viewport(
    design: [f32; 2],
    viewport: Vec2,
    policy: UiViewportPolicy,
) -> ([f32; 4], f32)

platinum_sdk::node_editor

pub struct Node

pub struct Link

pub struct Canvas

pub enum Edit

pub fn show(
        &mut self,
        ui: &mut Ui,
        salt: impl std::hash::Hash,
        nodes: &[Node],
        links: &[Link],
        positions: &mut BTreeMap<u64, [f32; 2]>,
        palette: &[&str],
        height: f32,
    ) -> Vec<Edit>

pub fn show_grid(&mut self, ui: &mut Ui, salt: impl std::hash::Hash, nodes: &[Node])

platinum_sdk::panels

pub enum DockSide

pub enum PanelPlacement

pub struct PanelPreferences

pub struct PanelWindow

pub struct PanelActivation

pub enum PanelSet

pub struct PanelContext<'a>

pub struct PanelOutput<A>

pub fn actions(actions: Vec<A>) -> Self

pub type PanelRenderer<T, A>

pub struct PanelDefinition<T, A>

pub fn new(id: impl Into<String>, title: impl Into<String>, draw: PanelRenderer<T, A>) -> Self

pub struct Panel<T, A>

pub struct PanelRegistry<T: Send + Sync + 'static, A: Send + Sync + 'static>

pub fn register(&mut self, definition: PanelDefinition<T, A>)

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn contains(&self,id:&str)->bool

pub fn set_enabled(&mut self,id:&str,enabled:bool)->bool

pub fn set_pinned(&mut self, id: &str, pinned: bool) -> bool

pub fn surface(&self, id: &str) -> Option<SurfaceHandle>

pub fn owns_window(&self, window: Entity) -> bool

pub fn preferences(&self) -> BTreeMap<String, PanelPreferences>

pub fn restore(&mut self, saved: &BTreeMap<String, PanelPreferences>)

pub fn set_placement(&mut self, id: &str, placement: PanelPlacement)

pub fn resource_advisor(&mut self) -> &mut crate::window_resources::WindowResourceAdvisor

pub fn set_resource_policy(
        &mut self,
        id: &str,
        policy: crate::window_resources::WindowResourcePolicy,
    ) -> bool

pub fn profile_resources(&mut self, time: f64)

pub fn show_resource_advice(&mut self, ctx: &egui::Context, time: f64)

pub fn toggle(&mut self, id: &str)

pub fn toggle_docked(&mut self, id: &str)

pub fn show_docked(
        &mut self,
        ctx: &egui::Context,
        content: &mut T,
        time: f64,
        enabled: bool,
    ) -> PanelOutput<A>

pub fn show_floating(
        &mut self,
        ctx: &egui::Context,
        window: Entity,
        host: &mut Window,
        content: &mut T,
        time: f64,
        enabled: bool,
    ) -> PanelOutput<A>

pub fn show_canvas_floating(
        &mut self,
        ctx: &egui::Context,
        content: &mut T,
        time: f64,
        enabled: bool,
    ) -> PanelOutput<A>

pub struct DockablePanelsPlugin<T: Send + Sync + 'static, A: Send + Sync + 'static>(
    PhantomData<fn() -> (T, A)>,
)