Struct HexView 

pub struct HexView { /* private fields */ }

Hexadecimal viewer.

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::dummy();

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

    // cur.run();
}

Implementations

impl HexView

pub fn new() -> Self

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

Examples

let view = HexView::new();

Examples found in repository

examples/default.rs (line 10)

fn main() {
    let mut cur = cursive::default();
    let explanation = TextView::new("Use the keys + - ↑ ↓ ← → 0-9 a-f for the HexView.\nUse q to exit.");
    let view = HexView::new().display_state(DisplayState::Editable);

    cur.add_layer(
        Dialog::around(LinearLayout::vertical().child(explanation).child(DummyView).child(view)).title("HexView"),
    );
    cur.add_global_callback('q', |cur| cur.quit());
    cur.run();
}

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

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]);

Examples found in repository

examples/hexdump.rs (line 26)

fn main() {
    let arg = env::args()
        .nth(1)
        .expect("Please provide the file to read from as first argument");
    let path = Path::new(&arg);

    let mut cur = cursive::default();
    let explanation = TextView::new("Use the keys ↑ ↓ ← → to navigate around.\nUse q to exit.");
    let view = HexView::new_from_iter(read_file(path).expect("Cannot read file")).display_state(DisplayState::Enabled);

    cur.add_layer(
        Dialog::around(LinearLayout::vertical().child(explanation).child(DummyView).child(view)).title("HexView"),
    );
    cur.add_global_callback('q', |cur| cur.quit());
    cur.run();
}

examples/config.rs (line 13)

fn main() {
    let mut cur = cursive::default();
    let explanation = TextView::new("Use the keys + - ↑ ↓ ← → 0-9 a-f for the HexView.\nUse q to exit.");
    let data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".as_bytes();

    //A view with implicit default config
    let view1 = HexView::new_from_iter(data).display_state(DisplayState::Editable);

    //A view with a single config change, everything else default, chainable version
    let config = HexViewConfig {
        hex_ascii_separator: " - ",
        ..Default::default()
    };
    let view2 = HexView::new_from_iter(data)
        .config(config)
        .display_state(DisplayState::Editable);

    //A view with several config changes, non chainable version
    let mut view3 = HexView::new_from_iter(data).display_state(DisplayState::Editable);
    let config2 = HexViewConfig {
        bytes_per_line: 8,
        bytes_per_group: 4,
        byte_group_separator: "     ",
        show_ascii: false,
        ..Default::default()
    };
    view3.set_config(config2);

    cur.add_layer(
        Dialog::around(
            LinearLayout::vertical()
                .child(explanation)
                .child(DummyView)
                .child(view1)
                .child(DummyView)
                .child(view2)
                .child(DummyView)
                .child(view3),
        )
        .title("HexView"),
    );
    cur.add_global_callback('q', |cur| cur.quit());
    cur.run();
}

pub fn set_config(&mut self, config: HexViewConfig)

This function allows the customization of the HexView output.

For options and explanation of every possible option, see the HexViewConfig struct.

#Examples

let mut view = HexView::new();
view.set_config(HexViewConfig {
    bytes_per_line: 8,
    ..Default::default()
});

Examples found in repository

examples/config.rs (line 33)

fn main() {
    let mut cur = cursive::default();
    let explanation = TextView::new("Use the keys + - ↑ ↓ ← → 0-9 a-f for the HexView.\nUse q to exit.");
    let data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".as_bytes();

    //A view with implicit default config
    let view1 = HexView::new_from_iter(data).display_state(DisplayState::Editable);

    //A view with a single config change, everything else default, chainable version
    let config = HexViewConfig {
        hex_ascii_separator: " - ",
        ..Default::default()
    };
    let view2 = HexView::new_from_iter(data)
        .config(config)
        .display_state(DisplayState::Editable);

    //A view with several config changes, non chainable version
    let mut view3 = HexView::new_from_iter(data).display_state(DisplayState::Editable);
    let config2 = HexViewConfig {
        bytes_per_line: 8,
        bytes_per_group: 4,
        byte_group_separator: "     ",
        show_ascii: false,
        ..Default::default()
    };
    view3.set_config(config2);

    cur.add_layer(
        Dialog::around(
            LinearLayout::vertical()
                .child(explanation)
                .child(DummyView)
                .child(view1)
                .child(DummyView)
                .child(view2)
                .child(DummyView)
                .child(view3),
        )
        .title("HexView"),
    );
    cur.add_global_callback('q', |cur| cur.quit());
    cur.run();
}

pub fn config(self, config: HexViewConfig) -> Self

set_config

Examples found in repository

examples/config.rs (line 21)

