Module freya::prelude

source ·
Expand description

Useful imports.

Re-exports§

  • pub use dioxus_core;
  • pub use dioxus_hot_reload;
  • pub use freya_elements as dioxus_elements;
  • pub use crate::launch::*;
  • pub use crate::plugins::*;

Modules§

Macros§

  • cow_borrowed
    Alias for Cow::Borrowed, because that’s used a million times so shortening it is nice. Makes the code more readable.
  • default_impl
    This macro is used to generate a impl Default block for any type with the function new_maybe_sync that takes a generic T
  • define_theme
    Example usage:
  • eq_impls
    This macro is used to generate impl PartialEq blocks for any Readable type that takes a generic T
  • fmt_impls
    This macro is used to generate impl Display, and impl Debug blocks for any Readable type that takes a generic T
  • import_svg
    Generate a Dioxus component rendering the specified SVG.
  • paste
  • read_impls
    This macro is used to generate impl Display, impl Debug, impl PartialEq, and impl Eq blocks for any Readable type that takes a generic T
  • rsx
    The rsx! macro makes it easy for developers to write jsx-style markup in their components.
  • theme_with
    Create FooThemeWith structs without having to deal with the verbose syntax.
  • to_owned
    A helper macro for cloning multiple values at once
  • use_applied_theme
    This macro has three arguments separator by commas.
  • use_reactive
    A helper macro for use_reactive that merges uses the closure syntax to elaborate the dependency array
  • write_impls
    This macro is used to generate impl Add, impl AddAssign, impl Sub, impl SubAssign, impl Mul, impl MulAssign, impl Div, and impl DivAssign blocks for any Writable type that takes a generic T

Structs§

Enums§

Constants§

