Events

Registering event handlers

RepetierSharp provides a lot of different event handlers to get notified about changes on the server. The following section shows how to register event handlers for the different events.

The division in different types of events is a RepetierSharp specific choice and mainly to group similar events.

Registering event handlers for client events

/// <summary>
///     Fired when the connection with the server is established successfully for the first time. <br></br>
///     At this point, the sessionId should already be assigned to this RepetierConnection.
/// </summary>
public event Func<RepetierConnectedEventArgs, Task> ConnectedAsync { ... }

/// <summary>
///     Fired when the connection with the server was closed. Either willingly or by other means. <br></br>
///     In case the disconnected client had the last connection open for this particular session, the session may be discarded by the server.
/// </summary>
public event Func<RepetierDisconnectedEventArgs, Task> DisconnectedAsync { ... }

/// <summary>
///     Fired after establishment of the connection to the server if the server requires a login. <br></br>
///     This might be the case if no API-Key is supplied in the URI and the server has at least one user account.
/// </summary>
public event Func<LoginRequiredEventArgs, Task> LoginRequiredAsync { ... }

/// <summary>
///     Fired when the login result response is received from the server after sending the login request.
/// </summary>
public event Func<LoginResultEventArgs, Task> LoginResultAsync { ... }

/// <summary>
///     Event which is fired when a command is not permitted for the current sessionId.
/// </summary>
public event Func<PermissionDeniedEventArgs, Task> PermissionDeniedAsync { ... }

/// <summary>
///     Event which is fired when a command is not permitted for the current sessionId.
/// </summary>
public event Func<SessionIdReceivedEventArgs, Task> SessionEstablishedAsync { ... }

/// <summary>
///     Fired when reconnecting to a still existing session. There is no login is required with an existing session.
///     <br></br>
///     This is the first event you will receive. It contains the permission flags, login name of the user and user only
///     settings.
/// </summary>
public event Func<UserCredentialsReceivedEventArgs, Task> SessionReconnectedAsync { ... }

/// <summary>
///     Fired for received events from the repetier server. Note that temp, move and log events are not included here.
///     <br></br>
///     They can be enabled by setting the appropriate properties.
/// </summary>
public event Func<RepetierEventReceivedEventArgs, Task> EventReceivedAsync { ... }

/// <summary>
///     Fired whenever an event from the repetier server is received. Unlike the RepetierEventReceivedAsync event,
///     <br></br>
///     this event includes the raw event itself (content of the data field).  <br></br>
///     This is mainly a fallback event for backwards compatibility and support events in newer repetier versions,
///     <br></br>
///     which are not yet implemented by RepetierSharp.
/// </summary>
public event Func<RawRepetierEventReceivedEventArgs, Task> RawRepetierEventReceivedAsync { ... }

/// <summary>
///     Fired when a response from the server is received. This does not include the ping response.
/// </summary>
public event Func<RepetierResponseReceivedEventArgs, Task> RepetierResponseReceivedAsync { ... }

/// <summary>
///     Fired when a raw response from the server is received. Unlike the RepetierResponseReceivedAsync event, <br></br>
///     this event includes the raw response itself (content of the data field). <br></br>
///     This is mainly a fallback event for backwards compatibility and support events in newer repetier versions,
///     <br></br>
///     which are not yet implemented by RepetierSharp.
/// </summary>
public event Func<RawRepetierResponseReceivedEventArgs, Task> RawRepetierResponseReceivedAsync { ... }

Event handlers for print job events

/// <summary>
///     Fired after a print job has been started.
/// </summary>
public event Func<PrintJobStartedEventArgs, Task> PrintStartedAsync { ... }

/// <summary>
///     Fired after a print job has been finished.
/// </summary>
public event Func<PrintJobFinishedEventArgs, Task> PrintFinishedAsync { ... }

/// <summary>
///     Fired after a normal job has been finished or killed. Shortcut if you do not care why a job is not active anymore.
/// </summary>
public event Func<PrintJobDeactivatedEventArgs, Task> PrintDeactivatedAsync { ... }

