Struct FrameLimit 

pub struct FrameLimit { /* private fields */ }

How many frames a second the runtime draws at most, for a local and for a remote connection.

An application answers with one from App::frame_limit. The limit merges frames the application’s own work causes: output of an embedded terminal, messages of background work, a running animation. It never holds back a frame that answers a key, a paste, a mouse button going down or a button coming up — the echo of a typed character, the answer to a click and the place a dragged window comes to rest are drawn at once, so the limit cannot be felt in the keyboard or in a click.

The pointer moving is merged too: a drag, the pointer passing over the screen and the wheel arrive as fast as the hand moves, and only the latest state is worth a frame. Every one of those events still reaches the widgets and the application, which apply them all; only the drawing waits, at most one gap of the limit, and the first motion after a rest that long is drawn at once. So a two-second window drag at 5 frames a second writes ten frames, not a frame for every cell the pointer crossed.

The default draws 60 frames a second locally and 20 over a remote connection (Env::remote), because on a slow link every frame is a screen written down a network: a program pouring out lines would otherwise spend the connection on frames nobody can read apart.

use qframe::prelude::*;
use qframe::runtime::FrameLimit;

// The default: 60 frames a second at the machine, 20 over SSH.
assert_eq!(FrameLimit::default().frames_per_second(false), Some(60));
assert_eq!(FrameLimit::default().frames_per_second(true), Some(20));

// The same number everywhere, or a quieter one on a remote connection.
assert_eq!(FrameLimit::per_second(30).frames_per_second(true), Some(30));
assert_eq!(FrameLimit::per_second(30).remote(10).frames_per_second(true), Some(10));

// Every frame that is wanted is drawn.
assert_eq!(FrameLimit::none().frames_per_second(false), None);

Implementations

impl FrameLimit

pub const LOCAL: u32 = 60

Frames a second the default draws locally: as many as a screen at 60 Hz shows.

pub const REMOTE: u32 = 20

Frames a second the default draws over a remote connection: fast enough to read a scrolling program by, cheap enough for a link that carries every frame.

pub fn per_second(frames: u32) -> Self

The same number of frames a second on every connection. A frames of zero is no limit, the way FrameLimit::none is; a limit of no frames would draw nothing at all.

pub fn none() -> Self

No limit: every frame the application asks for is drawn.

pub fn remote(self, frames: u32) -> Self

Draws frames a second over a remote connection instead, and leaves the local number as it is. A frames of zero lifts the limit for remote connections.

pub fn frames_per_second(self, remote: bool) -> Option<u32>

How many frames a second this limit allows on the connection in hand; None is no limit. remote is what Env::remote reports.

Trait Implementations

impl Clone for FrameLimit

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for FrameLimit

impl Debug for FrameLimit

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FrameLimit

fn default() -> Self

Returns the “default value” for a type.

impl Eq for FrameLimit

impl PartialEq for FrameLimit

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for FrameLimit