public void ReturnFalseIfStringDoesNotStartWithValue() { var e = new SystemEvent { Message = " Start of Message" }; var extendedProperties = new FakeExtendedProperties { { "property", "Message" }, { "value", "Start" } }; var filter = new StartsWithFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.False(Filter.Compile(filter).Invoke(e)); }
public void ReturnTrueIfStringContainsValue() { var e = new SystemEvent { Message = "Start Message End" }; var extendedProperties = new FakeExtendedProperties { { "property", "Message" }, { "value", "Message" } }; var filter = new ContainsFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.True(Filter.Compile(filter).Invoke(e)); }
public void CanHaveNullProperty() { var e = new SystemEvent { Message = null }; var extendedProperties = new FakeExtendedProperties { { "property", "Message" }, { "value", "Message" } }; var filter = new ContainsFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.False(Filter.Compile(filter).Invoke(e)); }
public void CanHaveNullValue() { var e = new SystemEvent { Message = "Start of Message" }; var extendedProperties = new FakeExtendedProperties { { "property", "Message" }, { "value", null } }; var filter = new StartsWithFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.True(Filter.Compile(filter).Invoke(e)); }
public void ValueCanBeString() { var e = new SystemEvent { Message = "My Message" }; var extendedProperties = new FakeExtendedProperties { { "property", "Message" }, { "value", "My Message" } }; var filter = new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.True(Filter.Compile(filter).Invoke(e)); }
public void ValueCanBeInt32() { var e = new SystemEvent { ProcessId = 123 }; var extendedProperties = new FakeExtendedProperties { { "property", "ProcessId" }, { "value", "123" } }; var filter = new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.True(Filter.Compile(filter).Invoke(e)); }
public void ReturnFalseIfNoChildFilters() { var e = new SystemEvent(); var extendedProperties = new FakeExtendedProperties { { "property", "Level" }, { "value", "Warning" } }; var filter = new NotFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.False(Filter.Compile(filter).Invoke(e)); }
public void ReturnTrueIfLessThanOrEqual() { var e = new SystemEvent { ProcessId = 50 }; var extendedProperties = new FakeExtendedProperties { { "property", "ProcessId" }, { "value", "50" } }; var filter = new LessThanOrEqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.True(Filter.Compile(filter).Invoke(e)); }
public void ValueCanBeUInt32() { var e = new SystemEvent(); var extendedProperties = new FakeExtendedProperties { { "property", "MessageId" }, { "value", e.MessageId.ToString(CultureInfo.InvariantCulture) } }; var filter = new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.True(Filter.Compile(filter).Invoke(e)); }
public void AlwaysCaseInsensitive() { var e = new SystemEvent { Message = "Start MESSAGE End" }; var extendedProperties = new FakeExtendedProperties { { "property", "Message" }, { "value", "Message" } }; var filter = new ContainsFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.True(Filter.Compile(filter).Invoke(e)); }
public void ReturnFalseIfSingleChildFilterFalse() { var e = new SystemEvent { Level = SystemEventLevel.Error }; var extendedProperties = new FakeExtendedProperties { { "property", "Level" }, { "value", "Warning" } }; var filter = new OrElseFilter(new FakeExtendedProperties(), new[] { new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()) }); Assert.False(Filter.Compile(filter).Invoke(e)); }
public void ReturnTrueIfEqual() { var e = new SystemEvent { Level = SystemEventLevel.Warning }; var extendedProperties = new FakeExtendedProperties { { "property", "Level" }, { "value", "Warning" } }; var filter = new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.True(Filter.Compile(filter).Invoke(e)); }
public void ReturnFalseIfNotGreaterThan() { var e = new SystemEvent { ProcessId = 50 }; var extendedProperties = new FakeExtendedProperties { { "property", "ProcessId" }, { "value", "50" } }; var filter = new GreaterThanFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.False(Filter.Compile(filter).Invoke(e)); }
public void ValueCanBeDateTime() { var now = DateTime.Now; var e = new SystemEvent { Timestamp = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second) }; var extendedProperties = new FakeExtendedProperties { { "property", "Timestamp" }, { "value", now.ToString("yyyy-MM-dd HH:mm:ss") } }; var filter = new EqualFilter(extendedProperties, Enumerable.Empty<ICreateFilterExpressions>()); Assert.True(Filter.Compile(filter).Invoke(e)); }
public void ReturnTrueIfAnyChildFilterTrue() { var e = new SystemEvent { Level = SystemEventLevel.Warning, ProcessId = 1234, Thread = "Main" }; var filter = new OrElseFilter( new FakeExtendedProperties(), new[] { new EqualFilter(new FakeExtendedProperties { { "property", "ProcessId" }, { "value", "1234" } }, Enumerable.Empty<ICreateFilterExpressions>()), new EqualFilter(new FakeExtendedProperties { { "property", "Thread" }, { "value", "Unknown" } }, Enumerable.Empty<ICreateFilterExpressions>()), new EqualFilter(new FakeExtendedProperties { { "property", "Level" }, { "value", "Error" } }, Enumerable.Empty<ICreateFilterExpressions>()) }); Assert.True(Filter.Compile(filter).Invoke(e)); }
private static Char GetLevel(SystemEvent e) { switch (e.Level) { case SystemEventLevel.Fatal: return('F'); case SystemEventLevel.Error: return('E'); case SystemEventLevel.Warning: return('W'); case SystemEventLevel.Information: return('I'); case SystemEventLevel.Debug: return('D'); default: return('T'); } }
public GammaService(SettingsService settingsService) { _settingsService = settingsService; // Register for all system events that may indicate that device context or gamma has changed from outside _eventRegistration = Disposable.Aggregate( PowerSettingNotification.TryRegister( PowerSettingNotification.ConsoleDisplayStateId, InvalidateGamma ) ?? Disposable.Null, PowerSettingNotification.TryRegister( PowerSettingNotification.PowerSavingStatusId, InvalidateGamma ) ?? Disposable.Null, PowerSettingNotification.TryRegister( PowerSettingNotification.SessionDisplayStatusId, InvalidateGamma ) ?? Disposable.Null, PowerSettingNotification.TryRegister( PowerSettingNotification.MonitorPowerOnId, InvalidateGamma ) ?? Disposable.Null, PowerSettingNotification.TryRegister( PowerSettingNotification.AwayModeId, InvalidateGamma ) ?? Disposable.Null, SystemEvent.Register( SystemEvent.DisplayChangedId, InvalidateDeviceContext ), SystemEvent.Register( SystemEvent.PaletteChangedId, InvalidateDeviceContext ), SystemEvent.Register( SystemEvent.SettingsChangedId, InvalidateDeviceContext ), SystemEvent.Register( SystemEvent.SystemColorsChangedId, InvalidateDeviceContext ) ); }
private ListViewItem CreateListViewItem(SystemEvent e) { return(new ListViewItem(new[] { e.MessageId.ToString(CultureInfo.InvariantCulture), e.Timestamp.ToString("HH:mm:ss,fff"), e.Level.ToString(), e.ProcessId.ToString(CultureInfo.InvariantCulture), e.ProcessName, e.Thread, e.Source, e.Username, e.Message }) { Tag = e, ForeColor = GetForegroundColor(e.Level), BackColor = GetBackgroundColor(e.Level) }); }
public void TestIfTimeBetweenOperationsIsBelowTimeout() { Rule.OperationName = null; Rule.StartOperationName = StartName; Rule.EndOperationName = EndName; var startOp = new SystemEvent(SystemEvent.OperationResult.Success); startOp.OperationName = StartName; var endOp = new SystemEvent(SystemEvent.OperationResult.Success); endOp.OperationName = EndName; Assert.IsFalse(Rule.AddAndCheckIfTriggered(startOp)); Thread.Sleep(6000); Assert.IsFalse(Rule.AddAndCheckIfTriggered(endOp)); Assert.IsFalse(Rule.AddAndCheckIfTriggered(startOp)); Thread.Sleep(4500); Assert.IsFalse(Rule.AddAndCheckIfTriggered(endOp)); }
public override bool AddAndCheckIfTriggered(SystemEvent opResult) { if (opResult.Result != SystemEvent.OperationResult.Failure) { return(false); } while (Failures.Any() && Failures.Peek() <= DateTime.UtcNow) { Failures.Dequeue(); } Failures.Enqueue(DateTime.UtcNow + KeepOperationInPileTime); if (Failures.Count >= MaxTimesFailureAllowed) { AlarmMessage = $"{MaxTimesFailureAllowed} failures occured within {KeepOperationInPileTime}."; Failures.Clear(); return(true); } return(false); }
/// <summary> /// Create the message queues and system event. /// </summary> public void InitQueueEndPoints() { //Create out reader and writer queues. Since this queue has a name it is accessible // by other programs. _writer = new MessageQueueWriter(QueueEndpointName, maxItems, maxMessageSize); if (_isReader) { _reader = new MessageQueueReader(QueueEndpointName, maxItems, maxMessageSize); //Create an unnamed event. This will be used to unblock the read thread //when the program is terminating. _readerWaitEvent = new SystemEvent(null, false, true); Thread readThread = new Thread(new ThreadStart(ReaderThread)); readThread.IsBackground = true; readThread.Start(); } }
/// <summary> /// Create the message queues and system event. /// </summary> public void InitQueueEndPoints() { //Create out reader and writer queues. Since this queue has a name it is accessible // by other programs. _writer = new MessageQueueWriter(QueueEndpointName, maxItems, maxMessageSize); if (_isReader) { _reader = new MessageQueueReader(QueueEndpointName, maxItems, maxMessageSize); //Create an unnamed event. This will be used to unblock the read thread //when the program is terminating. _readerWaitEvent = new SystemEvent(null, false, true); Thread readThread = new Thread(new ThreadStart(ReaderThread)); readThread.IsBackground = true; readThread.Start(); } }
public IHttpActionResult PostSystemEvent(SystemEvent systemEvent) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } using (SqlConnection con = new SqlConnection(conString.ConnectionString)) { using (SqlCommand cmd = new SqlCommand("AddSystemEvent", con)) { cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@Description", systemEvent.Description); con.Open(); cmd.ExecuteNonQuery(); } } return(CreatedAtRoute("DefaultApi", new { id = systemEvent.Id }, systemEvent)); }
public void Bind(SystemEvent e) { Verify.NotNull(e, "e"); // Message tab messageText.Text = e.Message; // Details tab messageId.Text = e.MessageId.ToString(CultureInfo.CurrentUICulture); level.Text = e.Level.ToString(); source.Text = e.Source; timestamp.Text = e.Timestamp.ToString("yyyy-MM-dd HH:mm:ss,fff"); process.Text = e.ProcessName + " (" + e.ProcessId + ")"; thread.Text = e.Thread; username.Text = e.Username; message.Text = e.Message; // Raw tab rawText.Text = e.RawMessage.Value; }
public string HandleEvent(SystemEvent e, int time, ref bool updateVisuals) { if (this.Disposed == true) { throw new ObjectDisposedException(this.GetType().Name); } _time = time; if ((_bindHandler != null) && (e.Type == SystemEventType.Key) && (e.Value2 == 1)) { string ret = _bindHandler.HandleEvent(e, ref updateVisuals); _bindHandler = null; return(ret); } if (e.Type == SystemEventType.Mouse) { _cursorX += e.Value; _cursorY += e.Value2; if (_cursorX < 0) { _cursorX = 0; } if (_cursorY < 0) { _cursorY = 0; } } if (this.Desktop != null) { this.Desktop.HandleEvent(e, ref updateVisuals); } return(string.Empty); }
public void LogSystemEvent(SystemEvent systemEvent) { using (var command = new NpgsqlCommand("log_system_event")) { Log.DebugFormat("Inserting system event {0} into databse...", systemEvent.Id); command.CommandType = System.Data.CommandType.StoredProcedure; AddCommonEventPropertyParametersToCommand(command, systemEvent); command.Parameters.Add(new NpgsqlParameter { NpgsqlDbType = NpgsqlDbType.Enum, Value = systemEvent.Command }); command.Parameters.Add(new NpgsqlParameter { NpgsqlDbType = NpgsqlDbType.Char, Value = ((object)systemEvent.StockSymbol) ?? DBNull.Value }); command.Parameters.Add(new NpgsqlParameter { NpgsqlDbType = NpgsqlDbType.Money, Value = ((object)systemEvent.Funds) ?? DBNull.Value }); command.Parameters.Add(new NpgsqlParameter { NpgsqlDbType = NpgsqlDbType.Varchar, Value = ((object)systemEvent.FileName) ?? DBNull.Value }); int id = ExecuteInsertCommand(command); Log.DebugFormat(CultureInfo.InvariantCulture, "Successfully inserted system event {0} (database id = {1}).", systemEvent.Id, id); } }
public override string HandleEvent(SystemEvent e, ref bool updateVisuals) { if (((e.Type == SystemEventType.Key) && (e.Value2 > 0)) == false) { return(string.Empty); } Keys key = (Keys)e.Value; if ((e.Value2 > 0) && (key == Keys.Mouse1)) { this.CaptureChild = this; RouteMouseCoordinates(0, 0); return(string.Empty); } if ((key == Keys.Right) || ((key == Keys.Mouse2) && ((this.UserInterface.CursorY > _thumbRect.Y) == true))) { _value.Set(_value + _stepSize); } if ((key == Keys.Left) || ((key == Keys.Mouse2) && ((this.UserInterface.CursorY < _thumbRect.Y) == true))) { _value.Set(_value - _stepSize); } if (this.Buddy != null) { this.Buddy.HandleBuddyUpdate(this); } else { this.UserInterface.State.Set(_cvarStr.ToString(), _value); } UpdateConsoleVariables(false); return(string.Empty); }
public void Post(SystemEvent @event) { var table = TableStorage.CreateCloudTable(); var entity = new EventEntity(@event.Date) { Message = @event.Message, User = @event.User }; try { table.CreateIfNotExists(); var insertOperation = new TableBatchOperation(); insertOperation.Insert(entity); table.ExecuteBatch(insertOperation); } catch (Exception) { } }
public void ReturnFalseIfAllChildFiltersFalse() { var e = new SystemEvent { Level = SystemEventLevel.Error, ProcessId = 123, Thread = "Unknown" }; var filter = new OrElseFilter( new FakeExtendedProperties(), new[] { new EqualFilter(new FakeExtendedProperties { { "property", "ProcessId" }, { "value", "1234" } }, Enumerable.Empty <ICreateFilterExpressions>()), new EqualFilter(new FakeExtendedProperties { { "property", "Thread" }, { "value", "Main" } }, Enumerable.Empty <ICreateFilterExpressions>()), new EqualFilter(new FakeExtendedProperties { { "property", "Level" }, { "value", "Warning" } }, Enumerable.Empty <ICreateFilterExpressions>()) }); Assert.False(Filter.Compile(filter).Invoke(e)); }
public override bool AddAndCheckIfTriggered(SystemEvent opResult) { if (Observers.Count == 0) { AlarmMessage = "No observers attached to rule. Rule can not let know when triggered through timeout."; return(true); } if (OperationName != null && opResult.OperationName == OperationName) { AddSingleOperation(); return(false); } if (opResult.OperationName == StartOperationName) { return(AddAndCheckIfTriggeredForStartOperation()); } if (opResult.OperationName == EndOperationName) { return(AddAndCheckIfTriggeredForEndOperation()); } return(false); }
public void Render(SystemEvent e) { if (filter.Exclude(e)) { return; } Console.ForegroundColor = timestampColor; Console.BackgroundColor = defaultBackColor; Console.Write(String.Format("{0:HH:mm:ss,fff} ", e.Timestamp)); Console.BackgroundColor = Settings.GetBackeColor(e.Level); Console.ForegroundColor = Settings.GetForeColor(e.Level); stringBuilder.Clear(); stringBuilder.AppendFormat("[{0}] ", GetProcessId(e)); stringBuilder.AppendFormat("{0} ", GetProcessName(e)); stringBuilder.AppendFormat("[{0}] ", GetThread(e)); stringBuilder.AppendFormat("{0} ", GetSource(e)); stringBuilder.AppendFormat("[{0}] ", GetLevel(e)); stringBuilder.Append(e.Message); Console.WriteLine(stringBuilder.ToString()); }
private void OnMessageReceived(string json) { Task.Run(async() => { SystemEvent systemEvent = JsonConvert.DeserializeObject <SystemEvent>(json); //update device status if (systemEvent.EventType == SystemEventTypesEnum.DeviceOnline || systemEvent.EventType == SystemEventTypesEnum.DeviceOffline) { _deviceManager.Tell(systemEvent); await this._devices.UpdateStatusAsync(systemEvent.EntityId, systemEvent.EventType == SystemEventTypesEnum.DeviceOnline ? true : false); Console.WriteLine("Device status updated"); } // Frame message for ack //dynamic message = new ExpandoObject(); //message.Type = "Acknowledgement"; //message.topic = ID; //var jsonMessage = JsonConvert.SerializeObject(message); ////send message to kafaka producer //_producer.ProduceMessage(Literals.KAFKA_TOPIC_CONFIG, jsonMessage); }); }
public IHttpActionResult PutSystemEvent(int id, SystemEvent systemEvent) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != systemEvent.Id) { return(BadRequest()); } using (SqlConnection con = new SqlConnection(conString.ConnectionString)) { using (SqlCommand cmd = new SqlCommand("UpdateSystemEvent", con)) { cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@Id", systemEvent.Id); cmd.Parameters.AddWithValue("@Description", systemEvent.Description); con.Open(); cmd.ExecuteNonQuery(); } } return(StatusCode(HttpStatusCode.NoContent)); }
public SystemEvent Parse(IMessage message) { Verify.NotNull(message, "message"); var match = pattern.Match(message.Message); var process = processes.GetProcessById(message.ProcessId); var level = Settings.GetLevel(match.Groups["level"].Value); return(match.Success ? new SystemEvent { Level = level, ProcessName = process.Name, ProcessId = process.Id, Timestamp = message.Timestamp, Thread = match.Groups["thread"].Value, Source = match.Groups["logger"].Value, Message = match.Groups["message"].Value, Username = match.Groups["username"].Value, RawMessage = new Lazy <String>(() => message.Message) } : SystemEvent.Create(message)); }
/// <summary> /// On shutdown we need to dispose our object manually before disposing the control /// </summary> public new void Dispose() { addLog("Dispose() called..."); #if USE_ENTER_KEY #else _continueWait = false; //signal thread to stop Thread.Sleep(100); SystemEvent waitEvent = new SystemEvent("EndWaitLoop52", false, false); waitEvent.PulseEvent(); Thread.Sleep(100); restoreKey(); #endif if (IntermecCamera != null) { #if STREAMING_ON addLog("...Dispose() we DO NOT SWITCH streaming"); #else IntermecCamera.Streaming = false; #endif IntermecCamera.Dispose(); IntermecCamera = null; } #if USE_ENTER_KEY #else //enable HW Trigger of Scanner //S9CconfigClass.S9Cconfig.HWTrigger.setHWTrigger(true); YetAnotherHelperClass.setHWTrigger(true); #endif #if REMAP_SCAN_TO_ENTERKEY restoreScanKey(); #endif //YetAnotherHelperClass.muteSpeakerVolume(false); Cursor.Current = Cursors.Default; //base.Dispose(); do not use!! addLog("...Dispose() finished"); }
public new void Dispose() { addLog("Dispose() called..."); _continueWait = false; //signal thread to stop Thread.Sleep(100); SystemEvent waitEvent = new SystemEvent("EndWaitLoop52", false, false); waitEvent.PulseEvent(); Thread.Sleep(100); #if STREAMING_ON //kill SnapShot Thread if (snapshotThread != null) { snapshotThread.Abort(); } #endif Thread.Sleep(100); if (_imager != null) { //restore AimerFlashing mode _imager.AimerFlashing = Imager.AimerFlashingMode.Auto; _imager.LightGoal = 128; _imager.VideoRunning = false; _imager.Dispose(); _imager = null; } //enable HW Trigger of Scanner //S9CconfigClass.S9Cconfig.HWTrigger.setHWTrigger(true); //removed as problems with ADCComInterface YetAnotherHelperClass.setHWTrigger(true); ITCTools.KeyBoard.restoreKey(); Cursor.Current = Cursors.Default; // base.Dispose(); do not use!! addLog("...Dispose() finished"); }
public Boolean Exclude(SystemEvent e) { return(!filter.Invoke(e)); }
public override string HandleEvent(SystemEvent e, ref bool updateVisuals) { idConsole.Warning("TODO: EditWindow HandleEvent"); /* TODO: static char buffer[ MAX_EDITFIELD ]; const char *ret = ""; if ( wrap ) { // need to call this to allow proper focus and capturing on embedded children ret = idWindow::HandleEvent( event, updateVisuals ); if ( ret && *ret ) { return ret; } } if ( ( event->evType != SE_CHAR && event->evType != SE_KEY ) ) { return ret; } idStr::Copynz( buffer, text.c_str(), sizeof( buffer ) ); int key = event->evValue; int len = text.Length(); if ( event->evType == SE_CHAR ) { if ( event->evValue == Sys_GetConsoleKey( false ) || event->evValue == Sys_GetConsoleKey( true ) ) { return ""; } if ( updateVisuals ) { *updateVisuals = true; } if ( maxChars && len > maxChars ) { len = maxChars; } if ( ( key == K_ENTER || key == K_KP_ENTER ) && event->evValue2 ) { RunScript( ON_ACTION ); RunScript( ON_ENTER ); return cmd; } if ( key == K_ESCAPE ) { RunScript( ON_ESC ); return cmd; } if ( readonly ) { return ""; } if ( key == 'h' - 'a' + 1 || key == K_BACKSPACE ) { // ctrl-h is backspace if ( cursorPos > 0 ) { if ( cursorPos >= len ) { buffer[len - 1] = 0; cursorPos = len - 1; } else { memmove( &buffer[ cursorPos - 1 ], &buffer[ cursorPos ], len + 1 - cursorPos); cursorPos--; } text = buffer; UpdateCvar( false ); RunScript( ON_ACTION ); } return ""; } // // ignore any non printable chars (except enter when wrap is enabled) // if ( wrap && (key == K_ENTER || key == K_KP_ENTER) ) { } else if ( !idStr::CharIsPrintable( key ) ) { return ""; } if ( numeric ) { if ( ( key < '0' || key > '9' ) && key != '.' ) { return ""; } } if ( dc->GetOverStrike() ) { if ( maxChars && cursorPos >= maxChars ) { return ""; } } else { if ( ( len == MAX_EDITFIELD - 1 ) || ( maxChars && len >= maxChars ) ) { return ""; } memmove( &buffer[ cursorPos + 1 ], &buffer[ cursorPos ], len + 1 - cursorPos ); } buffer[ cursorPos ] = key; text = buffer; UpdateCvar( false ); RunScript( ON_ACTION ); if ( cursorPos < len + 1 ) { cursorPos++; } EnsureCursorVisible(); } else if ( event->evType == SE_KEY && event->evValue2 ) { if ( updateVisuals ) { *updateVisuals = true; } if ( key == K_DEL ) { if ( readonly ) { return ret; } if ( cursorPos < len ) { memmove( &buffer[cursorPos], &buffer[cursorPos + 1], len - cursorPos); text = buffer; UpdateCvar( false ); RunScript( ON_ACTION ); } return ret; } if ( key == K_RIGHTARROW ) { if ( cursorPos < len ) { if ( idKeyInput::IsDown( K_CTRL ) ) { // skip to next word while( ( cursorPos < len ) && ( buffer[ cursorPos ] != ' ' ) ) { cursorPos++; } while( ( cursorPos < len ) && ( buffer[ cursorPos ] == ' ' ) ) { cursorPos++; } } else { if ( cursorPos < len ) { cursorPos++; } } } EnsureCursorVisible(); return ret; } if ( key == K_LEFTARROW ) { if ( idKeyInput::IsDown( K_CTRL ) ) { // skip to previous word while( ( cursorPos > 0 ) && ( buffer[ cursorPos - 1 ] == ' ' ) ) { cursorPos--; } while( ( cursorPos > 0 ) && ( buffer[ cursorPos - 1 ] != ' ' ) ) { cursorPos--; } } else { if ( cursorPos > 0 ) { cursorPos--; } } EnsureCursorVisible(); return ret; } if ( key == K_HOME ) { if ( idKeyInput::IsDown( K_CTRL ) || cursorLine <= 0 || ( cursorLine >= breaks.Num() ) ) { cursorPos = 0; } else { cursorPos = breaks[cursorLine]; } EnsureCursorVisible(); return ret; } if ( key == K_END ) { if ( idKeyInput::IsDown( K_CTRL ) || (cursorLine < -1) || ( cursorLine >= breaks.Num() - 1 ) ) { cursorPos = len; } else { cursorPos = breaks[cursorLine + 1] - 1; } EnsureCursorVisible(); return ret; } if ( key == K_INS ) { if ( !readonly ) { dc->SetOverStrike( !dc->GetOverStrike() ); } return ret; } if ( key == K_DOWNARROW ) { if ( idKeyInput::IsDown( K_CTRL ) ) { scroller->SetValue( scroller->GetValue() + 1.0f ); } else { if ( cursorLine < breaks.Num() - 1 ) { int offset = cursorPos - breaks[cursorLine]; cursorPos = breaks[cursorLine + 1] + offset; EnsureCursorVisible(); } } } if (key == K_UPARROW ) { if ( idKeyInput::IsDown( K_CTRL ) ) { scroller->SetValue( scroller->GetValue() - 1.0f ); } else { if ( cursorLine > 0 ) { int offset = cursorPos - breaks[cursorLine]; cursorPos = breaks[cursorLine - 1] + offset; EnsureCursorVisible(); } } } if ( key == K_ENTER || key == K_KP_ENTER ) { RunScript( ON_ACTION ); RunScript( ON_ENTER ); return cmd; } if ( key == K_ESCAPE ) { RunScript( ON_ESC ); return cmd; } } else if ( event->evType == SE_KEY && !event->evValue2 ) { if ( key == K_ENTER || key == K_KP_ENTER ) { RunScript( ON_ENTERRELEASE ); return cmd; } else { RunScript( ON_ACTIONRELEASE ); } } return ret;*/ return string.Empty; }
public void RaiseSystemEvent(object sender, XSystemEvent systemEvent) { SystemEvent?.Invoke(sender, systemEvent); }
static void Main(string[] args) { try { EventReporter.Instance.Init(); var t = 0; var innerCounter = 0; var edatalist = new List <SystemEvent>(); WriteLine("Generating first eventbatch..."); while (true) { try { if (innerCounter++ == 20) { WriteLine($"Enter för att skicka {innerCounter - 1} events."); //WriteLine($"Skickar {innerCounter - 1} events."); innerCounter = 0; ReadLine(); Clear(); //eventhubclient.SendBatch(edatalist); EventReporter.Instance.ReportEventBatchAsync(edatalist).Wait(); edatalist.Clear(); WriteLine("Sent."); WriteLine("Generating new eventbatch..."); } Write("."); //WriteLine(innerCounter); var opres = new SystemEvent(SystemEvent.OperationResult.Failure); opres.OtherInfo = $"{t++}"; if (t % 2 == 0) { opres.OperationName = "operation1"; } else { opres.OperationName = "operation2"; } opres.OperationParameters.Add(nameof(innerCounter), innerCounter); opres.OperationParameters.Add("test", 56); if (t % 8 == 0) { opres.AppInfo.ApplicationName = opres.PartitionKey = "Annan app"; } if (t % 6 == 0) { opres.Result = SystemEvent.OperationResult.Success; } else { opres.Result = SystemEvent.OperationResult.Failure; opres.CaughtException = new NullReferenceException(); //string error = null; //try //{ // if(t%7 == 0) // { // throw new ArgumentException("arg fail"); // } // if(error.Length == 9) // { // error = "9"; // } //} //catch(Exception ex) //{ // opres.Result = SystemEvent.OperationResult.Failure; // opres.CaughtException = ex; //} } var data = JsonConvert.SerializeObject(opres); //WriteLine(data); edatalist.Add(opres); //eventhubclient.Send(new EventData(Encoding.UTF8.GetBytes(data))); //Thread.Sleep(100); } catch (Exception ex) { WriteLine(ex.ToString()); ReadLine(); } } } catch (Exception ex) { WriteLine(ex.ToString()); ReadLine(); } }
//###################################################################### void waitLoop() { addLog("waitLoop starting..."); SystemEvent[] _events = new SystemEvent[3]; addLog("waitLoop setting up event array..."); _events[0] = new SystemEvent("StateLeftScan1", false, false); _events[1] = new SystemEvent("DeltaLeftScan1", false, false); _events[2] = new SystemEvent("EndWaitLoop52", false, false); try { do { //Sleep as long as a snapshot is pending while (_bTakingSnapShot && _continueWait) { Thread.Sleep(50); } if (!_continueWait) { Thread.CurrentThread.Abort(); } addLog2("waitLoop WaitForMultipleObjects..."); SystemEvent signaledEvent = SyncBase.WaitForMultipleObjects( -1, // wait for ever _events ) as SystemEvent; addLog2("waitLoop WaitForMultipleObjects released: "); if (_continueWait) { if (signaledEvent == _events[0]) { addLog2("######### Caught StateLeftScan ########"); onStateScan(); } if (signaledEvent == _events[1]) { addLog2("######### Caught DeltaLeftScan ########"); onDeltaScan(); } if (signaledEvent == _events[2]) { addLog2("######### Caught EndWaitLoop52 ########"); _continueWait = false; } } addLog2("waitLoop sleep(5)"); System.Threading.Thread.Sleep(5); } while (_continueWait); addLog("waitLoop while ended by _continueWait"); } catch (ThreadAbortException ex) { System.Diagnostics.Debug.WriteLine("waitLoop: ThreadAbortException: " + ex.Message); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("waitLoop: Exception: " + ex.Message); } finally { _events[0].Dispose(); _events[1].Dispose(); _events[2].Dispose(); } addLog("...waitLoop EXIT"); }
public void RenderMessageIfParserFound() { var e = new SystemEvent(); var message = new OutputDebugString("MySource", 123, "My Message"); var resetEvent = new ManualResetEvent(false); renderer.Setup(mock => mock.Render(It.IsAny<SystemEvent>())).Callback(() => resetEvent.Set()); parser.Setup(mock => mock.CanParseMessage("My Message")).Returns(true); parser.Setup(mock => mock.Parse(message)).Returns(e); processor.Process(message); Assert.True(resetEvent.WaitOne(TimeSpan.FromSeconds(1)), "ManualResetEvent not signalled within expected time."); renderer.Verify(mock => mock.Render(e), Times.Once()); }
public SystemEventWithMessage(ref SystemEvent e) { this.holder = e; }
public Boolean Exclude(SystemEvent e) { return !filter.Invoke(e); }
public Boolean Exclude(SystemEvent e) { return e == null || staticFilter.Exclude(e) || dynamicFilter != null && dynamicFilter.Exclude(e); }
public override string HandleEvent(SystemEvent e, ref bool updateVisuals) { idConsole.Warning("TODO: ListWindow HandleEvent"); // need to call this to allow proper focus and capturing on embedded children /*const char *ret = idWindow::HandleEvent(event, updateVisuals); float vert = GetMaxCharHeight(); int numVisibleLines = textRect.h / vert; int key = event->evValue; if ( event->evType == SE_KEY ) { if ( !event->evValue2 ) { // We only care about key down, not up return ret; } if ( key == K_MOUSE1 || key == K_MOUSE2 ) { // If the user clicked in the scroller, then ignore it if ( scroller->Contains(gui->CursorX(), gui->CursorY()) ) { return ret; } } if ( ( key == K_ENTER || key == K_KP_ENTER ) ) { RunScript( ON_ENTER ); return cmd; } if ( key == K_MWHEELUP ) { key = K_UPARROW; } else if ( key == K_MWHEELDOWN ) { key = K_DOWNARROW; } if ( key == K_MOUSE1) { if (Contains(gui->CursorX(), gui->CursorY())) { int cur = ( int )( ( gui->CursorY() - actualY - pixelOffset ) / vert ) + top; if ( cur >= 0 && cur < listItems.Num() ) { if ( multipleSel && idKeyInput::IsDown( K_CTRL ) ) { if ( IsSelected( cur ) ) { ClearSelection( cur ); } else { AddCurrentSel( cur ); } } else { if ( IsSelected( cur ) && ( gui->GetTime() < clickTime + doubleClickSpeed ) ) { // Double-click causes ON_ENTER to get run RunScript(ON_ENTER); return cmd; } SetCurrentSel( cur ); clickTime = gui->GetTime(); } } else { SetCurrentSel( listItems.Num() - 1 ); } } } else if ( key == K_UPARROW || key == K_PGUP || key == K_DOWNARROW || key == K_PGDN ) { int numLines = 1; if ( key == K_PGUP || key == K_PGDN ) { numLines = numVisibleLines / 2; } if ( key == K_UPARROW || key == K_PGUP ) { numLines = -numLines; } if ( idKeyInput::IsDown( K_CTRL ) ) { top += numLines; } else { SetCurrentSel( GetCurrentSel() + numLines ); } } else { return ret; } } else if ( event->evType == SE_CHAR ) { if ( !idStr::CharIsPrintable(key) ) { return ret; } if ( gui->GetTime() > typedTime + 1000 ) { typed = ""; } typedTime = gui->GetTime(); typed.Append( key ); for ( int i=0; i<listItems.Num(); i++ ) { if ( idStr::Icmpn( typed, listItems[i], typed.Length() ) == 0 ) { SetCurrentSel( i ); break; } } } else { return ret; } if ( GetCurrentSel() < 0 ) { SetCurrentSel( 0 ); } if ( GetCurrentSel() >= listItems.Num() ) { SetCurrentSel( listItems.Num() - 1 ); } if ( scroller->GetHigh() > 0.0f ) { if ( !idKeyInput::IsDown( K_CTRL ) ) { if ( top > GetCurrentSel() - 1 ) { top = GetCurrentSel() - 1; } if ( top < GetCurrentSel() - numVisibleLines + 2 ) { top = GetCurrentSel() - numVisibleLines + 2; } } if ( top > listItems.Num() - 2 ) { top = listItems.Num() - 2; } if ( top < 0 ) { top = 0; } scroller->SetValue(top); } else { top = 0; scroller->SetValue(0.0f); } if ( key != K_MOUSE1 ) { // Send a fake mouse click event so onAction gets run in our parents const sysEvent_t ev = sys->GenerateMouseButtonEvent( 1, true ); idWindow::HandleEvent(&ev, updateVisuals); } if ( currentSel.Num() > 0 ) { for ( int i = 0; i < currentSel.Num(); i++ ) { gui->SetStateInt( va( "%s_sel_%i", listName.c_str(), i ), currentSel[i] ); } } else { gui->SetStateInt( va( "%s_sel_0", listName.c_str() ), 0 ); } gui->SetStateInt( va( "%s_numsel", listName.c_str() ), currentSel.Num() ); return ret;*/ return string.Empty; }
public string HandleEvent(SystemEvent e, int time, ref bool updateVisuals) { if(this.Disposed == true) { throw new ObjectDisposedException(this.GetType().Name); } _time = time; if((_bindHandler != null) && (e.Type == SystemEventType.Key) && (e.Value2 == 1)) { string ret = _bindHandler.HandleEvent(e, ref updateVisuals); _bindHandler = null; return ret; } if(e.Type == SystemEventType.Mouse) { _cursorX += e.Value; _cursorY += e.Value2; if(_cursorX < 0) { _cursorX = 0; } if(_cursorY < 0) { _cursorY = 0; } } if(this.Desktop != null) { this.Desktop.HandleEvent(e, ref updateVisuals); } return string.Empty; }
public override string HandleEvent(SystemEvent e, ref bool updateVisuals) { if(this.Disposed == true) { throw new ObjectDisposedException(this.GetType().Name); } idConsole.Warning("TODO: ChoiceWindow HandleEvent"); /*int key; bool runAction = false; bool runAction2 = false; if ( event->evType == SE_KEY ) { key = event->evValue; if ( key == K_RIGHTARROW || key == K_KP_RIGHTARROW || key == K_MOUSE1) { // never affects the state, but we want to execute script handlers anyway if ( !event->evValue2 ) { RunScript( ON_ACTIONRELEASE ); return cmd; } currentChoice++; if (currentChoice >= choices.Num()) { currentChoice = 0; } runAction = true; } if ( key == K_LEFTARROW || key == K_KP_LEFTARROW || key == K_MOUSE2) { // never affects the state, but we want to execute script handlers anyway if ( !event->evValue2 ) { RunScript( ON_ACTIONRELEASE ); return cmd; } currentChoice--; if (currentChoice < 0) { currentChoice = choices.Num() - 1; } runAction = true; } if ( !event->evValue2 ) { // is a key release with no action catch return ""; } } else if ( event->evType == SE_CHAR ) { key = event->evValue; int potentialChoice = -1; for ( int i = 0; i < choices.Num(); i++ ) { if ( toupper(key) == toupper(choices[i][0]) ) { if ( i < currentChoice && potentialChoice < 0 ) { potentialChoice = i; } else if ( i > currentChoice ) { potentialChoice = -1; currentChoice = i; break; } } } if ( potentialChoice >= 0 ) { currentChoice = potentialChoice; } runAction = true; runAction2 = true; } else { return ""; } if ( runAction ) { RunScript( ON_ACTION ); } if ( choiceType == 0 ) { cvarStr.Set( va( "%i", currentChoice ) ); } else if ( values.Num() ) { cvarStr.Set( values[ currentChoice ] ); } else { cvarStr.Set( choices[ currentChoice ] ); } UpdateVars( false ); if ( runAction2 ) { RunScript( ON_ACTIONRELEASE ); } return cmd;*/ return string.Empty; }
private string HandleKeyEvent(SystemEvent e, Keys key, bool down, ref bool updateVisuals) { EvaluateRegisters(-1, true); updateVisuals = true; if(key == Keys.Mouse1) { if((down == false) && (this.CaptureChild != null)) { this.CaptureChild.HandleCaptureLost(); this.UserInterface.Desktop.CaptureChild = null; return string.Empty; } int c = _children.Count; while(--c >= 0) { idWindow child = _children[c]; if((child.IsVisible == true) && (child.Contains(child.DrawRectangle, this.UserInterface.CursorX, this.UserInterface.CursorY) == true) && (child.NoEvents == false)) { if(down == true) { BringToTop(child); SetFocus(child); if((child.Flags & WindowFlags.HoldCapture) == WindowFlags.HoldCapture) { this.CaptureChild = child; } } if(child.Contains(child.ClientRectangle, this.UserInterface.CursorX, this.UserInterface.CursorY) == true) { //if ((gui_edit.GetBool() && (child->flags & WIN_SELECTED)) || (!gui_edit.GetBool() && (child->flags & WIN_MOVABLE))) { // SetCapture(child); //} SetFocus(child); string childReturn = child.HandleEvent(e, ref updateVisuals); if(childReturn != string.Empty) { return childReturn; } if((child.Flags & WindowFlags.Modal) == WindowFlags.Modal) { return string.Empty; } } else { if(down == true) { SetFocus(child); bool capture = true; if((capture == true) && (((child.Flags & WindowFlags.Movable) == WindowFlags.Movable) || (idE.CvarSystem.GetBool("gui_edit") == true))) { this.CaptureChild = child; } return string.Empty; } } } } if((down == true) && (_actionDownRun == false)) { _actionDownRun = RunScript(ScriptName.Action); } else if(_actionUpRun == false) { _actionUpRun = RunScript(ScriptName.ActionRelease); } } else if (key == Keys.Mouse2) { if((down == false) && (this.CaptureChild != null)) { this.CaptureChild.HandleCaptureLost(); this.UserInterface.Desktop.CaptureChild = null; return string.Empty; } int c = _children.Count; while(--c >= 0) { idWindow child = _children[c]; if((child.IsVisible == true) && (child.Contains(child.DrawRectangle, this.UserInterface.CursorX, this.UserInterface.CursorY) == true) && (child.NoEvents == false)) { if(down == true) { BringToTop(child); SetFocus(child); } if((child.Contains(child.ClientRectangle, this.UserInterface.CursorX, this.UserInterface.CursorY) == true) || (this.CaptureChild == child)) { if(((idE.CvarSystem.GetBool("gui_edit") == true) && ((child.Flags & WindowFlags.Selected) == WindowFlags.Selected)) || (idE.CvarSystem.GetBool("gui_edit") == false) && ((child.Flags & WindowFlags.Movable) == WindowFlags.Movable)) { this.CaptureChild = child; } string childReturn = child.HandleEvent(e, ref updateVisuals); if(childReturn != string.Empty) { return childReturn; } if((child.Flags & WindowFlags.Modal) == WindowFlags.Modal) { return string.Empty; } } } } } else if(key == Keys.Mouse3) { if(idE.CvarSystem.GetBool("gui_edit") == true) { int c = _children.Count; for(int i = 0; i < c; i++) { if(_children[i].DrawRectangle.Contains(this.UserInterface.CursorX, this.UserInterface.CursorY) == true) { if(down == true) { _children[i].Flags ^= WindowFlags.Selected; if((_children[i].Flags & WindowFlags.Selected) == WindowFlags.Selected) { this.Flags &= ~WindowFlags.Selected; return "childsel"; } } } } } } else if((key == Keys.Tab) && (down == true)) { if(this.FocusedChild != null) { string childRet = this.FocusedChild.HandleEvent(e, ref updateVisuals); if(childRet != string.Empty) { return childRet; } // If the window didn't handle the tab, then move the focus to the next window // or the previous window if shift is held down int direction = 1; if(idE.Input.IsKeyDown(Keys.LeftShift) == true) { direction = -1; } idWindow currentFocus = this.FocusedChild; idWindow child = this.FocusedChild; idWindow parent = child.Parent; while(parent != null) { bool foundFocus = false; bool recurse = false; int index = 0; if(child != null) { index = parent.GetChildIndex(child) + direction; } else if(direction < 0) { index = parent.ChildCount - 1; } while((index < parent.ChildCount) && (index >= 0)) { idWindow testWindow = parent.GetChild(index); if(testWindow == currentFocus) { // we managed to wrap around and get back to our starting window foundFocus = true; break; } else if((testWindow != null) && (testWindow.NoEvents == false) && (testWindow.IsVisible == true)) { if((testWindow.Flags & WindowFlags.CanFocus) == WindowFlags.CanFocus) { SetFocus(testWindow); foundFocus = true; break; } else if(testWindow.ChildCount > 0) { parent = testWindow; child = null; recurse = true; break; } } index += direction; } if(foundFocus == true) { // we found a child to focus on break; } else if(recurse == true) { // we found a child with children continue; } else { // we didn't find anything, so go back up to our parent child = parent; parent = child.Parent; if(parent == this.UserInterface.Desktop) { // we got back to the desktop, so wrap around but don't actually go to the desktop parent = null; child = null; } } } } } else if((key == Keys.Escape) && (down == true)) { if(this.FocusedChild != null) { string childRet = this.FocusedChild.HandleEvent(e, ref updateVisuals); if(childRet != string.Empty) { return childRet; } } RunScript(ScriptName.Escape); } else if(key == Keys.Enter) { if(this.FocusedChild != null) { string childRet = this.FocusedChild.HandleEvent(e, ref updateVisuals); if(childRet != string.Empty) { return childRet; } } if((this.Flags & WindowFlags.WantEnter) == WindowFlags.WantEnter) { if(down == true) { RunScript(ScriptName.Action); } else { RunScript(ScriptName.ActionRelease); } } } else { if(this.FocusedChild != null) { string childRet = this.FocusedChild.HandleEvent(e, ref updateVisuals); if(childRet != string.Empty) { return childRet; } } } return string.Empty; }
public EventRecordProxy(ref SystemEvent item) { this.OriginalEvent = item; }
public void DefaultValues() { var sut = new SystemEvent(); Assert.AreEqual(SystemEventType.Unknown, sut.Type); }
public override string HandleEvent(SystemEvent e, ref bool updateVisuals) { if(((e.Type == SystemEventType.Key) && (e.Value2 > 0)) == false) { return string.Empty; } Keys key = (Keys) e.Value; if((e.Value2 > 0) && (key == Keys.Mouse1)) { this.CaptureChild = this; RouteMouseCoordinates(0, 0); return string.Empty; } if((key == Keys.Right) || ((key == Keys.Mouse2) && ((this.UserInterface.CursorY > _thumbRect.Y) == true))) { _value.Set(_value + _stepSize); } if((key == Keys.Left) || ((key == Keys.Mouse2) && ((this.UserInterface.CursorY < _thumbRect.Y) == true))) { _value.Set(_value - _stepSize); } if(this.Buddy != null) { this.Buddy.HandleBuddyUpdate(this); } else { this.UserInterface.State.Set(_cvarStr.ToString(), _value); } UpdateConsoleVariables(false); return string.Empty; }
void Run() { SystemEvent exclusiveEvent = null; SystemMutex exclusiveMutex = null; IDisposable exclusiveLock = null; SystemMutex priorityMutex = null; SystemMutex transientMutex = null; try { var em = HidSelector.Instance.EventManager; // *** Open the device. try { string transientName = GetResourceName("Transient"); // Create or open the exclusive event. exclusiveEvent = em.CreateEvent(GetResourceName("Event")); // Try to acquire the device. exclusiveMutex = em.CreateMutex(GetResourceName("Lock")); if (!exclusiveMutex.TryLock(0, out exclusiveLock)) { // We failed just locking it outright. First, can we interrupt? bool lockIsInterruptible = false; for (int priority = (int)OpenPriority.Idle; priority < (int)_priority; priority++) { if (em.MutexMayExist(GetResourceNameForPriority((OpenPriority)priority))) { lockIsInterruptible = true; break; } } // Let's try again. bool lockIsTransient = em.MutexMayExist(transientName); using (var tryPriorityMutex = (lockIsInterruptible ? em.CreateMutex(GetResourceNameForPriorityRequest()) : null)) { exclusiveEvent.Set(); int timeout; if (lockIsTransient) { timeout = Math.Max(0, _timeoutIfTransient); HidSharpDiagnostics.Trace("Failed to open the device. Luckily, it is in use by a transient process. We will wait {0} ms.", timeout); } else if (lockIsInterruptible) { timeout = Math.Max(0, _timeoutIfInterruptible); HidSharpDiagnostics.Trace("Failed to open the device. Luckily, it is in use by an interruptible process. We will wait {0} ms.", timeout); } else { timeout = 0; } if (!exclusiveMutex.TryLock(timeout, out exclusiveLock)) { throw DeviceException.CreateIOException(_device, "The device is in use.", Utility.HResult.SharingViolation); } } } if (_transient) { transientMutex = em.CreateMutex(transientName); } if (_interruptible) { priorityMutex = em.CreateMutex(GetResourceNameForPriority(_priority)); } } catch (Exception e) { _threadStartError = e; return; } finally { _threadStartEvent.Set(); } // *** OK! Now run the sharing monitor. { var handles = new WaitHandle[] { _closeEvent, exclusiveEvent.WaitHandle }; Exception ex = null; HidSharpDiagnostics.Trace("Started the sharing monitor thread ({0}).", Thread.CurrentThread.ManagedThreadId); while (true) { try { if (WaitHandle.WaitAny(handles) == 0) { break; } } catch (Exception e) { ex = e; break; } lock (_syncRoot) { // Okay. We received the request. Let's check for request priorities higher than ours. exclusiveEvent.Reset(); HidSharpDiagnostics.Trace("Received an interrupt request ({0}).", Thread.CurrentThread.ManagedThreadId); if (em.MutexMayExist(GetResourceNameForPriorityRequest())) { ThreadPool.QueueUserWorkItem(_ => { var ev = InterruptRequested; if (ev != null) { ev(this, EventArgs.Empty); } }); } } } HidSharpDiagnostics.Trace("Exited its sharing monitor thread ({0}).{1}", Thread.CurrentThread.ManagedThreadId, (ex != null ? " " + ex.ToString() : "")); } } finally { Close(ref priorityMutex); Close(ref transientMutex); Close(ref exclusiveLock); Close(ref exclusiveMutex); Close(ref exclusiveEvent); _closeEvent.Close(); _closeEvent = null; _thread = null; } }
public void OnSystemEvent(SystemEvent @event) { throw new NotImplementedException(); }
public string HandleEvent(SystemEvent e, int time) { if(this.Disposed == true) { throw new ObjectDisposedException(this.GetType().Name); } bool updateVisuals = false; return HandleEvent(e, time, ref updateVisuals); }
public void Notify(SystemEvent value) { Change(value); }
public override string HandleEvent(SystemEvent e, ref bool updateVisuals) { idConsole.Warning("TODO: BindWindow HandleEvent"); /*static char ret[ 256 ]; if (!(event->evType == SE_KEY && event->evValue2)) { return ""; } int key = event->evValue; if (waitingOnKey) { waitingOnKey = false; if (key == K_ESCAPE) { idStr::snPrintf( ret, sizeof( ret ), "clearbind \"%s\"", bindName.GetName()); } else { idStr::snPrintf( ret, sizeof( ret ), "bind %i \"%s\"", key, bindName.GetName()); } return ret; } else { if (key == K_MOUSE1) { waitingOnKey = true; gui->SetBindHandler(this); return ""; } } return "";*/ return string.Empty; }
private async void SystemActivityService_SystemActivitySnapshot(object sender, SystemEvent e) { await userSystemEventRepository.Create(new UserSystemEvent { EventType = e.EventType, DateTime = e.DateTime }); }
public virtual string HandleEvent(SystemEvent e, ref bool updateVisuals) { if(this.Disposed == true) { throw new ObjectDisposedException(this.GetType().Name); } if((_flags & WindowFlags.Desktop) == WindowFlags.Desktop) { _actionDownRun = false; _actionUpRun = false; if((_expressionRegisters.Count > 0) && (_ops.Count > 0)) { EvaluateRegisters(); } RunTimeEvents(_gui.Time); CalculateRectangles(0, 0); this.DeviceContext.Cursor = Cursor.Arrow; } if((_visible == true) && (_noEvents == false)) { if(e.Type == SystemEventType.Key) { string keyReturn = HandleKeyEvent(e, (Keys) e.Value, (e.Value2 == 1), ref updateVisuals); if(keyReturn != string.Empty) { return keyReturn; } } else if(e.Type == SystemEventType.Mouse) { string mouseReturn = HandleMouseEvent(e.Value, e.Value2, ref updateVisuals); if(mouseReturn != string.Empty) { return mouseReturn; } } else if(e.Type == SystemEventType.None) { } else if(e.Type == SystemEventType.Char) { if(this.FocusedChild != null) { string childRet = this.FocusedChild.HandleEvent(e, ref updateVisuals); if((childRet != null) && (childRet != string.Empty)) { return childRet; } } } } this.UserInterface.ReturnCommand = string.Empty; if(this.UserInterface.PendingCommand.Length > 0) { this.UserInterface.ReturnCommand += " ; "; this.UserInterface.ReturnCommand += this.UserInterface.PendingCommand; this.UserInterface.PendingCommand = string.Empty; } return this.UserInterface.ReturnCommand; }