Struct WaveData

pub struct WaveData {

    pub inner: DataContainer,
    pub source: WaveSource,
    pub format: WaveFormat,
    pub active_scope: Option<ScopeType>,
    pub items_tree: DisplayedItemTree,
    pub displayed_items: HashMap<DisplayedItemRef, DisplayedItem>,
    pub display_item_ref_counter: usize,
    pub viewports: Vec<Viewport>,
    pub cursor: Option<BigInt>,
    pub markers: HashMap<u8, BigInt>,
    pub focused_item: Option<VisibleItemIndex>,
    pub focused_transaction: (Option<TransactionRef>, Option<Transaction>),
    pub default_variable_name_type: VariableNameType,
    pub scroll_offset: f32,
    pub display_variable_indices: bool,
    pub graphics: HashMap<GraphicId, Graphic>,
    pub drawing_infos: Vec<ItemDrawingInfo>,
    pub top_item_draw_offset: f32,
    pub total_height: f32,
    pub old_num_timestamps: Option<BigInt>,
}

Fields

inner: DataContainer

source: WaveSource

format: WaveFormat

active_scope: Option<ScopeType>

items_tree: DisplayedItemTree

Root items (variables, dividers, …) to display

displayed_items: HashMap<DisplayedItemRef, DisplayedItem>

display_item_ref_counter: usize

Tracks the consecutive displayed item refs

viewports: Vec<Viewport>

cursor: Option<BigInt>

markers: HashMap<u8, BigInt>

focused_item: Option<VisibleItemIndex>

focused_transaction: (Option<TransactionRef>, Option<Transaction>)

default_variable_name_type: VariableNameType

scroll_offset: f32

display_variable_indices: bool

graphics: HashMap<GraphicId, Graphic>

drawing_infos: Vec<ItemDrawingInfo>

These are just stored during operation, so no need to serialize

top_item_draw_offset: f32

total_height: f32

old_num_timestamps: Option<BigInt>

used by the update_viewports method after loading a new file

Implementations

impl WaveData

fn get_item_y(&self, y: &GraphicsY) -> Option<f32>

