Struct fltk::app::prefs::Preferences

pub struct Preferences { /* private fields */ }

Provides methods to store user settings between application starts

Implementations

impl Preferences

pub fn set_file_access(flags: FileAccess)

Set filesystem access

pub fn file_access() -> FileAccess

Get filesystem access flags

pub fn new(root: Root, vendor: &str, application: &str) -> Option<Self>

Create a new Preferences object

Examples found in repository

examples/prefs.rs (line 4)

fn main() {
    let mut prefs = Preferences::new(Root::USER_L, "myfltk.org", "tempapp").unwrap();
    let mut opts = Preferences::new_group(&mut prefs, "Options").unwrap();
    opts.set_int("winsize", 400).unwrap();
    let size = opts.get_int("winsize").unwrap_or(300);
    opts.set_str("wintitle", "Hello").unwrap();
    let title = opts.get_str("wintitle").unwrap_or("My Window".to_string());
    println!("{}", size);
    println!("{}", title);
    println!("{:?}", opts.name());
    println!("{:?}", prefs.filename());
}

pub fn new_group(parent: &mut Preferences, group: &str) -> Option<Self>

Create a preferences object entry inside the group

Examples found in repository

examples/prefs.rs (line 5)

fn main() {
    let mut prefs = Preferences::new(Root::USER_L, "myfltk.org", "tempapp").unwrap();
    let mut opts = Preferences::new_group(&mut prefs, "Options").unwrap();
    opts.set_int("winsize", 400).unwrap();
    let size = opts.get_int("winsize").unwrap_or(300);
    opts.set_str("wintitle", "Hello").unwrap();
    let title = opts.get_str("wintitle").unwrap_or("My Window".to_string());
    println!("{}", size);
    println!("{}", title);
    println!("{:?}", opts.name());
    println!("{:?}", prefs.filename());
}

pub fn path(&self) -> String

Get the prefs path

pub fn filename(&self) -> Result<(PathBuf, Root), FltkError>

Get the filename

Examples found in repository

examples/prefs.rs (line 13)

fn main() {
    let mut prefs = Preferences::new(Root::USER_L, "myfltk.org", "tempapp").unwrap();
    let mut opts = Preferences::new_group(&mut prefs, "Options").unwrap();
    opts.set_int("winsize", 400).unwrap();
    let size = opts.get_int("winsize").unwrap_or(300);
    opts.set_str("wintitle", "Hello").unwrap();
    let title = opts.get_str("wintitle").unwrap_or("My Window".to_string());
    println!("{}", size);
    println!("{}", title);
    println!("{:?}", opts.name());
    println!("{:?}", prefs.filename());
}

pub fn get_userdata_path(&self) -> Result<PathBuf, FltkError>

Get the userdata path

pub fn set_int(&mut self, entry: &str, val: i32) -> Result<(), FltkError>

Set the value of an entry

Examples found in repository

examples/prefs.rs (line 6)

fn main() {
    let mut prefs = Preferences::new(Root::USER_L, "myfltk.org", "tempapp").unwrap();
    let mut opts = Preferences::new_group(&mut prefs, "Options").unwrap();
    opts.set_int("winsize", 400).unwrap();
    let size = opts.get_int("winsize").unwrap_or(300);
    opts.set_str("wintitle", "Hello").unwrap();
    let title = opts.get_str("wintitle").unwrap_or("My Window".to_string());
    println!("{}", size);
    println!("{}", title);
    println!("{:?}", opts.name());
    println!("{:?}", prefs.filename());
}

pub fn get_int(&mut self, entry: &str) -> Result<i32, FltkError>

Get the value of an entry

Examples found in repository

examples/prefs.rs (line 7)

fn main() {
    let mut prefs = Preferences::new(Root::USER_L, "myfltk.org", "tempapp").unwrap();
    let mut opts = Preferences::new_group(&mut prefs, "Options").unwrap();
    opts.set_int("winsize", 400).unwrap();
    let size = opts.get_int("winsize").unwrap_or(300);
    opts.set_str("wintitle", "Hello").unwrap();
    let title = opts.get_str("wintitle").unwrap_or("My Window".to_string());
    println!("{}", size);
    println!("{}", title);
    println!("{:?}", opts.name());
    println!("{:?}", prefs.filename());
}

