Enum UIMessageCode 

#[repr(i32)]
pub enum UIMessageCode {
    BreakOnUserRequest = 1,
    BreakOnBreakpoint = 2,
    BreakOnRunTimeError = 3,
    Trace = 4,
    TerminatingExecution = 5,
    AbortingExecution = 6,
    KillingExecutionThreads = 7,
    EndExecution = 8,
    ShutDownComplete = 9,
    StartExecution = 10,
    ProgressPercent = 11,
    ProgressText = 12,
    StartInteractiveExecution = 13,
    EndInteractiveExecution = 14,
    TerminatingInteractiveExecution = 15,
    TerminationCanceled = 16,
    ResumeFromBreak = 17,
    StartFileExecution = 18,
    EndFileExecution = 19,
    ShutDownCanceled = 20,
    LocalizationSettingChanged = 21,
    OpenWindows = 22,
    TileWindows = 23,
    CascadeWindows = 24,
    ReportChanged = 25,
    CloseWindows = 26,
    RefreshWindows = 27,
    ClientFileChanged = 28,
    DisplayReport = 29,
    ModelStateInitializing = 30,
    ModelStateWaiting = 31,
    ModelStateIdentified = 32,
    ModelStateBeginTesting = 33,
    ModelStateTestingComplete = 34,
    ModelStatePostProcessingComplete = 35,
    ModelStateEnabledStateSet = 36,
    ReportLocationChanged = 37,
    GotoLocation = 38,
    PushUndoItem = 39,
    OutputMessages = 40,
    TypePaletteFileListChanged = 41,
    NonTerminatableThreadsArePreventingTermination = 42,
    ModelStatePostProcessing = 43,
    ReportCollectionChanged = 44,
    RuntimeError = 45,
}

A user-interface message code (UIMsg_*).

The engine posts these to tell a host what an execution is doing. A sequence can also post its own, numbered from USER_MESSAGE_BASE upward, which is how a test reports progress to whatever is driving it.

Variants

BreakOnUserRequest = 1

UIMsg_BreakOnUserRequest.

BreakOnBreakpoint = 2

UIMsg_BreakOnBreakpoint.

BreakOnRunTimeError = 3

UIMsg_BreakOnRunTimeError.

Trace = 4

UIMsg_Trace.

TerminatingExecution = 5

UIMsg_TerminatingExecution.

AbortingExecution = 6

UIMsg_AbortingExecution.

KillingExecutionThreads = 7

UIMsg_KillingExecutionThreads.

EndExecution = 8

UIMsg_EndExecution.

ShutDownComplete = 9

UIMsg_ShutDownComplete.

StartExecution = 10

UIMsg_StartExecution.

ProgressPercent = 11

UIMsg_ProgressPercent.

ProgressText = 12

UIMsg_ProgressText.

StartInteractiveExecution = 13

UIMsg_StartInteractiveExecution.

EndInteractiveExecution = 14

UIMsg_EndInteractiveExecution.

TerminatingInteractiveExecution = 15

UIMsg_TerminatingInteractiveExecution.

TerminationCanceled = 16

UIMsg_TerminationCanceled.

ResumeFromBreak = 17

UIMsg_ResumeFromBreak.

StartFileExecution = 18

UIMsg_StartFileExecution.

EndFileExecution = 19

UIMsg_EndFileExecution.

ShutDownCanceled = 20

UIMsg_ShutDownCanceled.

LocalizationSettingChanged = 21

UIMsg_LocalizationSettingChanged.

OpenWindows = 22

UIMsg_OpenWindows.

TileWindows = 23

UIMsg_TileWindows.

CascadeWindows = 24

UIMsg_CascadeWindows.

ReportChanged = 25

UIMsg_ReportChanged.

CloseWindows = 26

UIMsg_CloseWindows.

RefreshWindows = 27

UIMsg_RefreshWindows.

ClientFileChanged = 28

UIMsg_ClientFileChanged.

DisplayReport = 29

UIMsg_DisplayReport.

ModelStateInitializing = 30

UIMsg_ModelStateInitializing.

ModelStateWaiting = 31

UIMsg_ModelStateWaiting.

ModelStateIdentified = 32

UIMsg_ModelStateIdentified.

ModelStateBeginTesting = 33

UIMsg_ModelStateBeginTesting.

ModelStateTestingComplete = 34

UIMsg_ModelStateTestingComplete.

ModelStatePostProcessingComplete = 35

