Struct SmartTable

pub struct SmartTable { /* private fields */ }

Smart table widget

Implementations

impl SmartTable

pub fn new<S: Into<Option<&'static str>>>( x: i32, y: i32, w: i32, h: i32, label: S, ) -> Self

Construct a new SmartTable widget using coords, size and label

pub fn default_fill() -> Self

Create a SmartTable the size of the parent widget

pub fn set_opts(&mut self, opts: TableOpts)

Sets the tables options

pub fn with_opts(self, opts: TableOpts) -> Self

Instantiate with TableOpts

Examples found in repository

examples/headers.rs (lines 15-19)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 15,
            ..Default::default()
        });

    wind.end();
    wind.show();

    for i in 0..30 {
        table.set_row_header_value(i, &(i + 100).to_string());
    }

    for i in 0..15 {
        table.set_col_header_value(i, &i.to_string());
    }

    app.run().unwrap();
}

examples/simple.rs (lines 16-21)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    // We pass the rows and columns thru the TableOpts field
    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 30,
            editable: true,
            ..Default::default()
        });

    wind.end();
    wind.show();

    // set the value at the row,column 4,5 to "another", notice that indices start at 0
    table.set_cell_value(3, 4, "another");
    assert_eq!(table.cell_value(3, 4), "another");

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == enums::Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

examples/int_table.rs (lines 16-21)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    // We pass the rows and columns thru the TableOpts field
    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 1000,
            editable: true,
            ..Default::default()
        });

    wind.end();
    wind.show();

    table
        .input()
        .as_mut()
        .unwrap()
        .set_type(input::InputType::Int);

    // set the value at the row,column 4,5 to "another", notice that indices start at 0
    table.set_cell_value(3, 4, "10");
    assert_eq!(table.cell_value(3, 4), "10");

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == enums::Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

examples/styled.rs (lines 16-24)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 15,
            cell_selection_color: Color::Red.inactive(),
            header_frame: FrameType::FlatBox,
            header_color: Color::BackGround.lighter(),
            cell_border_color: Color::White,
            ..Default::default()
        });

    wind.end();
    wind.show();

    // Just filling the vec with some values
    for i in 0..30 {
        for j in 0..15 {
            table.set_cell_value(i, j, &(i + j).to_string());
        }
    }
    table.redraw();

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

pub fn input(&mut self) -> &mut Option<Input>

Get the input widget

Examples found in repository

examples/int_table.rs (line 27)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    // We pass the rows and columns thru the TableOpts field
    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 1000,
            editable: true,
            ..Default::default()
        });

    wind.end();
    wind.show();

    table
        .input()
        .as_mut()
        .unwrap()
        .set_type(input::InputType::Int);

    // set the value at the row,column 4,5 to "another", notice that indices start at 0
    table.set_cell_value(3, 4, "10");
    assert_eq!(table.cell_value(3, 4), "10");

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == enums::Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

pub fn data(&self) -> Vec<Vec<Cell>>

Get a copy of the data

pub fn data_ref(&self) -> Arc<Mutex<Vec<Vec<Cell>>>>

Get the inner data

pub fn set_cell_value(&mut self, row: i32, col: i32, val: &str)

Set the cell value, using the row and column to index the data

Examples found in repository

examples/simple.rs (line 27)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    // We pass the rows and columns thru the TableOpts field
    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 30,
            editable: true,
            ..Default::default()
        });

    wind.end();
    wind.show();

    // set the value at the row,column 4,5 to "another", notice that indices start at 0
    table.set_cell_value(3, 4, "another");
    assert_eq!(table.cell_value(3, 4), "another");

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == enums::Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

examples/int_table.rs (line 33)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    // We pass the rows and columns thru the TableOpts field
    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 1000,
            editable: true,
            ..Default::default()
        });

    wind.end();
    wind.show();

    table
        .input()
        .as_mut()
        .unwrap()
        .set_type(input::InputType::Int);

    // set the value at the row,column 4,5 to "another", notice that indices start at 0
    table.set_cell_value(3, 4, "10");
    assert_eq!(table.cell_value(3, 4), "10");

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == enums::Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

