Struct SystemState

pub struct SystemState {

    pub user: UserState,
    pub(crate) translators: TranslatorList,
    pub channels: Channels,
    pub(crate) progress_tracker: Option<LoadProgress>,
    pub(crate) command_prompt: CommandPrompt,
    pub(crate) context: Option<Arc<Context>>,
    pub(crate) batch_messages: VecDeque<Message>,
    pub(crate) batch_messages_completed: bool,
    pub(crate) wcp_server_thread: Option<JoinHandle<()>>,
    pub(crate) wcp_server_address: Option<String>,
    pub(crate) wcp_stop_signal: Arc<AtomicBool>,
    pub(crate) wcp_running_signal: Arc<AtomicBool>,
    pub(crate) wcp_greeted_signal: Arc<AtomicBool>,
    pub(crate) wcp_client_capabilities: WcpClientCapabilities,
    pub(crate) draw_data: RefCell<Vec<Option<CachedDrawData>>>,
    pub(crate) variable_name_info_cache: RefCell<HashMap<VariableRef, Option<VariableNameInfo>>>,
    pub(crate) gesture_start_location: Option<Pos2>,
    pub(crate) measure_start_location: Option<Pos2>,
    pub(crate) url: RefCell<String>,
    pub(crate) command_prompt_text: RefCell<String>,
    pub(crate) last_canvas_rect: RefCell<Option<Rect>>,
    pub(crate) item_renaming_string: RefCell<String>,
    pub(crate) items_to_expand: RefCell<Vec<(DisplayedItemRef, usize)>>,
    pub(crate) char_to_add_to_prompt: RefCell<Option<char>>,
    pub(crate) continuous_redraw: bool,
    pub(crate) rendering_cpu_times: VecDeque<f32>,
    pub(crate) timing: RefCell<Timing>,
    pub(crate) undo_stack: Vec<CanvasState>,
    pub(crate) redo_stack: Vec<CanvasState>,
    pub(crate) url_callback: Option<Box<dyn Fn(String) -> Message + Send + 'static>>,
    pub(crate) expand_parameter_section: bool,
}

Fields

user: UserState

translators: TranslatorList

Which translator to use for each variable

channels: Channels

Channels for messages generated by other threads

progress_tracker: Option<LoadProgress>

Tracks progress of file/variable loading operations.

command_prompt: CommandPrompt

Buffer for the command input

context: Option<Arc<Context>>

The context to egui, we need this to change the visual settings when the config is reloaded

batch_messages: VecDeque<Message>

List of batch messages which will executed as soon as possible

batch_messages_completed: bool

wcp_server_thread: Option<JoinHandle<()>>

The WCP server

wcp_server_address: Option<String>

wcp_stop_signal: Arc<AtomicBool>

wcp_running_signal: Arc<AtomicBool>

wcp_greeted_signal: Arc<AtomicBool>

wcp_client_capabilities: WcpClientCapabilities

draw_data: RefCell<Vec<Option<CachedDrawData>>>

The draw commands for every variable currently selected

variable_name_info_cache: RefCell<HashMap<VariableRef, Option<VariableNameInfo>>>

gesture_start_location: Option<Pos2>

measure_start_location: Option<Pos2>

url: RefCell<String>

command_prompt_text: RefCell<String>

last_canvas_rect: RefCell<Option<Rect>>

item_renaming_string: RefCell<String>

items_to_expand: RefCell<Vec<(DisplayedItemRef, usize)>>

These items should be expanded into subfields in the next frame. Cleared after each frame

char_to_add_to_prompt: RefCell<Option<char>>

Character to add to the command prompt if it is visible. This is only needed for presentations at them moment.

continuous_redraw: bool

Invalidate draw commands every frame to make performance comparison easier

rendering_cpu_times: VecDeque<f32>

timing: RefCell<Timing>

undo_stack: Vec<CanvasState>

redo_stack: Vec<CanvasState>

url_callback: Option<Box<dyn Fn(String) -> Message + Send + 'static>>

expand_parameter_section: bool

Implementations

impl SystemState

pub(crate) fn handle_batch_commands(&mut self)

After user messages are addressed, we try to execute batch commands as they are ready to run

