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>,
    pub cache_generation: u64,
    pub inflight_caches: HashMap<AnalogCacheKey, Arc<AnalogCacheEntry>>,
}

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>

cache_generation: u64

Generation counter for analog cache invalidation on waveform reload.

inflight_caches: HashMap<AnalogCacheKey, Arc<AnalogCacheEntry>>

Registry of in-flight analog cache builds for sharing. Cleared on waveform reload when generation changes.

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

fn get_marker_color(&self, idx: u8, theme: &SurferTheme) -> Color32

Get the color for a marker by its index, falling back to cursor color if not found

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, ) -> Option<DisplayedItemRef>

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)

fn draw_text_with_background( ctx: &mut DrawingContext<'_>, x: f32, y: f32, text: &str, text_size: f32, background_color: Color32, foreground_color: Color32, padding: f32, )

Draw text with background box at the specified position Returns the text and its background rectangle info for reuse if needed

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

impl WaveData

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

pub fn draw_ticks( &self, color: Color32, ticks: &[(String, f32)], ctx: &DrawingContext<'_>, y_offset: f32, align: Align2, )

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 variable_translator_with_meta<'a>( &'a self, field: &DisplayedFieldRef, translators: &'a TranslatorList, meta: &VariableMeta, ) -> &'a DynTranslator

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

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

Remove a single item, it’s legal to call this function with an invalid ID

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)

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

Return an insert position based on item

If an item is passed, 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

Return insert position as last item

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 safe_num_timestamps(&self) -> BigInt

Returns the number of timestamps in the current waves. This is like num_timestamps but will always return at least 1.

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

pub fn build_analog_cache_async( &self, entry: Arc<AnalogCacheEntry>, variable_ref: &VariableRef, translator: AnyTranslator, sender: &Sender<Message>, ) -> Option<()>

Spawn async worker to build analog cache. Worker holds Arc clone.

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.