examples/styled.rs (line 32)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 15,
            cell_selection_color: Color::Red.inactive(),
            header_frame: FrameType::FlatBox,
            header_color: Color::BackGround.lighter(),
            cell_border_color: Color::White,
            ..Default::default()
        });

    wind.end();
    wind.show();

    // Just filling the vec with some values
    for i in 0..30 {
        for j in 0..15 {
            table.set_cell_value(i, j, &(i + j).to_string());
        }
    }
    table.redraw();

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

pub fn cell_value(&self, row: i32, col: i32) -> String

Get the cell value, using the row and column to index the data

Examples found in repository

examples/simple.rs (line 28)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    // We pass the rows and columns thru the TableOpts field
    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 30,
            editable: true,
            ..Default::default()
        });

    wind.end();
    wind.show();

    // set the value at the row,column 4,5 to "another", notice that indices start at 0
    table.set_cell_value(3, 4, "another");
    assert_eq!(table.cell_value(3, 4), "another");

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == enums::Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

examples/int_table.rs (line 34)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    // We pass the rows and columns thru the TableOpts field
    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 1000,
            editable: true,
            ..Default::default()
        });

    wind.end();
    wind.show();

    table
        .input()
        .as_mut()
        .unwrap()
        .set_type(input::InputType::Int);

    // set the value at the row,column 4,5 to "another", notice that indices start at 0
    table.set_cell_value(3, 4, "10");
    assert_eq!(table.cell_value(3, 4), "10");

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == enums::Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

pub fn set_cell_color(&mut self, row: i32, col: i32, color: Color)

Set the cell value, using the row and column to index the data

pub fn set_cell_selection_color(&mut self, row: i32, col: i32, color: Color)

Set the cell value, using the row and column to index the data

pub fn set_cell_font_color(&mut self, row: i32, col: i32, color: Color)

Set the cell value, using the row and column to index the data

pub fn set_cell_border_color(&mut self, row: i32, col: i32, color: Color)

Set the cell value, using the row and column to index the data

pub fn set_cell_font(&mut self, row: i32, col: i32, font: Font)

Set the cell value, using the row and column to index the data

pub fn set_cell_font_size(&mut self, row: i32, col: i32, sz: i32)

Set the cell value, using the row and column to index the data

pub fn set_cell_align(&mut self, row: i32, col: i32, align: Align)

Set the cell value, using the row and column to index the data

pub fn set_row_header_value(&mut self, row: i32, val: &str)

Set the row header value at the row index

Examples found in repository

examples/headers.rs (line 25)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 15,
            ..Default::default()
        });

    wind.end();
    wind.show();

    for i in 0..30 {
        table.set_row_header_value(i, &(i + 100).to_string());
    }

    for i in 0..15 {
        table.set_col_header_value(i, &i.to_string());
    }

    app.run().unwrap();
}

pub fn set_col_header_value(&mut self, col: i32, val: &str)

Set the column header value at the column index

Examples found in repository

examples/headers.rs (line 29)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 15,
            ..Default::default()
        });

    wind.end();
    wind.show();

    for i in 0..30 {
        table.set_row_header_value(i, &(i + 100).to_string());
    }

    for i in 0..15 {
        table.set_col_header_value(i, &i.to_string());
    }

    app.run().unwrap();
}

pub fn row_header_value(&mut self, row: i32) -> String

Get the row header value at the row index

pub fn col_header_value(&mut self, col: i32) -> String

Get the column header value at the column index

pub fn insert_empty_row(&mut self, row: i32, row_header: &str)

Insert an empty row at the row index

pub fn insert_row(&mut self, row: i32, row_header: &str, vals: &[&str])

Append a row to your table

pub fn append_empty_row(&mut self, row_header: &str)

Append an empty row to your table