pub(crate) fn can_start_batch_command(&self) -> bool

Returns whether it is OK to start a new batch command.

pub fn batch_commands_completed(&self) -> bool

Returns true once all batch commands have been completed and their effects are all executed.

pub fn add_batch_commands<I: IntoIterator<Item = String>>( &mut self, commands: I, )

pub fn add_batch_messages<I: IntoIterator<Item = Message>>( &mut self, messages: I, )

pub fn add_batch_message(&mut self, msg: Message)

pub fn parse_batch_commands<I: IntoIterator<Item = String>>( &mut self, cmds: I, ) -> Vec<Message>

pub fn load_commands_from_url(&mut self, url: String)

impl SystemState

pub fn draw_performance_graph(&self, ctx: &Context, msgs: &mut Vec<Message>)

impl SystemState

pub(crate) fn draw_open_sibling_state_file_dialog( &self, ctx: &Context, dialog: &OpenSiblingStateFileDialog, msgs: &mut Vec<Message>, )

Draw a dialog that asks the user if it wants to load a state file situated in the same directory as the waveform file.

pub(crate) fn draw_reload_waveform_dialog( &self, ctx: &Context, dialog: &ReloadWaveformDialog, msgs: &mut Vec<Message>, )

Draw a dialog that asks for user confirmation before re-loading a file. This is triggered by a file loading event from disk.

impl SystemState

pub fn invalidate_draw_commands(&mut self)

pub fn generate_draw_commands( &self, cfg: &DrawConfig, frame_width: f32, msgs: &mut Vec<Message>, viewport_idx: usize, )

fn generate_wave_draw_commands( &self, waves: &WaveData, cfg: &DrawConfig, frame_width: f32, msgs: &mut Vec<Message>, viewport_idx: usize, ) -> Option<CachedDrawData>

fn generate_transaction_draw_commands( &self, waves: &WaveData, cfg: &DrawConfig, frame_width: f32, msgs: &mut Vec<Message>, viewport_idx: usize, ) -> Option<CachedDrawData>

fn transform_pos(&self, to_screen: RectTransform, p: Pos2, ui: &Ui) -> Pos2

pub fn draw_items( &mut self, egui_ctx: &Context, msgs: &mut Vec<Message>, ui: &mut Ui, viewport_idx: usize, )

