Crate sixtyfps

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.

How to use:

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

• The .60 code is inline in a macro.
• The .60 code in external files compiled with build.rs

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 := 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:

FIXME! set the version

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

[dependencies]
sixtyfps = "*"
...

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

In the build.rs file:

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

Then in your main file

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

Types

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

.60 Type	Rust Type	Note
int	i32
float	f32
string	SharedString	A reference-counted string type that can be easily converted to a str reference.
color	Color
length	f32	The unit are physical pixels.
logical_length	f32	At run-time, logical lengths are automatically translated to physical pixels using the device pixel ratio.
duration	i64	At run-time, durations are always represented as signed 64-bit integers with milisecond precision.
structure	struct of the same name

Modules

builtin_elements	Builtin Elements
generated_code	This module exists only to explain the API of the code generated from .60 design markup. Its described structure is not really contained in the compiled crate.
langref	The .60 language reference
testing	This module contains functions useful for unit tests
widgets	Widgets

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

ARGBColor	ARGBColor 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.
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:
ModelNotify	Dispatch notification 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 listen to change to a model. See Model::attach_peer and ModelNotify
SharedArray	SharedArray holds a reference-counted read-only copy of [T].
SharedString	A string type used by the SixtyFPS run-time.
StandardListViewItem	Represend an item in a StandardListView
VecModel	A model backed by an SharedArray

Traits

Model

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

Type Definitions

ModelHandle

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