pub fn append_row(&mut self, row_header: &str, vals: &[&str])

Append a row to your table

pub fn insert_empty_col(&mut self, col: i32, col_header: &str)

Insert an empty column at the column index

pub fn insert_col(&mut self, col: i32, col_header: &str, vals: &[&str])

Append a column to your table

pub fn append_empty_col(&mut self, col_header: &str)

Append an empty column to your table

pub fn append_col(&mut self, col_header: &str, vals: &[&str])

Append a column to your table

pub fn remove_row(&mut self, row: i32)

Remove a row at the row index

pub fn remove_col(&mut self, col: i32)

Remove a column at the column index

pub fn set_callback<F: FnMut(&mut Self) + 'static>(&mut self, cb: F)

Set a callback for the SmartTable

pub fn set_on_update_callback<F: FnMut(i32, i32, String) + Send + 'static>( &mut self, cb: F, )

Set a callback for on user input callback function takes the values row, col, and the new value of the cell

pub fn clear(&mut self)

Clears all cells in the table

pub fn row_count(&self) -> i32

Returns the row count

pub fn column_count(&self) -> i32

Returns the column count

pub fn col_width(&self, col: i32) -> i32

Get the column’s width

pub fn row_height(&self, row: i32) -> i32

Get the row’s height

pub fn set_col_width(&mut self, col: i32, width: i32)

Set column’s width

pub fn set_row_height(&mut self, row: i32, height: i32)

Set the row’s height

pub fn col_header_height(&self) -> i32

Get the column header height

pub fn row_header_width(&self) -> i32

Get the row header width

pub fn set_col_header_height(&mut self, height: i32)

Set column header height

pub fn set_row_header_width(&mut self, width: i32)

Set the row header width

impl SmartTable

pub fn with_pos(self, x: i32, y: i32) -> Self

Initialize to position x, y

pub fn with_size(self, width: i32, height: i32) -> Self

Initialize to size width, height

Examples found in repository

examples/headers.rs (line 13)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 15,
            ..Default::default()
        });

    wind.end();
    wind.show();

    for i in 0..30 {
        table.set_row_header_value(i, &(i + 100).to_string());
    }

    for i in 0..15 {
        table.set_col_header_value(i, &i.to_string());
    }

    app.run().unwrap();
}

examples/simple.rs (line 14)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    // We pass the rows and columns thru the TableOpts field
    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 30,
            editable: true,
            ..Default::default()
        });

    wind.end();
    wind.show();

    // set the value at the row,column 4,5 to "another", notice that indices start at 0
    table.set_cell_value(3, 4, "another");
    assert_eq!(table.cell_value(3, 4), "another");

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == enums::Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

examples/int_table.rs (line 14)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    // We pass the rows and columns thru the TableOpts field
    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 1000,
            editable: true,
            ..Default::default()
        });

    wind.end();
    wind.show();

    table
        .input()
        .as_mut()
        .unwrap()
        .set_type(input::InputType::Int);

    // set the value at the row,column 4,5 to "another", notice that indices start at 0
    table.set_cell_value(3, 4, "10");
    assert_eq!(table.cell_value(3, 4), "10");

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == enums::Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

examples/styled.rs (line 14)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 15,
            cell_selection_color: Color::Red.inactive(),
            header_frame: FrameType::FlatBox,
            header_color: Color::BackGround.lighter(),
            cell_border_color: Color::White,
            ..Default::default()
        });

    wind.end();
    wind.show();

    // Just filling the vec with some values
    for i in 0..30 {
        for j in 0..15 {
            table.set_cell_value(i, j, &(i + j).to_string());
        }
    }
    table.redraw();

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

pub fn with_label(self, title: &str) -> Self

Initialize with a label

pub fn with_align(self, align: Align) -> Self

Initialize with alignment

pub fn with_type<T: WidgetType>(self, typ: T) -> Self

Initialize with type

pub fn below_of<W: WidgetExt>(self, wid: &W, padding: i32) -> Self

