Struct BufferOpts 

pub struct BufferOpts {

    pub highlight_current_line: bool,
    pub wrap_lines: bool,
    pub wrap_on_word: bool,
    pub wrapping_cap: Option<u32>,
    pub indent_wraps: bool,
    pub tabstop: u8,
    pub scrolloff: ScrollOff,
    pub force_scrolloff: bool,
    pub extra_word_chars: &'static [char],
    pub indent_str: Option<&'static str>,
    pub indent_str_on_empty: bool,
    pub indent_tab_str: Option<&'static str>,
    pub space_char: Option<char>,
    pub space_char_trailing: Option<char>,
    pub new_line_char: char,
    pub new_line_on_empty: Option<char>,
    pub new_line_trailing: Option<char>,
}

The default suite of options available to Buffers

Unlike most other widget options, these ones are dynamic, that is, if they are changed while duat is still open, the Buffer will be updated accordingly.

Note

While these options are defined as a core part of the Buffer, they are not implemented natively. The implementation is done in the duat-base crate, which means you may replace the implementation with your own version if that suits you.

Fields

highlight_current_line: bool

Highlights the current line

The default is true

This makes use of the current_line Form

wrap_lines: bool

Enables wrapping of lines

The default is true

wrap_on_word: bool

Wrap on word boundaries, rather than on any character

The default is false.

wrapping_cap: Option<u32>

Where to start wrapping

The default is None

If this value is None and opts.wrap_lines == true, then wrapping will take place at the right edge of the screen.

Otherwise, if it is Some({cap}), then wrapping will take place {cap} cells from the left edge. This value may or may not be greater than the width of the area. If it is greater than it, then wrapping will take place slightly outside the screen as a concequence.

indent_wraps: bool

Whether to indent wrapped lines or not

The default is true.

This turns this:

    This is a very long line of text, so long that it
wraps around

Into this:

    This is a very long line of text, so long that it
    wraps around

tabstop: u8

How much space a tab should occupy

The default is 4

This also affect other things, like if your tabs are converted into spaces, this will also set how many spaces should be added.

scrolloff: ScrollOff

How much space to keep between the cursor and edges

The default is ScrollOff { x: 3, y: 3 }

force_scrolloff: bool

Whether to limit scrolloff at the end of lines

The default is false

This makes it so, as you reach the end of a long line of text, the cursor line will continue scrolling to the left, maintaining the scrolloff.x’s gap.

extra_word_chars: &'static [char]

Extra characters to be considered part of a word

The default is &[].

Normally, word characters include all of those in the \w character set, which most importantly includes [0-9A-Za-z_].

You can use this setting to add more characters to that list, usually something like -, $ or @, which are useful to consider as word characters in some circumstances.

indent_str: Option<&'static str>

Indent string

The default is Some("│").

The indent lines will be printed with the replace.indent Form.

A string to replace the indentation at the start of the line. This string will repeat on every opts.tabstop initial spaces or on every \t character, replacing that many characters of the tab stop with those of the string.

For example, if tabstop == 2 && indent_str == Some("│ "), this:

int (int var1, int var2) {
  if (var1 > 2)
    return 42;
  else
    if (var1 <= 50)
      return 20;
    else
      return 10;
}

Would be displayed like this:

int (int var1, int var2) {
│ if (var1 > 2)
│ │ return 42;
│ else
│ │ if (var1 <= 50)
│ │ │ return 20;
│ │ else
│ │ │ return 10;
}

That is, it will take tabstop characters and print them. Where the tabstop == 4, it would use all 4 characters.

indent_str_on_empty: bool

Wether to copy the indentation string of opts.indent_str on empty lines.

The default is true

If this is set to true, this str will be printed with the replace.indent.empty form.

This will always copy whichever line has the smallest ammount of indentation.

indent_tab_str: Option<&'static str>

An indent string, just like opts.indent_str, but only for \ts

The default is None

This is useful for languages like python, where the mixup of tabs and spaces on indentation can cause problems.

If it is Some, the str will be shown with the replace.indent.tab form. If this is None, then opts.indent_str will be used instead.

space_char: Option<char>

A character to be printed in place of the space

The default is None

The char will be printed with the replace.space Form.

This character will replace only the space characters that are not part of the indentation.

space_char_trailing: Option<char>

A character to be printed on trailing whitespace

The default is None

This character will be printed with the replace.space.trailing Form

If it is None, it will be the same as opts.space_char.

new_line_char: char

Which char should be printed in new lines

The default is ' ' (space character)

This character will be printed with the replace.new_line Form.

new_line_on_empty: Option<char>

A character to be printed on the new line on empty strings

The default is None

This character will be printed with the replace.new_line.empty Form.

If it is None, it will be the same as opts.new_line_char.

new_line_trailing: Option<char>

A character to be printed on trailing new lines

The default is None

This character will be printed with the replace.new_line.trailing Form.

Implementations

impl BufferOpts

pub fn to_print_opts(&self) -> PrintOpts

Gets PrintOpts from this BufferOpts

Trait Implementations

impl Clone for BufferOpts

fn clone(&self) -> BufferOpts

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BufferOpts

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

Formats the value using the given formatter.

impl Default for BufferOpts

fn default() -> Self

Returns the “default value” for a type.

impl Hash for BufferOpts

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BufferOpts

fn eq(&self, other: &BufferOpts) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for BufferOpts

impl Eq for BufferOpts

impl StructuralPartialEq for BufferOpts