pub fn set_float(&mut self, entry: &str, val: f32) -> Result<(), FltkError>

Set the value of an entry

pub fn set_float_with_precision( &mut self, entry: &str, val: f32, precision: u16 ) -> Result<(), FltkError>

Set the value of an entry

pub fn get_float(&mut self, entry: &str) -> Result<f32, FltkError>

Get the value of an entry

pub fn set_double(&mut self, entry: &str, val: f64) -> Result<(), FltkError>

Set the value of an entry

pub fn set_double_with_precision( &mut self, entry: &str, val: f64, precision: u16 ) -> Result<(), FltkError>

Set the value of an entry

pub fn get_double(&mut self, entry: &str) -> Result<f64, FltkError>

Get the value of an entry

pub fn set_str(&mut self, entry: &str, val: &str) -> Result<(), FltkError>

Set the value of an entry

Examples found in repository

examples/prefs.rs (line 8)

fn main() {
    let mut prefs = Preferences::new(Root::USER_L, "myfltk.org", "tempapp").unwrap();
    let mut opts = Preferences::new_group(&mut prefs, "Options").unwrap();
    opts.set_int("winsize", 400).unwrap();
    let size = opts.get_int("winsize").unwrap_or(300);
    opts.set_str("wintitle", "Hello").unwrap();
    let title = opts.get_str("wintitle").unwrap_or("My Window".to_string());
    println!("{}", size);
    println!("{}", title);
    println!("{:?}", opts.name());
    println!("{:?}", prefs.filename());
}

pub fn get_str(&mut self, entry: &str) -> Result<String, FltkError>

Get the value of an entry

Examples found in repository

examples/prefs.rs (line 9)

fn main() {
    let mut prefs = Preferences::new(Root::USER_L, "myfltk.org", "tempapp").unwrap();
    let mut opts = Preferences::new_group(&mut prefs, "Options").unwrap();
    opts.set_int("winsize", 400).unwrap();
    let size = opts.get_int("winsize").unwrap_or(300);
    opts.set_str("wintitle", "Hello").unwrap();
    let title = opts.get_str("wintitle").unwrap_or("My Window".to_string());
    println!("{}", size);
    println!("{}", title);
    println!("{:?}", opts.name());
    println!("{:?}", prefs.filename());
}

pub fn name(&mut self) -> Option<String>

Return the pref’s name

Examples found in repository

examples/prefs.rs (line 12)

fn main() {
    let mut prefs = Preferences::new(Root::USER_L, "myfltk.org", "tempapp").unwrap();
    let mut opts = Preferences::new_group(&mut prefs, "Options").unwrap();
    opts.set_int("winsize", 400).unwrap();
    let size = opts.get_int("winsize").unwrap_or(300);
    opts.set_str("wintitle", "Hello").unwrap();
    let title = opts.get_str("wintitle").unwrap_or("My Window".to_string());
    println!("{}", size);
    println!("{}", title);
    println!("{:?}", opts.name());
    println!("{:?}", prefs.filename());
}

pub fn groups(&mut self) -> i32

Return the number of groups

pub fn group_exists(&mut self, key: &str) -> bool

Check whether a group exists

pub fn delete_group(&mut self, group: &str) -> Result<(), FltkError>

Delete a group

pub fn delete_all_groups(&mut self) -> Result<(), FltkError>

Delete all groups

pub fn entries(&mut self) -> i32

Return the number of entries

pub fn entry_exists(&mut self, key: &str) -> bool

Check whether an entry exists

pub fn delete_entry(&mut self, entry: &str) -> Result<(), FltkError>

Delete an entry

pub fn delete_all_entries(&mut self) -> Result<(), FltkError>

Delete all entries

pub fn clear(&mut self) -> Result<(), FltkError>

Clear prefs

Trait Implementations

impl Clone for Preferences

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Preferences

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

Formats the value using the given formatter.

impl Drop for Preferences

fn drop(&mut self)

Executes the destructor for this type.