Struct cursive_hexview::HexView

pub struct HexView { /* fields omitted */ }

This is a classic hexview which can be used to view and manipulate data which resides inside this struct. There are severeal states in which the view can be operatered, see DisplayState. You should consider the corresponding method docs for each state.

Examples

extern crate cursive;
extern crate cursive_hexview;

use cursive_hexview::{DisplayState,HexView};

fn main() {
    let view = HexView::new().display_state(DisplayState::Editable);
    let mut cur = cursive::Cursive::new();

    cur.add_layer(cursive::views::Dialog::around(view).title("HexView"));

    // cur.run();
}

Methods

impl HexView

fn new() -> HexView

Creates a new, default HexView with an empty databuffer and disabled state.

Examples

let view = HexView::new();

fn new_from_iter<B: Borrow<u8>, I: IntoIterator<Item = B>>(data: I) -> HexView

Crates a new HexView with the given data and disabled state.

Examples

With data from a Vec:

let view = HexView::new_from_iter(vec![3, 6, 1, 8, 250]);

With data from a byte string literal:

let view = HexView::new_from_iter(b"Hello, World!");

Or with a slice

let view = HexView::new_from_iter(&[5, 6, 2, 89]);

fn data(&self) -> &Vec<u8>

Returns a reference to the internal data.

Examples

let data = vec![3, 4, 9, 1];
let view = HexView::new_from_iter(data.clone());
assert_eq!(view.data(), &data);

fn set_data<B: Borrow<u8>, I: IntoIterator<Item = B>>(&mut self, data: I)

This methods lets set you data during the lifetime of this instance (e.g. the data has been updated due to an external event).

let mut view = cursive_hexview::HexView::new();
view.set_data(b"Hello, World!".to_owned().iter());

fn display_state(self, state: DisplayState) -> Self

set_display_state

fn set_display_state(&mut self, state: DisplayState)

Sets the state of the view to one of the variants from DisplayState. This will alter the behavoir of the view accrodingly to the set state.

If the state is set to Disabled this view can neither be focused nor edited. If the state is set to Enabled it can be focused and the cursor can be moved around, but no data can be altered. If set to Editable this view behaves like Enabled but the data can be altered.

Note

This has nothing to do with rusts type system, which means even when this instance is set to Disabled you still can alter the data through set_data but you cannot alter it with the keyboard commands (+, -, #hexvalue).

Examples

let view = HexView::new().display_state(DisplayState::Editable);

fn len(&self) -> usize

Returns the length of the data.

Examples

let view = HexView::new_from_iter(vec![0, 1, 2, 3]);
assert_eq!(4, view.len());

fn is_empty(&self) -> bool

Checks whether the data is empty.

Examples

let view = HexView::new();
assert!(view.is_empty());

let view = HexView::new_from_iter(b"ABC");
assert!(!view.is_empty());

fn set_len(&mut self, length: usize)

Sets the length of the data which this view displays. If the new length is greater than the current one, 0's will be appended to the data. If the new length is less than the current one, the data will be truncated and is lost.

Examples

let mut view = HexView::new();
view.set_len(3);
 
assert_eq!(view.len(), 3);
assert_eq!(view.data(), &vec![0u8, 0u8, 0u8]);

Trait Implementations

impl Default for HexView

fn default() -> Self

Creates a new, default HexView with an empty databuffer and disabled state.

impl View for HexView

fn on_event(&mut self, event: Event) -> EventResult

Called when a key was pressed.

fn required_size(&mut self, _: Vec2) -> Vec2

Returns the minimum size the view requires with the given restrictions.

fn draw(&self, printer: &Printer)

Draws the view with the given printer (includes bounds) and focus.

fn take_focus(&mut self, _: Direction) -> bool

This view is offered focus. Will it take it?

fn needs_relayout(&self) -> bool

Returns true if the view content changed since last layout phase.

fn layout(&mut self, XY<usize>)

Called once the size for this view has been decided,

fn call_on_any(&mut self, &Selector, Box<FnMut(&mut (Any + 'static)) + 'a>)

Runs a closure on the view identified by the given selector.

fn focus_view(&mut self, &Selector) -> Result<(), ()>

Moves the focus to the view identified by the given selector.