/// <summary>
///     Triggered after a print job has been killed.
/// </summary>
public event Func<PrintJobKilledEventArgs, Task> PrintKilledAsync { ... }

/// <summary>
///     Triggered when a failure upon starting a print job was detected. This usually happens when the printer is not ready
///     or on connection issues.
/// </summary>
public event Func<PrintJobStartFailedEventArgs, Task> PrintStartFailedAsync { ... }

/// <summary>
///     Fired after a job got added. It might already be started for printing and info might be in state of evaluation at
///     that point.
/// </summary>
public event Func<PrintJobAddedEventArgs, Task> PrintJobChangedAsync { ... }

Event handlers for printer events

/// <summary>
///     Fired when the state of a printer changes.
/// </summary>
public event Func<StateChangedEventArgs, Task> PrinterStateReceivedAsync { ... }

/// <summary>
///     Fired when the condition of a printer changes
/// </summary>
public event Func<ConditionChangedEventArgs, Task> PrinterConditionChangedAsync { ... }

/// <summary>
///     Fired everytime settings of a printer change
/// </summary>
public event Func<SettingChangedEventArgs, Task> PrinterSettingChangedAsync { ... }

/// <summary>
///     Fired when a printer has a change in it's stored g-file list.
/// </summary>
public event Func<JobsChangedEventArgs, Task> PrinterJobsChangedAsync { ... }

/// <summary>
///     Fired after the response for the printer activation request from was received.
/// </summary>
public event Func<ActivatedEventArgs, Task> PrinterActivatedAsync { ... }

/// <summary>
///     Fired after the response for the printer deactivation request from was received.
/// </summary>
public event Func<DeactivatedEventArgs, Task> PrinterDeactivatedAsync { ... }

/// <summary>
///     Fired after the response for the emergency stop request from the printer was received.
/// </summary>
public event Func<EmergencyStopTriggeredEventArgs, Task> PrinterEmergencyStopTriggeredAsync { ... }

/// <summary>
///     Fired after a new temperature entry for the printer is available. Depending on the printer configuration this can
///     be a very frequently occurring event.
/// </summary>
public event Func<TemperatureChangedEventArgs, Task> PrinterTempChangedAsync { ... }

/// <summary>
///     Fired for every move the printer does. This can be used to provide a live preview of what the printer does.
///     This is only fired when moves are enabled (sendMoves action).
/// </summary>
public event Func<MovedEventArgs, Task> PrinterMovedAsync { ... }

public event Func<LayerChangedEventArgs, Task> LayerChangedAsync { ... }

Event handlers for server events

/// <summary>
///     Fired for each new log line. You received logs depends on the log level set at the server.
/// </summary>
public event Func<LogEntryEventArgs, Task> LogEntryAsync { ... }

/// <summary>
///     Fired whenever a printer was added, deleted or modified.
/// </summary>
public event Func<PrinterListChangedEventArgs, Task> PrinterListChangedAsync { ... }

/// <summary>
///     Fired when a new message gets available. <br></br>
///     Contains the new added message as payload or null when a message got removed.
/// </summary>
public event Func<MessagesChangedEventArgs, Task> MessagesChangedAsync { ... }

/// <summary>
///     Fired for every command/request send to the repetier server. <br></br>
///     This is mainly useful for debugging purposes.
/// </summary>
public event Func<RepetierRequestEventArgs, Task> RepetierRequestSendAsync { ... }

/// <summary>
///     Fired when a request to the repetier server failed. <br></br>
///     This happens when the websocket client is unable to queue the request internally. <br></br>
///     To check if the server received the response either listen for the corresponding response.
/// </summary>
public event Func<RepetierRequestEventArgs, Task> RepetierRequestFailedAsync { ... }

/// <summary>
///    Fired when a request to the repetier server failed. <br></br>
/// </summary>
public event Func<HttpContextEventArgs, Task> HttpRequestFailedAsync { ... }