UIMsg_ModelStatePostProcessingComplete.

ModelStateEnabledStateSet = 36

UIMsg_ModelStateEnabledStateSet.

ReportLocationChanged = 37

UIMsg_ReportLocationChanged.

GotoLocation = 38

UIMsg_GotoLocation.

PushUndoItem = 39

UIMsg_PushUndoItem.

OutputMessages = 40

UIMsg_OutputMessages.

TypePaletteFileListChanged = 41

UIMsg_TypePaletteFileListChanged.

NonTerminatableThreadsArePreventingTermination = 42

UIMsg_NonTerminatableThreadsArePreventingTermination.

ModelStatePostProcessing = 43

UIMsg_ModelStatePostProcessing.

ReportCollectionChanged = 44

UIMsg_ReportCollectionChanged.

RuntimeError = 45

UIMsg_RuntimeError.

Implementations

impl UIMessageCode

pub const ALL: [Self; 45]

Every code the engine defines.

pub const USER_MESSAGE_BASE: i32 = 10000

The first code available to a sequence (UIMsg_UserMessageBase).

Engine codes sit below this; anything at or above it was posted by a sequence, so a host can tell the two apart without a lookup.

pub const fn bits(self) -> i32

The value the COM boundary expects.

pub const fn is_user_message(raw: i32) -> bool

Whether a raw code was posted by a sequence rather than the engine.

Examples found in repository

examples/ui_messages_handle.rs (line 92)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let engine = Engine::new()?;

    // Nothing reaches the queue until polling is switched on.
    engine.set_ui_message_polling_enabled(true)?;

    let sequence_file = engine.new_sequence_file()?;
    let main_sequence = sequence_file.get_sequence_by_name("MainSequence")?;

    // Posted through the engine and tagged with the execution. Synchronous, so
    // the sequence waits until the host acknowledges it.
    add_statement(
        &engine,
        &main_sequence,
        "Report Stage",
        &format!(
            "RunState.Engine.PostUIMessage(RunState.Execution, RunState.Thread, {STAGE_MESSAGE}, \
             1, \"stage: configuring instruments\", Nothing, True)"
        ),
    )?;
    // Posted through the thread. Asynchronous, so the sequence carries on.
    add_statement(
        &engine,
        &main_sequence,
        "Report Progress",
        &format!(
            "RunState.Thread.PostUIMessageEx({PROGRESS_MESSAGE}, 50, \"progress: halfway\", \
             Nothing, False)"
        ),
    )?;

    let execution = engine.new_execution(&sequence_file, "MainSequence", None, false, 0)?;
    println!(
        "Execution {} started; polling for messages...",
        execution.id()?
    );

    // The end is detected from the message stream, not by waiting on the
    // execution: a wait call does not pump the queue, so a synchronous message
    // would sit unacknowledged and both sides would stop.
    let started = Instant::now();
    let mut ended = false;
    while started.elapsed() < Duration::from_secs(60) && !ended {
        while !engine.is_ui_message_queue_empty()? {
            let message = engine.get_ui_message()?;
            let code = message.event()?;
            if matches!(
                UIMessageCode::from_bits(code),
                Ok(UIMessageCode::EndExecution)
            ) {
                ended = true;
            }
            let origin = if UIMessageCode::is_user_message(code) {
                "sequence".to_owned()
            } else {
                format!("engine {:?}", UIMessageCode::from_bits(code))
            };
            println!(
                "  [{origin}] code={code} numeric={} string={:?} synchronous={}",
                message.numeric_data()?,
                message.string_data()?,
                message.is_synchronous()?
            );
            // Required: releases a synchronous poster and asks for the next.
            message.acknowledge()?;
        }
    }

    println!("\nExecution ended: {ended}");
    engine.release_sequence_file_ex(sequence_file, NO_OPTIONS)?;
    Ok(())
}

pub const fn from_bits(raw: i32) -> Result<Self, i32>

Reads a raw code, returning it unchanged when it is not an engine one.

Errors

The raw value, for a user message or a code this build does not name.

Examples found in repository

examples/execution_run_subsequence.rs (line 95)

fn wait_for_end(engine: &Engine, deadline: Duration) -> Result<bool, Error> {
    let started = Instant::now();
    while started.elapsed() < deadline {
        if pump_thread_messages() {
            return Ok(false);
        }
        while !engine.is_ui_message_queue_empty()? {
            let message = engine.get_ui_message()?;
            let ended = matches!(
                UIMessageCode::from_bits(message.event()?),
                Ok(UIMessageCode::EndExecution)
            );
            message.acknowledge()?;
            if ended {
                return Ok(true);
            }
        }
    }
    Ok(false)
}

