/// <summary> /// Handles app event sent from Razer SDK. /// </summary> /// <param name="type">App event type.</param> /// <param name="firstParam">The first DWORD parameter.</param> /// <param name="secondParam">The second DWORD parameter.</param> /// <returns><see cref="HRESULT" /> object indicating success or failure.</returns> private HRESULT HandleAppEvent(AppEventType type, uint firstParam, uint secondParam) { const int Result = HRESULT.RZSB_OK; if (type == AppEventType.Invalid || type == AppEventType.None) { _log.DebugFormat("Unsupported AppEventType: {0}", type); return(Result); } OnAppEvent(type, firstParam, secondParam); switch (type) { case AppEventType.Activated: OnActivated(firstParam, secondParam); break; case AppEventType.Close: OnClose(firstParam, secondParam); break; case AppEventType.Deactivated: OnDeactivated(firstParam, secondParam); break; case AppEventType.Exit: OnExit(firstParam, secondParam); break; } return(Result); }
public static void Dispatch(AppEventType type, params object[] data) { if (Events.ContainsKey(type)) { Events[type].Dispatch(new AppEvent(type, data)); } }
public static void ExecuteHandler(AppEventType eventType) { foreach (var handler in GetHandler(eventType)) { handler.Execute_AppHandler(); } }
/// <summary> /// Represents low-level networking call that can be used to transmit an event to the browser. /// </summary> /// <param name="client">The client to transmit the event to.</param> /// <param name="propertyName">The name of the event to transmit.</param> /// <param name="type">The type of the event to transmit.</param> /// <param name="eventValue">The value of the event to transmit.</param> internal static void SendEvent(ClientObject client, AppEventType type, BoxedValue target, string eventName, BoxedValue eventValue) { try { // Check if the target is an object and retrieve the id. var oid = 0; if (target.IsObject && target.Object is BaseObject) oid = ((BaseObject)target.Object).Oid; // Get the client var channel = client.Target; // Convert to a string var stringValue = TypeConverter.ToNullableString( Native.Serialize(client.Env, eventValue, true) ); // Dispatch the inform channel.TransmitEvent(type, oid, eventName, stringValue); } catch (Exception ex) { // Log the exception Service.Logger.Log(ex); } }
public void Subscribe(AppEventType type, Listener listener) { if (!listenersMap.ContainsKey(type)) listenersMap.Add(type, new Listener(listener)); else listenersMap[type] += listener; }
/// <summary> /// 获取指定事件按照 ID 和优先级排序后的结果 /// </summary> /// <param name="events">要获取的事件源的应用</param> /// <param name="type">事件类型</param> /// <returns>事件列表</returns> private static IEnumerable <AppEvent> GetEvents(CQPSimulatorApp app, AppEventType type) { return(from temp in app.Library.AppInfo.Events where temp.Type == type orderby temp.Id orderby temp.Priority select temp); }
public static void On(AppEventType type, ExEventDelegate <AppEvent> d) { if (!Events.ContainsKey(type)) { Events.Add(type, new ExEvent <AppEvent>()); } Events[type] += d; }
/// <summary> /// Raises app event to subscribers. /// </summary> /// <param name="type">App event type.</param> /// <param name="firstParam">The first DWORD parameter.</param> /// <param name="secondParam">The second DWORD parameter.</param> private void OnAppEvent(AppEventType type, uint firstParam, uint secondParam) { var func = AppEvent; if (func != null) { func(this, new AppEventEventArgs(type, firstParam, secondParam)); } }
public AppEventArgs(Guid id, DateTime event_ts, AppEventType appEventType, T beforeChange, T afterChange) { this.id = id; this.event_ts = event_ts; this.appEventType = appEventType; this.beforeChange = beforeChange; this.afterChange = afterChange; }
public void Unsubscribe(AppEventType type, Listener listener) { if(!listenersMap.ContainsKey(type)) { Debug.LogError(type.ToString() + " doesn't exist"); return; } listenersMap[type] -= listener; }
// This function is used to subscribe to an event using an asynchrnous handler public virtual Guid Subscribe(AppEventType appEventType, Func <AppEventArgs <T>, Task> handler) { var newhandler = new EventHandlerEntry <T>(); newhandler.EventHandlerID = Guid.NewGuid(); newhandler.AppEventType = appEventType; newhandler.EventHandler = handler; allEventHandlers.Add(newhandler); return(newhandler.EventHandlerID); }
public EventLogItem(DateTime timestamp, Exception ex, string description) { Timestamp = timestamp; EventType = AppEventType.Error; ObjectType = ex.Source; if (ex.Data.Contains("ObjectName")) { ObjectName = ex.Data["ObjectName"].ToString(); } Description = description + ", exception: " + ex.Message; ErrorCode = "0x" + Convert.ToString(ex.HResult, 16); StackTrace = ex.StackTrace; }
private static IEnumerable <IAppEvent> GetHandler(AppEventType eventType) { Type interfaceType = typeof(IAppEvent); List <IAppEvent> result = new List <IAppEvent>(); foreach (var item in Assembly.GetExecutingAssembly().GetTypes().Where(t => interfaceType.IsAssignableFrom(t) && !t.IsInterface)) { IAppEvent handler = (IAppEvent)Activator.CreateInstance(item); result.Add(handler); } return(result.Where(i => i.EvenType == eventType)); }
public EventLogItem(DateTime timestamp, string objectType, string objectName, string description, bool ConfigError = false) { Timestamp = timestamp; ObjectType = objectType; ObjectName = objectName; Description = description; if (ConfigError) { EventType = AppEventType.ConfigErr; } else { EventType = AppEventType.Debug; } }
public EmailEventArgs(Guid id, DateTime event_ts, AppEventType appEventType, string subject, string textMsg, string htmlMsg, List <string> notifyTo, List <string> notifyCC, List <string> notifyBCC ) { this.id = id; this.event_ts = event_ts; this.appEventType = appEventType; this.subject = subject; this.textMsg = textMsg; this.htmlMsg = htmlMsg; this.notifyTo = notifyTo; this.notifyCC = notifyCC; this.notifyBCC = notifyBCC; }
/// <summary> /// Represents low-level networking call that can be used to transmit an event to the browser. /// </summary> /// <param name="client">The client to transmit the event to.</param> /// <param name="propertyName">The name of the event to transmit.</param> /// <param name="type">The type of the event to transmit.</param> /// <param name="eventValue">The value of the event to transmit.</param> internal static void SendEvent(BoxedValue client, AppEventType type, BoxedValue target, string eventName, BoxedValue eventValue) { try { // Check if it's an object if (!client.IsObject) return; // Unbox & check if alive var unboxedClient = client.Object as ClientObject; if (unboxedClient == null && unboxedClient.IsAlive) return; // Unboxed call Native.SendEvent(unboxedClient, type, target, eventName, eventValue); } catch (Exception ex) { // Log the exception Service.Logger.Log(ex); } }
void handle_app_events(AppEventType event_type, params object[] param_array) { if (event_type == AppEventType.LOG) { Console.WriteLine(param_array[0]); } else { // A default handler that relies on the .ToString() Console.Write(event_type + ": "); if (param_array != null && param_array.Length > 0) { foreach (var obj in param_array) { Console.WriteLine(obj); } } else { Console.WriteLine(); } } }
public GameObjectEvent(AppEventType type, GameObject g) { Type = type; gameObject = g; }
/// <summary> /// Run app event /// </summary> /// <remarks>DEPRECATED METHOD, USE EVENT SPECIFIC METHOD INSTEAD</remarks> /// <param name="appEvent">The app event type</param> /// <param name="model">The service model</param> /// <param name="modelState">The model state</param> /// <returns>True if the event was handled</returns> public override async Task <bool> RunAppEvent(AppEventType appEvent, object model, ModelStateDictionary modelState = null) { _logger.LogInformation($"RunAppEvent {appEvent}"); return(await Task.FromResult(true)); }
internal static extern ErrorCode AddEventHandler(out IntPtr handle, AppEventType eventType, AppEventCallback callback, IntPtr data);
public SendNumberEvent(int value) { Type = AppEventType.SEND_NUMBER; number = value; }
public virtual void OnEvent(AppEventType appEventType, AppEventArgs <T> e) { this.__executeEventHandlers( this.allEventHandlers.Where(ed => ed.AppEventType == appEventType), e); }
/// <summary> /// Executes the event. /// </summary> /// <param name="eventActionType">Type of the event action.</param> /// <param name="type">The type.</param> /// <param name="state">The state.</param> /// <param name="eventItem">The event item.</param> protected void ExecuteEventImpl(Type eventActionType, AppEventType type, string state, object eventItem) { List<Delegate> delegateList; if (_events.TryGetValue(eventActionType, out delegateList)) { foreach (Delegate delgate in delegateList) { try { delgate.DynamicInvoke(eventItem, new AppEventArgs(type, state)); } catch (Exception ex) { if (ExceptionHandler != null) { ExceptionHandler(ex); } } } } }
/// <summary> /// Executes the event. /// </summary> /// <param name="appType">Type of the application.</param> /// <param name="state">The state.</param> /// <param name="eventItem">The event item.</param> public void ExecuteEvent(AppEventType appType, string state, object eventItem) { Type[] tArray = eventItem.GetType().FindInterfaces(Module.FilterTypeName, "*"); foreach(Type type in tArray) { ExecuteEventImpl(type, appType, state, eventItem); } ExecuteEventImpl(eventItem.GetType(), appType, state, eventItem); }
public AppEvent(AppEventType type, params object[] data) { this.EventType = type; this.Data = data; }
public SortNumberEvent(Controller controller) { Type = AppEventType.SORT_NUMBER; ctrl = controller; }
/// <inheritdoc /> public abstract Task <bool> RunAppEvent(AppEventType appEvent, object model, ModelStateDictionary modelState = null);
/// <summary> /// Event handler for events issued by the backup manager thread. /// This function runs on the backup manager thread, so it cannot /// access the GUI elements directly. /// </summary> void handle_event(AppEventType event_type, params object[] param_array) { if (event_type == AppEventType.LOG) { string text = (string)param_array[0]; add_line_of_text(text); } else if (event_type == AppEventType.ERROR) { app_mode = AppMode.ERROR; Output_tb.Dispatcher.BeginInvoke(new Func_Icon(change_notify_icon), error_icon); var error_message = (string)param_array[0]; Output_tb.Dispatcher.BeginInvoke( new Func_string(show_error_message_box), error_message); add_line_of_text(error_message); } else if (event_type == AppEventType.CHECK_BACKUPS_DONE) { // This is the backup manager thread, so better to not call: // backup_manager.start_live_backup(); // directly. Better call it via GUI thread, for consistency. Output_tb.Dispatcher.BeginInvoke(new Func_void(start_live_backup), null); add_line_of_text("All backups are up to date."); } else if (event_type == AppEventType.GET_RESTORE_INFO_DONE) { if (app_mode == AppMode.RESTORE_GET_INFO) { RestoreInfo info = (RestoreInfo)param_array[0]; RestoreInfo_text.Dispatcher.BeginInvoke( new Func_RestoreInfo(restore_window.get_restore_info_done), info); app_mode = AppMode.RESTORE_UNDER_WAY; restore_mode_files_processed = 0; } } else if (event_type == AppEventType.FILES_PROCESSED) { int files_processed = (int)param_array[0]; restore_mode_files_processed += files_processed; string progress = "Files processed: " + restore_mode_files_processed.ToString(); if (app_mode == AppMode.RESTORE_GET_INFO) { RestoreInfo_text.Dispatcher.BeginInvoke( new Func_TextBlock_string(set_text_block_text), RestoreInfo_text, progress); } else if (app_mode == AppMode.RESTORE_UNDER_WAY) { RestoreInfo_text.Dispatcher.BeginInvoke( new Func_TextBlock_string(set_text_block_text), RestoreStatus_text, progress); } } else if (event_type == AppEventType.RESTORE_DONE) { if (app_mode == AppMode.RESTORE_UNDER_WAY) { string message = "Files processed: " + restore_mode_files_processed.ToString() + "\nRestore completed."; RestoreInfo_text.Dispatcher.BeginInvoke( new Func_TextBlock_string(set_text_block_text), RestoreStatus_text, message); app_mode = AppMode.RESTORE_DONE; } } else if (event_type == AppEventType.BM_THREAD_IDLE) { if (app_mode != AppMode.ERROR) { Output_tb.Dispatcher.BeginInvoke( new Func_Icon(change_notify_icon), ready_icon); } } else if (event_type == AppEventType.BM_THREAD_RUNNING) { if (app_mode != AppMode.ERROR) { Output_tb.Dispatcher.BeginInvoke( new Func_Icon(change_notify_icon), busy_icon); } } }
public override Task <bool> RunAppEvent(AppEventType appEvent, object model, ModelStateDictionary modelState = null) { return(Task.FromResult(true)); }
/// <summary> /// Run app event /// </summary> /// <remarks>DEPRECATED METHOD, USE EVENT SPECIFIC METHOD INSTEAD</remarks> /// <param name="appEvent">The app event type</param> /// <param name="model">The service model</param> /// <param name="modelState">The model state</param> /// <returns></returns> public override async Task <bool> RunAppEvent(AppEventType appEvent, object model, ModelStateDictionary modelState) { _logger.LogInformation($"RunAppEvent {appEvent}"); return(true); }
public ModifyButtonEvent(AppEventType type) { Type = type; }
/// <summary> /// Initializes a new instance of the <see cref="AppEventEventArgs" /> class. /// </summary> /// <param name="eventType">App event type.</param> /// <param name="firstParam">App event mode associated with this event.</param> /// <param name="secondParam">Process ID associated with event.</param> internal AppEventEventArgs(AppEventType eventType, uint firstParam, uint secondParam) { _eventType = eventType; _firstParam = firstParam; _secondParam = secondParam; }