Crate sixtyfps[][src]

SixtyFPS

This crate is the main entry point for embedding user interfaces designed with SixtyFPS UI in Rust programs.

Included in this documentation is also the language reference, documentation of builtin elements, widgets and layouting.

How to use:

The user interfaces are described in the .60 design markup language. There are two ways of including the design in Rust:

This markup code is translated to Rust code and each component is turned into a Rust struct with functions to instantiated, show or access properties. This documentation includes an example of how the API looks like.

The .60 code in a macro

This method combines your Rust code with the .60 design markup in one file, using a macro:

sixtyfps::sixtyfps!{
    HelloWorld := Window {
        Text {
            text: "hello world";
            color: green;
        }
    }
}
fn main() {
    HelloWorld::new().run();
}

The .60 file in external files compiled with build.rs

This method allows you to a separate .60 file on the file system, which works well if your design becomes bigger and you split it up across multiple files. You need to use a so-called build script to trigger the compilation of the .60 file.

In your Cargo.toml:

[package]
...
build = "build.rs"

[dependencies]
sixtyfps = "0.0.5"
...

[build-dependencies]
sixtyfps-build = "0.0.5"

In the build.rs file:

fn main() {
    sixtyfps_build::compile("ui/hello.60").unwrap();
}

Then in your main file

sixtyfps::include_modules!();
fn main() {
    HelloWorld::new().run();
}

Generated components

As of now, only the last component of a .60 source is generated. It is planned to generate all exported components.

The component is generated and re-exported at the location of the include_modules! or sixtyfps! macro. it consist of a struct of the same name of the component. For example, if you have export MyComponent := Window { /*...*/ } in the .60 file, it will create a struct MyComponent{ /*...*/ }. This documentation contains a documented generated component: docs::generated_code::SampleComponent.

The following associated function are added to the component:

For each top-level property

For each top-level callback

After instantiating the component you can call just [fn run(&self)] on it, in order to show it and spin the event loop to render and react to input events. If you want to show multiple components simultaneously, then you can also call just show() first. When you’re ready to enter the event loop, just call run_event_loop().

Type Mappings

The types used for properties in .60 design markup each translate to specific types in Rust. The follow table summarizes the entire mapping:

.60 TypeRust TypeNote
inti32
floatf32
stringSharedStringA reference-counted string type that can be easily converted to a str reference.
colorColor
lengthf32The unit are physical pixels.
logical_lengthf32At run-time, logical lengths are automatically translated to physical pixels using the device pixel ratio.
durationi64At run-time, durations are always represented as signed 64-bit integers with milisecond precision.
structurestruct of the same name
arrayModelHandle

For user defined structures in the .60, an extra struct is generated. For example, if the .60 contains

export struct MyStruct := {
    foo: int,
    bar: string,
}

The following struct would be generated:

#[derive(Default, Clone, Debug, PartialEq)]
struct MyStruct {
    foo : i32,
    bar: sixtyfps::SharedString,
}

Modules

docs

This is a pseudo module which only exist for documentation purposes as a way to show the SixtyFPS documentation as part of rustdoc.

testing

This module contains functions useful for unit tests

Macros

include_modules

Include the code generated with the sixtyfps-build crate from the build script. After calling sixtyfps_build::compile in your build.rs build script, the use of this macro includes the generated Rust code and makes the exported types available for you to instantiate.

sixtyfps

This macro allows you to use the .60 design markup language inline in Rust code. Within the braces of the macro you can use place .60 code and the named exported components will be available for instantiation.

Structs

Color

Color represents a color in the SixtyFPS run-time, represented using 8-bit channels for red, green, blue and the alpha (opacity). It can be conveniently constructed and destructured using the to_ and from_ (a)rgb helper functions:

ModelHandle

Properties of type array in the .60 language are represented as an Option of an Rc of something implemented the Model trait

ModelNotify

Dispatch notifications from a Model to one or several ModelPeer. Typically, you would want to put this in the implementaiton of the Model

ModelPeer

Represent a handle to a view that listens to changes to a model. See Model::attach_peer and ModelNotify

RgbaColor

RgbaColor stores the red, green, blue and alpha components of a color with the precision of the generic parameter T. For example if T is f32, the values are normalized between 0 and 1. If T is u8, they values range is 0 to 255. This is merely a helper class for use with Color.

SharedString

A string type used by the SixtyFPS run-time.

SharedVector

SharedVector holds a reference-counted read-only copy of [T].

StandardListViewItem

Represend an item in a StandardListView

Timer

Timer is a handle to the timer system that allows triggering a callback to be called after a specified period of time.

VecModel

A model backed by a SharedVector

Weak

Struct that’s used to hold weak references for SixtyFPS components.

Enums

Brush

A brush is a data structure that is used to describe how a shape, such as a rectangle, path or even text, shall be filled. A brush can also be applied to the outline of a shape, that means the fill of the outline itself.

TimerMode

The TimerMode specifies what should happen after the timer fired.

Traits

IntoWeak

This trait describes the conversion of a strongly referenced SixtyFPS component, held by a [vtable::VRc] into a weak reference.

Model

A Model is providing Data for the Repeater or ListView elements of the .60 language

Functions

register_font_from_memory

This function can be used to register a custom TrueType font with SixtyFPS, for use with the font-family property. The provided slice must be a valid TrueType font.

register_font_from_path

This function can be used to register a custom TrueType font with SixtyFPS, for use with the font-family property. The provided path must refer to a valid TrueType font.

run_event_loop

Enters the main event loop. This is necessary in order to receive events from the windowing system in order to render to the screen and react to user input.