examples/result_list_parse.rs (line 97)

fn wait_for_end(engine: &Engine, deadline: Duration) -> Result<bool, Error> {
    let started = Instant::now();
    while started.elapsed() < deadline {
        if pump_thread_messages() {
            return Ok(false);
        }
        while !engine.is_ui_message_queue_empty()? {
            let message = engine.get_ui_message()?;
            let ended = matches!(
                UIMessageCode::from_bits(message.event()?),
                Ok(UIMessageCode::EndExecution)
            );
            message.acknowledge()?;
            if ended {
                return Ok(true);
            }
        }
    }
    Ok(false)
}

examples/execution_run_test_headless.rs (line 99)

fn wait_for_end(engine: &Engine, deadline: Duration) -> Result<bool, Error> {
    let started = Instant::now();
    while started.elapsed() < deadline {
        if pump_thread_messages() {
            return Ok(false);
        }
        while !engine.is_ui_message_queue_empty()? {
            let message = engine.get_ui_message()?;
            let ended = matches!(
                UIMessageCode::from_bits(message.event()?),
                Ok(UIMessageCode::EndExecution)
            );
            // Acknowledging is what releases a synchronous poster; skipping it
            // stalls the sequence rather than merely losing a notification.
            message.acknowledge()?;
            if ended {
                return Ok(true);
            }
        }
    }
    Ok(false)
}

examples/ui_messages_handle.rs (line 87)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let engine = Engine::new()?;

    // Nothing reaches the queue until polling is switched on.
    engine.set_ui_message_polling_enabled(true)?;

    let sequence_file = engine.new_sequence_file()?;
    let main_sequence = sequence_file.get_sequence_by_name("MainSequence")?;

    // Posted through the engine and tagged with the execution. Synchronous, so
    // the sequence waits until the host acknowledges it.
    add_statement(
        &engine,
        &main_sequence,
        "Report Stage",
        &format!(
            "RunState.Engine.PostUIMessage(RunState.Execution, RunState.Thread, {STAGE_MESSAGE}, \
             1, \"stage: configuring instruments\", Nothing, True)"
        ),
    )?;
    // Posted through the thread. Asynchronous, so the sequence carries on.
    add_statement(
        &engine,
        &main_sequence,
        "Report Progress",
        &format!(
            "RunState.Thread.PostUIMessageEx({PROGRESS_MESSAGE}, 50, \"progress: halfway\", \
             Nothing, False)"
        ),
    )?;

    let execution = engine.new_execution(&sequence_file, "MainSequence", None, false, 0)?;
    println!(
        "Execution {} started; polling for messages...",
        execution.id()?
    );

    // The end is detected from the message stream, not by waiting on the
    // execution: a wait call does not pump the queue, so a synchronous message
    // would sit unacknowledged and both sides would stop.
    let started = Instant::now();
    let mut ended = false;
    while started.elapsed() < Duration::from_secs(60) && !ended {
        while !engine.is_ui_message_queue_empty()? {
            let message = engine.get_ui_message()?;
            let code = message.event()?;
            if matches!(
                UIMessageCode::from_bits(code),
                Ok(UIMessageCode::EndExecution)
            ) {
                ended = true;
            }
            let origin = if UIMessageCode::is_user_message(code) {
                "sequence".to_owned()
            } else {
                format!("engine {:?}", UIMessageCode::from_bits(code))
            };
            println!(
                "  [{origin}] code={code} numeric={} string={:?} synchronous={}",
                message.numeric_data()?,
                message.string_data()?,
                message.is_synchronous()?
            );
            // Required: releases a synchronous poster and asks for the next.
            message.acknowledge()?;
        }
    }

    println!("\nExecution ended: {ended}");
    engine.release_sequence_file_ex(sequence_file, NO_OPTIONS)?;
    Ok(())
}

Trait Implementations

impl Clone for UIMessageCode

fn clone(&self) -> UIMessageCode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for UIMessageCode

impl Debug for UIMessageCode

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

Formats the value using the given formatter.

impl Eq for UIMessageCode

impl Hash for UIMessageCode

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 UIMessageCode

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for UIMessageCode