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 only merges frames the application’s own work causes: output of an embedded terminal, messages of background work, a running animation. A frame the user asked for is never held back — the echo of a typed character, the tone under the pointer and every other answer to input is drawn at once, so the limit cannot be felt in the keyboard.

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) -> FrameLimit

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: &FrameLimit) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for FrameLimit