fn draw_wave_data( &self, waves: &WaveData, draw_data: &CachedWaveDrawData, ctx: &mut DrawingContext<'_>, )

fn draw_transaction_data( &self, waves: &WaveData, draw_data: &CachedTransactionDrawData, viewport_idx: usize, frame_width: f32, cfg: &DrawConfig, ui: &mut Ui, msgs: &mut Vec<Message>, ctx: &mut DrawingContext<'_>, )

fn draw_region( &self, ((old_x, prev_region), (new_x, _)): (&(f32, DrawnRegion), &(f32, DrawnRegion)), user_color: Color32, offset: f32, height_scaling_factor: f32, ctx: &mut DrawingContext<'_>, text_color: Color32, )

fn draw_bool_transition( &self, ((old_x, prev_region), (new_x, new_region)): (&(f32, DrawnRegion), &(f32, DrawnRegion)), force_anti_alias: bool, color: Color32, offset: f32, height_scaling_factor: f32, draw_clock_marker: bool, draw_background: bool, ctx: &mut DrawingContext<'_>, )

fn draw_arrow( &self, start: Pos2, end: Pos2, color: Color32, ctx: &DrawingContext<'_>, )

Draws a curvy arrow from start to end.

fn draw_arrowheads( &self, vec_start: Pos2, vec_tip: Pos2, ctx: &DrawingContext<'_>, stroke: Stroke, )

Draws arrowheads for the vector going from vec_start to vec_tip. The angle has to be in degrees.

fn handle_canvas_context_menu( &self, response: Response, waves: &WaveData, to_screen: RectTransform, ctx: &mut DrawingContext<'_>, msgs: &mut Vec<Message>, viewport_idx: usize, )

fn snap_to_edge( &self, pointer_pos_canvas: Option<Pos2>, waves: &WaveData, frame_width: f32, viewport_idx: usize, ) -> Option<BigInt>

Takes a pointer pos in the canvas and returns a position that is snapped to transitions if the cursor is close enough to any transition. If the cursor is on the canvas and no transitions are close enough for snapping, the raw point will be returned. If the cursor is off the canvas, None is returned

pub fn draw_line( &self, time: &BigInt, ctx: &mut DrawingContext<'_>, size: Vec2, viewport: &Viewport, waves: &WaveData, )

impl SystemState

fn file_dialog<F>( &mut self, title: &'static str, filter: (String, Vec<String>), message: F, )

where F: FnOnce(PathBuf) -> Message + Send + 'static,

pub fn open_file_dialog(&mut self, mode: OpenMode)

pub fn open_command_file_dialog(&mut self)

impl SystemState

pub fn help_message(&self, ui: &mut Ui)

impl SystemState

pub fn handle_pressed_keys(&self, ctx: &Context, msgs: &mut Vec<Message>)

pub fn get_count(&self) -> usize

impl SystemState

pub fn draw_log_window(&self, ctx: &Context, msgs: &mut Vec<Message>)

impl SystemState

pub fn draw_marker_window( &self, waves: &WaveData, ctx: &Context, msgs: &mut Vec<Message>, )

pub fn draw_marker_boxes( &self, waves: &WaveData, ctx: &mut DrawingContext<'_>, view_width: f32, gap: f32, viewport: &Viewport, y_zero: f32, )

impl SystemState

pub fn add_menu_panel(&self, ctx: &Context, msgs: &mut Vec<Message>)

pub fn menu_contents(&self, ui: &mut Ui, msgs: &mut Vec<Message>)

pub fn item_context_menu( &self, path: Option<&FieldRef>, msgs: &mut Vec<Message>, ui: &mut Ui, vidx: VisibleItemIndex, )

fn add_format_menu( &self, displayed_field_ref: &DisplayedFieldRef, displayed_item: &DisplayedItem, path: &FieldRef, msgs: &mut Vec<Message>, ui: &mut Ui, )

impl SystemState

pub fn draw_mouse_gesture_widget( &self, egui_ctx: &Context, waves: &WaveData, pointer_pos_canvas: Option<Pos2>, response: &Response, msgs: &mut Vec<Message>, ctx: &mut DrawingContext<'_>, viewport_idx: usize, )

Draw the mouse gesture widget, i.e., the line(s) and text showing which gesture is being drawn.

fn stop_dragging( &self, pointer_pos_canvas: Option<Pos2>, start_location: Pos2, msgs: &mut Vec<Message>, viewport_idx: usize, waves: &WaveData, frame_width: f32, )

fn start_dragging( &self, pointer_pos_canvas: Option<Pos2>, start_location: Pos2, ctx: &mut DrawingContext<'_>, response: &Response, waves: &WaveData, viewport_idx: usize, )

fn draw_gesture_line( &self, start: Pos2, end: Pos2, text: &str, active: bool, ctx: &mut DrawingContext<'_>, )

Draw the line used by most mouse gestures.

fn draw_zoom_in_gesture( &self, start_location: Pos2, current_location: Pos2, response: &Response, ctx: &mut DrawingContext<'_>, waves: &WaveData, viewport_idx: usize, measure: bool, )

Draw the lines used for the zoom-in gesture.

pub fn mouse_gesture_help(&self, ctx: &Context, msgs: &mut Vec<Message>)

Draw the mouse gesture help window.

pub fn draw_measure_widget( &self, egui_ctx: &Context, waves: &WaveData, pointer_pos_canvas: Option<Pos2>, response: &Response, msgs: &mut Vec<Message>, ctx: &mut DrawingContext<'_>, viewport_idx: usize, )

impl SystemState

pub fn add_overview_panel( &self, ctx: &Context, waves: &WaveData, msgs: &mut Vec<Message>, )

fn draw_overview(&self, ui: &mut Ui, waves: &WaveData, msgs: &mut Vec<Message>)

impl SystemState

pub fn with_params(self, args: StartupParams) -> Self

pub fn wcp(&mut self)

pub(crate) fn get_scope( &mut self, scope: ScopeRef, recursive: bool, ) -> Vec<VariableRef>

pub(crate) fn on_waves_loaded( &mut self, filename: WaveSource, format: WaveFormat, new_waves: Box<WaveContainer>, load_options: LoadOptions, )

pub(crate) fn on_transaction_streams_loaded( &mut self, filename: WaveSource, format: WaveFormat, new_ftr: TransactionContainer, _loaded_options: LoadOptions, )

pub(crate) fn handle_async_messages(&mut self)

pub fn get_visuals(&self) -> Visuals

pub(crate) fn load_state( &mut self, loaded_state: Box<UserState>, path: Option<PathBuf>, )

pub fn waves_fully_loaded(&self) -> bool

Returns true if the waveform and all requested signals have been loaded. Used for testing to make sure the GUI is at its final state before taking a snapshot.

pub(crate) fn current_canvas_state( waves: &WaveData, message: String, ) -> CanvasState

Returns the current canvas state

pub(crate) fn save_current_canvas(&mut self, message: String)

Push the current canvas state to the undo stack

pub(crate) fn start_wcp_server( &mut self, address: Option<String>, initiate: bool, )

pub(crate) fn stop_wcp_server(&mut self)

impl SystemState

pub fn load_state_file(&mut self, path: Option<PathBuf>)

pub fn save_state_file(&mut self, path: Option<PathBuf>)

fn encode_state(&self) -> Option<String>

impl SystemState

pub fn get_item_text_color(&self, item: &DisplayedItem) -> &Color32

pub fn show_statusbar(&self) -> bool

pub fn show_toolbar(&self) -> bool

pub fn show_overview(&self) -> bool

pub fn show_hierarchy(&self) -> bool

pub fn show_tooltip(&self) -> bool

pub fn show_scope_tooltip(&self) -> bool

pub fn show_ticks(&self) -> bool

pub fn show_menu(&self) -> bool

pub fn show_variable_indices(&self) -> bool

pub fn show_variable_direction(&self) -> bool

pub fn ui_zoom_factor(&self) -> f32

pub fn show_empty_scopes(&self) -> bool

pub fn show_parameters_in_scopes(&self) -> bool

pub fn show_default_timeline(&self) -> bool

pub fn highlight_focused(&self) -> bool

pub fn fill_high_values(&self) -> bool

impl SystemState

pub fn add_statusbar_panel( &self, ctx: &Context, waves: &Option<WaveData>, msgs: &mut Vec<Message>, )

fn draw_statusbar( &self, ui: &mut Ui, waves: &Option<WaveData>, msgs: &mut Vec<Message>, )

impl SystemState

pub fn new() -> Result<SystemState>

fn new_inner(force_default_config: bool) -> Result<SystemState>

impl SystemState

pub fn get_time_format(&self) -> TimeFormat

impl SystemState

pub fn add_toolbar_panel(&self, ctx: &Context, msgs: &mut Vec<Message>)

Add panel and draw toolbar.

fn simulation_status_toolbar(&self, ui: &mut Ui, msgs: &mut Vec<Message>)

fn draw_toolbar(&self, ui: &mut Ui, msgs: &mut Vec<Message>)

impl SystemState

pub fn draw_variable_filter_edit( &mut self, ui: &mut Ui, msgs: &mut Vec<Message>, )

pub fn variable_filter_type_menu(&self, ui: &mut Ui, msgs: &mut Vec<Message>)

pub fn variable_cmp( &self, a: &VariableRef, b: &VariableRef, wave_container: Option<&WaveContainer>, ) -> Ordering

pub fn filtered_variables( &self, variables: &[VariableRef], variable_filter: &VariableFilter, ) -> Vec<VariableRef>

impl SystemState

pub(crate) fn draw( &mut self, ctx: &Context, window_size: Option<Vec2>, ) -> Vec<Message>

fn draw_load_url(&self, ctx: &Context, msgs: &mut Vec<Message>)

fn handle_pointer_in_ui(&self, ui: &mut Ui, msgs: &mut Vec<Message>)

pub fn draw_all_scopes( &self, msgs: &mut Vec<Message>, wave: &WaveData, draw_variables: bool, ui: &mut Ui, filter: &VariableFilter, )

fn add_scope_selectable_label( &self, msgs: &mut Vec<Message>, wave: &WaveData, scope: &ScopeRef, ui: &mut Ui, )

fn draw_selectable_child_or_orphan_scope( &self, msgs: &mut Vec<Message>, wave: &WaveData, scope: &ScopeRef, draw_variables: bool, ui: &mut Ui, filter: &VariableFilter, )

fn draw_root_scope_view( &self, msgs: &mut Vec<Message>, wave: &WaveData, root_scope: &ScopeRef, draw_variables: bool, ui: &mut Ui, filter: &VariableFilter, )

pub fn draw_variable_list( &self, msgs: &mut Vec<Message>, wave_container: &WaveContainer, ui: &mut Ui, all_variables: &[VariableRef], row_range: Option<Range<usize>>, filter: &VariableFilter, )

pub fn draw_filtered_variable_list( &self, msgs: &mut Vec<Message>, wave_container: &WaveContainer, ui: &mut Ui, all_variables: &[VariableRef], row_range: Option<Range<usize>>, )

fn draw_item_focus_list(&self, ui: &mut Ui)

fn hierarchy_icon( &self, ui: &mut Ui, has_children: bool, unfolded: bool, alignment: Align, ) -> Response

fn draw_item_list( &mut self, msgs: &mut Vec<Message>, ui: &mut Ui, ctx: &Context, )

fn draw_transaction_root( &self, msgs: &mut Vec<Message>, streams: &WaveData, ui: &mut Ui, )

pub fn draw_transaction_variable_list( &self, msgs: &mut Vec<Message>, streams: &WaveData, ui: &mut Ui, active_stream: &StreamScopeRef, )

fn draw_focused_transaction_details(&self, ui: &mut Ui)

fn get_name_alignment(&self) -> Align

fn draw_drag_source( &self, msgs: &mut Vec<Message>, vidx: VisibleItemIndex, item_response: &Response, )

fn draw_variable_label( &self, vidx: VisibleItemIndex, displayed_item: &DisplayedItem, displayed_id: DisplayedItemRef, field: FieldRef, msgs: &mut Vec<Message>, ui: &mut Ui, ctx: &Context, ) -> Response

fn draw_variable( &self, msgs: &mut Vec<Message>, vidx: VisibleItemIndex, displayed_item: &DisplayedItem, displayed_id: DisplayedItemRef, field: FieldRef, drawing_infos: &mut Vec<ItemDrawingInfo>, info: &VariableInfo, ui: &mut Ui, ctx: &Context, levels_to_force_expand: Option<usize>, alignment: Align, ) -> Rect

fn draw_drag_target( &self, msgs: &mut Vec<Message>, vidx: VisibleItemIndex, expanded_rect: Rect, available_rect: Rect, ui: &mut Ui, last: bool, )

fn draw_plain_item( &self, msgs: &mut Vec<Message>, vidx: VisibleItemIndex, displayed_id: DisplayedItemRef, displayed_item: &DisplayedItem, drawing_infos: &mut Vec<ItemDrawingInfo>, ui: &mut Ui, ) -> Rect

fn get_alpha_focus_id(&self, vidx: VisibleItemIndex) -> RichText

fn item_is_focused(&self, vidx: VisibleItemIndex) -> bool

fn item_is_selected(&self, id: DisplayedItemRef) -> bool

fn draw_var_values(&self, ui: &mut Ui, msgs: &mut Vec<Message>)

pub fn get_variable_value( &self, waves: &WaveData, displayed_field_ref: &DisplayedFieldRef, ucursor: &Option<BigUint>, ) -> Option<String>

pub fn get_variable_name_info( &self, wave_container: &WaveContainer, var: &VariableRef, ) -> Option<VariableNameInfo>

pub fn draw_background( &self, drawing_info: &ItemDrawingInfo, y_zero: f32, ctx: &DrawingContext<'_>, gap: f32, frame_width: f32, background_color: &Color32, )

pub fn get_background_color( &self, waves: &WaveData, drawing_info: &ItemDrawingInfo, vidx: VisibleItemIndex, ) -> Color32

fn get_default_alternating_background_color( &self, vidx: VisibleItemIndex, ) -> &Color32

pub fn draw_default_timeline( &self, waves: &WaveData, ctx: &DrawingContext<'_>, viewport_idx: usize, frame_width: f32, cfg: &DrawConfig, )

Draw the default timeline at the top of the canvas

impl SystemState

pub fn load_from_file( &mut self, filename: Utf8PathBuf, load_options: LoadOptions, ) -> Result<()>

pub fn load_from_bytes( &mut self, source: WaveSource, bytes: Vec<u8>, load_options: LoadOptions, )

pub fn load_wave_from_file( &mut self, filename: Utf8PathBuf, load_options: LoadOptions, ) -> Result<()>

pub fn load_from_data( &mut self, data: Vec<u8>, load_options: LoadOptions, ) -> Result<()>

pub fn load_from_dropped(&mut self, file: DroppedFile) -> Result<()>

pub fn load_wave_from_url(&mut self, url: String, load_options: LoadOptions)

pub fn load_transactions_from_file( &mut self, filename: Utf8PathBuf, load_options: LoadOptions, ) -> Result<()>

pub fn load_transactions_from_bytes( &mut self, source: WaveSource, bytes: Vec<u8>, load_options: LoadOptions, )

fn get_hierarchy_from_server( sender: Sender<Message>, server: String, load_options: LoadOptions, )

pub fn get_time_table_from_server(sender: Sender<Message>, server: String)

fn get_server_status(sender: Sender<Message>, server: String, delay_ms: u64)

pub fn server_status_to_progress(&mut self, server: String, status: Status)

uses the server status in order to display a loading bar

pub fn connect_to_cxxrtl(&mut self, kind: CxxrtlKind, keep_variables: bool)

pub fn load_wave_from_bytes( &mut self, source: WaveSource, bytes: Vec<u8>, load_options: LoadOptions, )

fn get_thread_pool() -> Option<ThreadPool>

pub fn load_wave_body<R: BufRead + Seek + Sync + Send + 'static>( &mut self, source: WaveSource, cont: ReadBodyContinuation<R>, body_len: u64, hierarchy: Arc<Hierarchy>, )

pub fn load_variables(&mut self, cmd: LoadSignalsCmd)

impl SystemState

pub fn handle_wcp_commands(&mut self)

fn handle_wcp_cs_message(&mut self, message: &WcpCSMessage)

fn send_greeting(&self)

fn send_response(&self, result: WcpResponse)

fn send_error(&self, error: &str, arguments: Vec<String>, message: &str)

fn get_displayed_items(&self, waves: &WaveData) -> Vec<DisplayedItemRef>

impl SystemState

pub fn update(&mut self, message: Message) -> Option<()>

pub fn add_scope_as_group( &mut self, scope: ScopeRef, pos: TargetPosition, recursive: bool, )

pub(crate) fn handle_variable_clipboard_operation<F>( &self, vidx: MessageTarget<VisibleItemIndex>, get_text: F, )

where F: FnOnce(&WaveData, DisplayedItemRef) -> Option<String>,

Trait Implementations

impl App for SystemState

fn update(&mut self, ctx: &Context, frame: &mut Frame)

Called each time the UI needs repainting, which may be many times per second.

fn save(&mut self, _storage: &mut dyn Storage)

Called on shutdown, and perhaps at regular intervals. Allows you to save state.

fn on_exit(&mut self, _gl: Option<&Context>)

Called once on shutdown, after Self::save.

fn auto_save_interval(&self) -> Duration

Time between automatic calls to Self::save

fn clear_color(&self, _visuals: &Visuals) -> [f32; 4]

Background color values for the app, e.g. what is sent to gl.clearColor.

fn persist_egui_memory(&self) -> bool

Controls whether or not the egui memory (window positions etc) will be persisted (only if the “persistence” feature is enabled).

fn raw_input_hook(&mut self, _ctx: &Context, _raw_input: &mut RawInput)

A hook for manipulating or filtering raw input before it is processed by Self::update.

impl From<UserState> for SystemState

fn from(serializable_state: UserState) -> SystemState

Converts to this type from the input type.