pub(crate) fn draw_graphics( &self, ctx: &mut DrawingContext<'_>, size: Vec2, viewport: &Viewport, theme: &SurferTheme, )

impl WaveData

pub fn draw_cursor( &self, theme: &SurferTheme, ctx: &mut DrawingContext<'_>, size: Vec2, viewport: &Viewport, )

pub fn draw_markers( &self, theme: &SurferTheme, ctx: &mut DrawingContext<'_>, size: Vec2, viewport: &Viewport, )

pub fn can_add_marker(&self) -> bool

pub fn add_marker( &mut self, location: &BigInt, name: Option<String>, move_focus: bool, )

pub fn remove_marker(&mut self, idx: u8)

pub fn set_marker_position(&mut self, idx: u8, location: &BigInt)

Set the marker with the specified id to the location. If the marker doesn’t exist already, it will be created

pub fn move_marker_to_cursor(&mut self, idx: u8)

pub fn draw_marker_number_boxes( &self, ctx: &mut DrawingContext<'_>, size: Vec2, theme: &SurferTheme, viewport: &Viewport, )

impl WaveData

pub fn get_ticks( &self, viewport: &Viewport, timescale: &TimeScale, frame_width: f32, text_size: f32, wanted_timeunit: &TimeUnit, time_format: &TimeFormat, config: &SurferConfig, ) -> Vec<(String, f32)>

Get suitable tick locations for the current view port. The method is based on guessing the length of the time string and is inspired by the corresponding code in Matplotlib.

pub fn draw_tick_line( &self, x: f32, ctx: &mut DrawingContext<'_>, stroke: &Stroke, )

pub fn draw_ticks( &self, color: Option<&Color32>, ticks: &Vec<(String, f32)>, ctx: &DrawingContext<'_>, y_offset: f32, align: Align2, config: &SurferConfig, )

Draw the text for each tick location.

impl WaveData

pub fn compute_variable_display_names(&mut self)

pub fn force_variable_name_type(&mut self, name_type: VariableNameType)

impl WaveData

pub fn update_with_waves( self, new_waves: Box<WaveContainer>, source: WaveSource, format: WaveFormat, translators: &TranslatorList, keep_unavailable: bool, ) -> (WaveData, Option<LoadSignalsCmd>)

pub fn update_with_items( &mut self, new_items: &HashMap<DisplayedItemRef, DisplayedItem>, items_tree: DisplayedItemTree, translators: &TranslatorList, ) -> Option<LoadSignalsCmd>

fn update_metadata(&mut self, translators: &TranslatorList)

Go through all signals and update the metadata for all signals

Used after loading new waves, signals or switching a bunch of translators

fn load_waves(&mut self) -> Option<LoadSignalsCmd>

Get the underlying wave container to load all signals that are being displayed

This is needed for wave containers that lazy-load signals.

pub fn update_viewports(&mut self)

Needs to be called after update_with, once the new number of timestamps is available in the inner WaveContainer.

fn update_displayed_items( &self, waves: &WaveContainer, items: &HashMap<DisplayedItemRef, DisplayedItem>, keep_unavailable: bool, translators: &TranslatorList, ) -> HashMap<DisplayedItemRef, DisplayedItem>

pub fn select_preferred_translator( &self, var: VariableMeta, translators: &TranslatorList, ) -> String

pub fn variable_translator<'a>( &'a self, field: &DisplayedFieldRef, translators: &'a TranslatorList, ) -> &'a DynTranslator

pub fn add_variables( &mut self, translators: &TranslatorList, variables: Vec<VariableRef>, target_position: Option<TargetPosition>, update_display_names: bool, ) -> (Option<LoadSignalsCmd>, Vec<DisplayedItemRef>)

pub fn remove_displayed_item(&mut self, id: DisplayedItemRef)

pub fn add_divider( &mut self, name: Option<String>, vidx: Option<VisibleItemIndex>, )

pub fn add_timeline(&mut self, vidx: Option<VisibleItemIndex>)

pub fn add_group( &mut self, name: String, target_position: Option<TargetPosition>, ) -> DisplayedItemRef

pub fn add_generator(&mut self, gen_ref: TransactionStreamRef)

pub fn add_stream(&mut self, stream_ref: TransactionStreamRef)

pub fn add_all_streams(&mut self)

fn vidx_insert_position( &self, vidx: Option<VisibleItemIndex>, ) -> Option<TargetPosition>

pub fn focused_insert_position(&self) -> Option<TargetPosition>

Return an insert position based on the focused item

If an item is focused, and it is

• an unfolded group, insert index is to the first element of the group
• a folded group, insert index is to before the next sibling (if exists)
• otherwise insert index is past it on the same level

pub fn end_insert_position(&self) -> TargetPosition

pub fn index_for_ref_or_focus( &self, item_ref: Option<DisplayedItemRef>, ) -> Option<ItemIndex>

pub(crate) fn insert_item( &mut self, new_item: DisplayedItem, target_position: Option<TargetPosition>, move_focus: bool, ) -> DisplayedItemRef

Insert item after item vidx if Some(vidx). If None, insert in relation to focused item (see Self::focused_insert_position()). If nothing is selected, fall back to appending. Focus on the inserted item if there was a focused item.

pub fn go_to_cursor_if_not_in_view(&mut self) -> bool

pub fn numbered_marker_location( &self, idx: u8, viewport: &Viewport, view_width: f32, ) -> f32

pub fn numbered_marker_time(&self, idx: u8) -> &BigInt

pub fn viewport_all(&self) -> Viewport

pub fn remove_placeholders(&mut self)

pub fn any_displayed(&self) -> bool

pub fn get_top_item(&self) -> usize

Find the top-most of the currently visible items.

pub fn get_item_at_y(&self, y: f32) -> Option<VisibleItemIndex>

Find the item at a given y-location.

pub fn scroll_to_item(&mut self, idx: usize)

pub fn set_cursor_at_transition( &mut self, next: bool, variable: Option<VisibleItemIndex>, skip_zero: bool, )

Set cursor at next (or previous, if next is false) transition of variable. If skip_zero is true, use the next transition to a non-zero value.

pub fn next_displayed_item_ref(&mut self) -> DisplayedItemRef

pub fn num_timestamps(&self) -> Option<BigInt>

Returns the number of timestamps in the current waves. For now, this adjusts the number of timestamps as returned by wave sources if they specify 0 timestamps. This is done to avoid having to consider what happens with the viewport.

pub fn get_displayed_item_index( &self, item_ref: &DisplayedItemRef, ) -> Option<VisibleItemIndex>

Trait Implementations

impl<'de> Deserialize<'de> for WaveData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for WaveData

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.