Traits§

  • AnimatedValue
  • AnyStorage
    A trait for any storage backing type.
  • AreaModel
  • ComponentFunction
    Any component that implements the ComponentFn trait can be used as a component.
  • Context
    Provides context methods to [Result] and Option types that are compatible with [CapturedError]
  • DOMAdapter
  • Default
    A trait for giving a type a useful default value.
  • Dependency
    A dependency is a trait that can be used to determine if a effect or selector should be re-run.
  • DependencyElement
    A dependency is a trait that can be used to determine if a effect or selector should be re-run.
  • HasAttributes
    A trait for anything that has a dynamic list of attributes
  • IntoAttributeValue
    A value that can be converted into an attribute value
  • IntoDynNode
    A trait that allows various items to be converted into a dynamic node for the rsx macro
  • ItemPath
    Abstract the path matching.
  • LayoutMeasurer
  • NodeKey
  • Properties
    Every “Props” used for a component must implement the Properties trait. This trait gives some hints to Dioxus on how to memoize the props and some additional optimizations that can be made. We strongly encourage using the derive macro to implement the Properties trait automatically.
  • Readable
    A trait for states that can be read from like crate::Signal, crate::GlobalSignal, or crate::ReadOnlySignal. You may choose to accept this trait as a parameter instead of the concrete type to allow for more flexibility in your API. For example, instead of creating two functions, one that accepts a crate::Signal and one that accepts a crate::GlobalSignal, you can create one function that accepts a Readable type.
  • ReadableOptionExt
    An extension trait for Readable<Option> that provides some convenience methods.
  • ReadableResultExt
    An extension trait for Readable<Option> that provides some convenience methods.
  • ReadableVecExt
    An extension trait for Readable<Vec> that provides some convenience methods.
  • Scaled
  • Storage
    A trait for a storage backing type. (RefCell, RwLock, etc.)
  • SuperFrom
    A enhanced version of the From trait that allows with more flexibility.
  • SuperInto
    A enhanced version of the Into trait that allows with more flexibility.
  • SuspenseExtension
    Provides context methods to [Result<T, RenderError>] to show loading indicators for suspended results
  • TextEditor
    Common trait for editable texts
  • Writable
    A trait for states that can be written to like crate::Signal. You may choose to accept this trait as a parameter instead of the concrete type to allow for more flexibility in your API.
  • WritableOptionExt
    An extension trait for Writable<Option<T>>` that provides some convenience methods.
  • WritableVecExt
    An extension trait for Writable<Vec<T>> that provides some convenience methods.

Functions§

  • Accordion
    Show other elements under a collapsable box.
  • AccordionBody
    Intended to wrap the body of an Accordion.
  • AccordionSummary
    Intended to use as summary for an Accordion.
  • ActivableRoute
    Provide a context to the inner components so they can know whether the passed route is the current router in the Router or not.
  • AnimatedRouter
    Provide a mechanism for outlets to animate between route transitions.
  • ArrowIcon
    Icon component for an Arrow.
  • Body
    Usually used to wrap the application root component.
  • BottomTab
    Clickable BottomTab. Same thing as Tab but designed to be placed in the bottom of your app, usually used in combination with [Tabsbar], [Link] and [ActivableRoute].
  • Button
    Clickable button.
  • Canvas
    Draw anything inside of this canvas.
  • Checkbox
    Controlled Checkbox component.
  • CrossIcon
    Icon component for a Cross.
  • CursorArea
    Change the cursor icon when it’s hovering over this component.
  • DragProvider
    Provide a common place for DragZones and DropZones to exchange their data.
  • DragZone
    Make the inner children draggable to other DropZone.
  • DropZone
    Elements from DragZones can be dropped here.
  • Dropdown
    Select from multiple options, use alongside DropdownItem.
  • DropdownItem
    Styling
  • ErrorBoundary
    Create a new error boundary component that catches any errors thrown from child components
  • Fragment
    Create inline fragments using Component syntax.
  • GestureArea
    Detect complex touch gestures such as Gesture::DoubleTap.
  • Graph
    Graph component.
  • Input
    Small box to edit text.
  • Link
    Similar to Link, but you can use it in Freya. Both internal routes (dioxus-router) and external links are supported. When using internal routes make sure the Link is descendant of a Router component.
  • Loader
    Styling
  • Menu
    Floating menu, use alongside [MenuItem].
  • MenuButton
    Like a button, but for [Menu]s.
  • MenuContainer
    Wraps the body of a [Menu].
  • MenuItem
    Styling
  • NativeContainer
    Props
  • NativeRouter
    Provides native functionalities for a dioxus-router.
  • NetworkImage
    Image component that automatically fetches and caches remote (HTTP) images.
  • Popup
    Floating window intended for quick interactions. Also called Dialog in other frameworks.
  • PopupBackground
    The background of the [Popup] component.
  • PopupContent
    Optionally wrap the content of your [Popup] in a styled container.
  • PopupTitle
    Optionally use a styled title inside a [Popup].
  • ProgressBar
    Display the progress of something visually. For example: downloading files, fetching data, etc.
  • Radio
    Controlled Radio component.
  • ScrollBar
    Scroll bar used for crate::ScrollView and crate::VirtualScrollView.
  • ScrollThumb
    Scroll thumb used for crate::ScrollView and crate::VirtualScrollView.
  • ScrollView
    Scrollable area with bidirectional support and scrollbars.
  • Sidebar
    Props
  • SidebarItem
    Props
  • Slider
    Controlled Slider component.
  • SnackBar
    SnackBar component. Use in combination with other components.
  • SubMenu
    Create sub menus inside a [Menu].
  • SuspenseBoundary
    Suspense Boundaries let you render a fallback UI while a child component is suspended.
  • Switch
    Display whether a state is true or false. Commonly used for enabled/disabled scenarios. Example: light/dark theme.
  • Tab
    Clickable Tab. Usually used in combination with [Tabsbar], [Link] and [ActivableRoute].
  • Table
    Table component, composed with TableHead and TableBody.
  • TableBody
    The body of a Table.
  • TableCell
    Cell for a Table. You can place anything inside.
  • TableHead
    The head of a Table. Use TableRow inside.
  • TableRow
    Table row for Table. Use TableCell inside.
  • Tabsbar
    Horizontal container for Tabs. Use in combination with [Tab]
  • ThemeProvider
    Provides a Theme for all its children.
  • TickIcon
    Icon component for a Tick.
  • Tile
    Tile component to be used with [Radio] and [Checkbox].
  • Tooltip
    Tooltip component
  • VirtualScrollView
    One-direction scrollable area that dynamically builds and renders items based in their size and current available size, this is intended for apps using large sets of data that need good performance.
  • WindowDragArea
    Allow dragging the window when the cursor drag this component with a left mouse click.
  • apply_value
  • consume_context
    Consume context from the current scope
  • consume_context_from_scope
    Consume context from the current scope
  • current_owner
    Returns the current owner. This owner will be used to drop any Copy state that is created by the generational-box crate.
  • current_scope_id
    Get the current scope id
  • dynamic_bytes
    Transform some dynamic bytes (e.g: remote image fetched at runtime) into an attribute
  • fc_to_builder
    This utility function launches the builder method so rsx! and html! macros can use the typed-builder pattern to initialize a component’s props.
  • generation
    Get the current render since the inception of this component
  • get_align_axis
  • get_global_context
    Get the global context for signals
  • has_context
    Check if the current scope has a context
  • manage_key_event
  • map_winit_key
    Return the equivalent Winit’s Key in keyboard_types
  • map_winit_modifiers
  • map_winit_physical_key
    Return the equivalent of Winit’s PhysicalKey in keyboard_types
  • needs_update
    Mark the current scope as dirty, causing it to re-render
  • needs_update_any
    Mark the current scope as dirty, causing it to re-render
  • onclick
    The click event fires when the user clicks an element with the left button of the mouse.
  • onfiledrop
    The filedrop event fires when the user drops a file over the element.
  • onglobalclick
    The globalclick event fires when the user clicks anywhere. Note that this fires for all mouse buttons. You can check the specific variant with the MouseData’s trigger_button property.
  • onglobalfilehover
    The onglobalfilehover event fires when the user hovers a file over the window.
  • onglobalfilehovercancelled
    The onglobalfilehovercancelled event fires when the user cancels the hovering of a file over the window. It’s the opposite of onglobalfilehover.
  • onglobalmousedown
    The globalmousedown event fires when the user starts clicking anywhere. Note that this fires for all mouse buttons. You can check the specific variant with the MouseData’s trigger_button property.
  • onglobalmouseover
    The globalmouseover event fires when the user moves the mouse anywhere in the app.
  • onglobalpointerup
    The globalpointerup event fires when the user releases the point anywhere in the app.
  • onkeydown
    The keydown event fires when the user starts pressing any key.
  • onkeyup
    The keyup event fires when the user releases any key being pressed.
  • onmiddleclick
    The click event fires when the user clicks an element with the middle button of the mouse.
  • onmousedown
    The mousedown event fires when the user starts clicking an element. Note that this fires for all mouse buttons. You can check the specific variant with the MouseData’s trigger_button property.
  • onmouseenter
    The mouseenter event fires when the user starts hovering an element.
  • onmouseleave
    The mouseleave event fires when the user stops hovering an element.
  • onmouseover
    The mouseover event fires when the user moves the mouse over an element. Unlike onmouseover, this fires even if the user was already hovering over the element. For that reason, it’s less efficient.
  • onpointerdown
    The pointerdown event fires when the user clicks/starts touching an element.
  • onpointerenter
    The pointerenter event fires when the user starts hovering/touching an element.
  • onpointerleave
    The pointerleave event fires when the user stops hovering/touching an element.
  • onpointerover
    The pointerover event fires when the user hovers/touches over an element. Unlike onpointerenter, this fires even if the user was already hovering over the element. For that reason, it’s less efficient.
  • onpointerup
    The pointerup event fires when the user releases their mouse button or stops touching the element.
  • onrightclick
    The click event fires when the user clicks an element with the right button of the mouse.
  • ontouchcancel
    The touchcancel event fires when the user cancels the touching, this is usually caused by the hardware or the OS. Also see ontouchend.
  • ontouchend
    The touchend event fires when the user stops touching an element.
  • ontouchmove
    The touchmove event fires when the user is touching over an element.
  • ontouchstart
    The touchstart event fires when the user starts touching an element.
  • onwheel
    The wheel event fires when the user scrolls the mouse wheel while hovering over the element.
  • parent_scope
    Get the parent of the current scope if it exists
  • provide_context
    Provide context to the current scope
  • provide_error_boundary
    Provide an error boundary to catch errors from child components
  • provide_root_context
    Provide a context to the root scope
  • queue_effect
    Queue an effect to run after the next render. You generally shouldn’t need to interact with this function directly. use_effect will call this function for you.
  • remove_future
    Informs the scheduler that this task is no longer needed and should be removed.
  • run_calculations
    Calculate some chained operations with a given value. This value could be for example the width of a node’s parent area.
  • schedule_update
    Schedule an update for the current component
  • schedule_update_any
    Schedule an update for any component given its ScopeId.
  • spawn
    Spawns the future but does not return the Task. This task will automatically be canceled when the component is dropped.
  • spawn_forever
    Spawn a future that Dioxus won’t clean up when this component is unmounted
  • spawn_isomorphic
    Start a new future on the same thread as the rest of the VirtualDom.
  • static_bytes
    Transform some static bytes (e.g: statically linked images or SVGs) into an attribute
  • suspend
    Suspended the current component on a specific task and then return None
  • throw_error
    Throw a [CapturedError] into the current scope. The error will bubble up to the nearest crate::prelude::ErrorBoundary() or the root of the app.
  • try_consume_context
    Consume context from the current scope
  • try_use_context
    Consume some context in the tree, providing a sharable handle to the value
  • use_activable_route
  • use_after_render
    Push this function to be run after the next render
  • use_animated_router
    Shortcut to get access to the AnimatedRouterContext.
  • use_animation
    Animate your elements easily.
  • use_animation_with_dependencies
  • use_asset_cacher
    Global caching system for assets.
  • use_before_render
    A hook that allows you to insert a “before render” function.
  • use_callback
    A callback that’s always current
  • use_canvas
    Register a rendering hook to gain access to the Canvas. Reactivity managed through signals.
  • use_canvas_with_deps
    Register a rendering hook to gain access to the Canvas. Reactivity managed with manual dependencies.
  • use_context
    Consume some context in the tree, providing a sharable handle to the value
  • use_context_provider
    Provide some context via the tree and return a reference to it
  • use_coroutine
    Maintain a handle over a future that can be paused, resumed, and canceled.
  • use_coroutine_handle
    Get a handle to a coroutine higher in the tree Analogous to use_context_provider and use_context, but used for coroutines specifically See the docs for use_coroutine for more details.
  • use_drop
    Creates a callback that will be run before the component is removed. This can be used to clean up side effects from the component (created with use_effect).
  • use_editable
    Create a virtual text editor with it’s own cursor and rope.
  • use_effect
    Effects are reactive closures that run after the component has finished rendering. Effects are useful for things like manually updating the DOM after it is rendered with web-sys or javascript. Or reading a value from the rendered DOM.
  • use_focus
    Create a focus manager for a node.
  • use_form
    Create a Form controller with a submit callback.
  • use_future
    A hook that allows you to spawn a future the first time you render a component.
  • use_get_theme
    Subscribe to Theme changes, default theme will be used if there is no provided Theme.
  • use_hook
    Store a value between renders. The foundational hook for all other hooks.
  • use_hook_did_run
    A hook that uses before/after lifecycle hooks to determine if the hook was run
  • use_hook_with_cleanup
    Use a hook with a cleanup function
  • use_init_asset_cacher
    Initialize the global caching system for assets.
  • use_init_default_theme
    Provide the default Theme.
  • use_init_native_platform
    Keep some native features (focused element, preferred theme, etc) on sync between the platform and the components
  • use_init_theme
    Provide a custom Theme.
  • use_memo
    Creates a new Memo. The memo will be run immediately and whenever any signal it reads is written to. Memos can be used to efficiently compute derived data from signals.
  • use_node
    Subscribe to a Node layout changes.
  • use_node_signal
    Get a signal to read the latest layout from a Node.
  • use_on_unmountDeprecated
  • use_platform
    Get access to information and features of the platform.
  • use_platform_information
    Get access to information from the platform.
  • use_preferred_theme
    Access the preferred theme selected by the user.
  • use_reactive
    Takes some non-reactive data, and a closure and returns a closure that will subscribe to that non-reactive data as if it were reactive.
  • use_resource
    use_resource() is a reactive hook that resolves to the result of a future. It will rerun when you write to any signals you read inside the future.
  • use_root_context
    Try to get a value from the root of the virtual dom, if it doesn’t exist, create a new one with the closure provided.
  • use_scroll_controller
  • use_set_compare
    Creates a new SetCompare which efficiently tracks when a value changes to check if it is equal to a set of values.
  • use_set_compare_equal
    A hook that returns true if the value is equal to the value in the set compare.
  • use_signal
    Creates a new Signal. Signals are a Copy state management solution with automatic dependency tracking.
  • use_signal_sync
    Creates a new `Send + Sync`` Signal. Signals are a Copy state management solution with automatic dependency tracking.
  • use_theme
    Subscribe to Theme changes.
  • with_owner
    Run a closure with the given owner.

Type Aliases§

Attribute Macros§

Derive Macros§

  • Default
    Derive macro generating an impl of the trait Default.
  • Props
    Props