Initialize at bottom of another widget

pub fn above_of<W: WidgetExt>(self, wid: &W, padding: i32) -> Self

Initialize above of another widget

pub fn right_of<W: WidgetExt>(self, wid: &W, padding: i32) -> Self

Initialize right of another widget

pub fn left_of<W: WidgetExt>(self, wid: &W, padding: i32) -> Self

Initialize left of another widget

pub fn center_of<W: WidgetExt>(self, w: &W) -> Self

Initialize center of another widget

pub fn center_x<W: WidgetExt>(self, w: &W) -> Self

Initialize center of another widget on the x axis

pub fn center_y<W: WidgetExt>(self, w: &W) -> Self

Initialize center of another widget on the y axis

pub fn center_of_parent(self) -> Self

Initialize center of parent

Examples found in repository

examples/headers.rs (line 14)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 15,
            ..Default::default()
        });

    wind.end();
    wind.show();

    for i in 0..30 {
        table.set_row_header_value(i, &(i + 100).to_string());
    }

    for i in 0..15 {
        table.set_col_header_value(i, &i.to_string());
    }

    app.run().unwrap();
}

examples/simple.rs (line 15)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    // We pass the rows and columns thru the TableOpts field
    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 30,
            editable: true,
            ..Default::default()
        });

    wind.end();
    wind.show();

    // set the value at the row,column 4,5 to "another", notice that indices start at 0
    table.set_cell_value(3, 4, "another");
    assert_eq!(table.cell_value(3, 4), "another");

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == enums::Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

examples/int_table.rs (line 15)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    // We pass the rows and columns thru the TableOpts field
    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 1000,
            editable: true,
            ..Default::default()
        });

    wind.end();
    wind.show();

    table
        .input()
        .as_mut()
        .unwrap()
        .set_type(input::InputType::Int);

    // set the value at the row,column 4,5 to "another", notice that indices start at 0
    table.set_cell_value(3, 4, "10");
    assert_eq!(table.cell_value(3, 4), "10");

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == enums::Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

examples/styled.rs (line 15)

fn main() {
    let app = app::App::default().with_scheme(app::Scheme::Gtk);
    let mut wind = window::Window::default().with_size(800, 600);

    let mut table = SmartTable::default()
        .with_size(790, 590)
        .center_of_parent()
        .with_opts(TableOpts {
            rows: 30,
            cols: 15,
            cell_selection_color: Color::Red.inactive(),
            header_frame: FrameType::FlatBox,
            header_color: Color::BackGround.lighter(),
            cell_border_color: Color::White,
            ..Default::default()
        });

    wind.end();
    wind.show();

    // Just filling the vec with some values
    for i in 0..30 {
        for j in 0..15 {
            table.set_cell_value(i, j, &(i + j).to_string());
        }
    }
    table.redraw();

    // To avoid closing the window on hitting the escape key
    wind.set_callback(move |_| {
        if app::event() == Event::Close {
            app.quit();
        }
    });

    app.run().unwrap();
}

pub fn size_of<W: WidgetExt>(self, w: &W) -> Self

Initialize to the size of another widget

pub fn size_of_parent(self) -> Self

Initialize to the size of the parent

Methods from Deref<Target = TableRow>

pub fn row_selected(&mut self, row: i32) -> bool

Returns whether a row was selected

pub fn select_row( &mut self, row: i32, selection_flag: TableRowSelectFlag, ) -> Result<(), FltkError>

Selects a row

Errors

Errors on failure to select row

pub fn select_all_rows(&mut self, selection_flag: TableRowSelectFlag)

Selects all rows

Trait Implementations

impl Clone for SmartTable

fn clone(&self) -> SmartTable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SmartTable

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

Formats the value using the given formatter.

impl Default for SmartTable

fn default() -> Self

Returns the “default value” for a type.

impl Deref for SmartTable

type Target = TableRow

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for SmartTable

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.