fn main() {
    let mut cur = cursive::default();
    let explanation = TextView::new("Use the keys + - ↑ ↓ ← → 0-9 a-f for the HexView.\nUse q to exit.");
    let data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".as_bytes();

    //A view with implicit default config
    let view1 = HexView::new_from_iter(data).display_state(DisplayState::Editable);

    //A view with a single config change, everything else default, chainable version
    let config = HexViewConfig {
        hex_ascii_separator: " - ",
        ..Default::default()
    };
    let view2 = HexView::new_from_iter(data)
        .config(config)
        .display_state(DisplayState::Editable);

    //A view with several config changes, non chainable version
    let mut view3 = HexView::new_from_iter(data).display_state(DisplayState::Editable);
    let config2 = HexViewConfig {
        bytes_per_line: 8,
        bytes_per_group: 4,
        byte_group_separator: "     ",
        show_ascii: false,
        ..Default::default()
    };
    view3.set_config(config2);

    cur.add_layer(
        Dialog::around(
            LinearLayout::vertical()
                .child(explanation)
                .child(DummyView)
                .child(view1)
                .child(DummyView)
                .child(view2)
                .child(DummyView)
                .child(view3),
        )
        .title("HexView"),
    );
    cur.add_global_callback('q', |cur| cur.quit());
    cur.run();
}

pub fn data(&self) -> &[u8]

Returns a reference to the internal data.

Examples

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

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

Sets the data during the lifetime of this instance.

For insance to update the data due to an external event.

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

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

set_display_state

Examples found in repository

examples/default.rs (line 10)

fn main() {
    let mut cur = cursive::default();
    let explanation = TextView::new("Use the keys + - ↑ ↓ ← → 0-9 a-f for the HexView.\nUse q to exit.");
    let view = HexView::new().display_state(DisplayState::Editable);

    cur.add_layer(
        Dialog::around(LinearLayout::vertical().child(explanation).child(DummyView).child(view)).title("HexView"),
    );
    cur.add_global_callback('q', |cur| cur.quit());
    cur.run();
}

examples/hexdump.rs (line 26)

fn main() {
    let arg = env::args()
        .nth(1)
        .expect("Please provide the file to read from as first argument");
    let path = Path::new(&arg);

    let mut cur = cursive::default();
    let explanation = TextView::new("Use the keys ↑ ↓ ← → to navigate around.\nUse q to exit.");
    let view = HexView::new_from_iter(read_file(path).expect("Cannot read file")).display_state(DisplayState::Enabled);

    cur.add_layer(
        Dialog::around(LinearLayout::vertical().child(explanation).child(DummyView).child(view)).title("HexView"),
    );
    cur.add_global_callback('q', |cur| cur.quit());
    cur.run();
}

examples/config.rs (line 13)

fn main() {
    let mut cur = cursive::default();
    let explanation = TextView::new("Use the keys + - ↑ ↓ ← → 0-9 a-f for the HexView.\nUse q to exit.");
    let data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".as_bytes();

    //A view with implicit default config
    let view1 = HexView::new_from_iter(data).display_state(DisplayState::Editable);

    //A view with a single config change, everything else default, chainable version
    let config = HexViewConfig {
        hex_ascii_separator: " - ",
        ..Default::default()
    };
    let view2 = HexView::new_from_iter(data)
        .config(config)
        .display_state(DisplayState::Editable);

    //A view with several config changes, non chainable version
    let mut view3 = HexView::new_from_iter(data).display_state(DisplayState::Editable);
    let config2 = HexViewConfig {
        bytes_per_line: 8,
        bytes_per_group: 4,
        byte_group_separator: "     ",
        show_ascii: false,
        ..Default::default()
    };
    view3.set_config(config2);

    cur.add_layer(
        Dialog::around(
            LinearLayout::vertical()
                .child(explanation)
                .child(DummyView)
                .child(view1)
                .child(DummyView)
                .child(view2)
                .child(DummyView)
                .child(view3),
        )
        .title("HexView"),
    );
    cur.add_global_callback('q', |cur| cur.quit());
    cur.run();
}

pub 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 behavior 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);

pub 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());

pub 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());

pub 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 an event is received (key press, mouse event, …).

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) -> Result<EventResult, CannotFocus>

Attempt to give this view the focus.

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

Called once the size for this view has been decided.

fn needs_relayout(&self) -> bool

Should return true if the view content changed since the last call to layout().

fn call_on_any( &mut self, _: &Selector<'_>, _: &mut dyn FnMut(&mut (dyn View + 'static)), )

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

fn focus_view(&mut self, _: &Selector<'_>) -> Result<EventResult, ViewNotFound>

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

fn important_area(&self, view_size: XY<usize>) -> Rect

What part of the view is important and should be visible?

fn type_name(&self) -> &'static str

Returns the type of this view.