public static void AskSurvey()
{
Stats stats = new Stats();
stats.Start();
Data data = new Data();
Console.WriteLine("What is your name?");
data.Name = TryAnswer();
Console.WriteLine("What is your age?");
data.Age = int.Parse(TryAnswer());
Console.WriteLine("What is your birth month?");
data.Month = TryAnswer();
//if(Triggered != null)
//{
// Triggered();
//}
Triggered?.Invoke();
data.Display();
}
private void Tick(object sender, EventArgs e)
{
isRunningTrigger = true;
parseTimer.Stop();
Triggered?.Invoke();
isRunningTrigger = false;
}
/// <summary>
/// fires some trigger
/// changes the state if needed
///
/// returns true if a valid transition is called
///
/// </summary>
/// <param name="trigger"></param>
public bool Fire(TTrigger trigger)
{
object fromState = fsm.CurrentStateMap.state;
if (!dict.ContainsKey(fromState))
{
return(false);
}
Transition <TTrigger, TState> transition = dict[fromState].ProcessTrigger(trigger);
if (transition == null)
{
return(false);
}
if (transition != null && BeforeTriggered != null)
{
BeforeTriggered.Invoke(transition);
}
fsm.ChangeState(transition.toState, transition.overrideSetting);
if (Triggered != null)
{
Triggered.Invoke(transition);
}
return(true);
}
public PlusButton(int height)
{
Rectangle backgroundRect;
Children.Add(backgroundRect = new Rectangle
{
Fill = Brushes.DimGray,
StrokeThickness = 1,
Height = height,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Stretch
});
backgroundRect.RadiusX = backgroundRect.RadiusY = height / 2.0;
Children.Add(new Rectangle
{
Fill = Brushes.White,
Width = height * 2 / 3.0,
Height = height * 2 / 9.0,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center,
IsHitTestVisible = false
});
Children.Add(new Rectangle
{
Fill = Brushes.White,
Width = height * 2 / 9.0,
Height = height * 2 / 3.0,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center,
IsHitTestVisible = false
});
backgroundRect.MouseEnter += (s0, e0) => ((Rectangle)s0).Fill = Brushes.MediumAquamarine;
backgroundRect.MouseLeave += (s0, e0) => ((Rectangle)s0).Fill = Brushes.DimGray;
backgroundRect.MouseUp += (s1, e1) => Triggered?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// fires some trigger
/// changes the state if needed
///
/// returns true if a valid transition is called
///
/// </summary>
/// <param name="trigger"></param>
public bool Fire(TTrigger trigger)
{
try
{
object fromState = fsm.CurrentStateMap.state;
Transition <TTrigger, TState> transition = dict[fromState].ProcessTrigger(trigger);
if (transition != null && BeforeTriggered != null)
{
BeforeTriggered.Invoke(transition);
}
fsm.ChangeState(transition.toState, transition.overrideSetting);
if (Triggered != null)
{
Triggered.Invoke(transition);
}
return(true);
}
catch
{
// does not find valid transition regarding this state
return(false);
}
}
public MinusButton(int width, int height)
{
Rectangle backgroundRect;
Children.Add(backgroundRect = new Rectangle
{
Fill = Brushes.DarkGray,
Width = width,
Height = height,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center
});
backgroundRect.RadiusX = backgroundRect.RadiusY = Math.Min(width, height) / 2.0;
Children.Add(new Rectangle
{
Fill = Brushes.White,
Width = Math.Min(width, height) * 2 / 3.0,
Height = Math.Min(width, height) * 2 / 9.0,
VerticalAlignment = VerticalAlignment.Center,
HorizontalAlignment = HorizontalAlignment.Center,
IsHitTestVisible = false
});
backgroundRect.MouseEnter += (s0, e0) => ((Rectangle)s0).Fill = Brushes.IndianRed;
backgroundRect.MouseLeave += (s0, e0) => ((Rectangle)s0).Fill = Brushes.DarkGray;
backgroundRect.MouseUp += (s1, e1) => Triggered?.Invoke(this, EventArgs.Empty);
}
private void Handler(string name)
{
if (string.Equals(name, Name, StringComparison.OrdinalIgnoreCase))
{
Triggered?.Invoke();
}
}
public void Update()
{
var currentWatchLocationValue = m_memoryDomains.MainMemory.PeekByte(m_memoryTrigger.TriggerAddress);
if (currentWatchLocationValue != m_lastWatchLocationValue)
{
bool wereConditionsMet = true;
foreach (var v in m_memoryTrigger.ExpectedMemoryValues)
{
if (m_memoryDomains.MainMemory.PeekByte(v.Item1) != v.Item2)
{
wereConditionsMet = false;
break;
}
}
if (wereConditionsMet)
{
lock (m_lock)
{
m_isTriggered = true;
}
Triggered?.Invoke(this, EventArgs.Empty);
}
m_lastWatchLocationValue = currentWatchLocationValue;
}
}
protected override async Task OnLoop()
{
if (!enabled)
{
return;
}
var ns = sql.SelectToList(ServiceTable, (SqlColumn)ServiceColumnTimestamp > last, SqlOrder.By(ServiceColumnTimestamp, Order.Descending));
if (ns.Count > 0)
{
last = ns[0][ServiceColumnTimestamp].GetDateTime();
var tags = new List <string>();
foreach (SqlRow row in ns)
{
var tag = row[ServiceColumnTag].GetString();
if (tag != null && !tags.Contains(tag))
{
tags.Add(tag);
}
}
foreach (var tag in tags)
{
Triggered?.Invoke(this, new SqlServiceTriggerEventArgs(tag));
}
}
}
private void Tick(object state)
{
var position = _gazePointProvider.CurrentPosition;
if (position == null)
{
return;
}
var pNew = position.Value;
var now = _clock.Time;
if (_point == null)
{
_point = new Timestamped <Point>(now, pNew);
return;
}
var pOld = _point.Value.Value;
if (Math.Abs(pOld.X - pNew.X) + Math.Abs(pOld.Y - pNew.Y) > _cursorMovementTolerance)
{
_point = new Timestamped <Point>(now, pNew);
if (_cancellable && _inTrial)
{
Cancelled?.Invoke(this, EventArgs.Empty);
}
return;
}
if (_inTrial || _clock.Unit.ToMilliseconds(Math.Abs(now - _point.Value.Timestamp)) < _dwellToSelectDelay)
{
return;
}
_point = new Timestamped <Point>(now, pNew);
_inTrial = true;
Triggered?.Invoke(this, EventArgs.Empty);
}
void ProcessMessage(ref MSG msg, ref bool handled)
{
if ((msg.message == (int)WindowsMessage.HOTKEY) &&
(msg.wParam.ToInt32() == Identifier))
{
Triggered?.Invoke();
}
}
public void Update(float time)
{
if (time - startTime > _delay)
{
endTime = time;
Triggered?.Invoke(this);
}
}
public void Update()
{
var detected = m_Sense.Invoke();
if (detected != null)
{
Triggered?.Invoke(detected);
}
}
public void Tick()
{
if (Count == 0)
{
Count = Threshold;
Triggered?.Invoke();
}
Count--;
}
public void Execute()
{
Triggered?.Invoke(this, new TriggeredEventArgs());
foreach (var action in _actions)
{
action();
}
}
protected Task Invoke(TriggeredEventArgs e)
{
return(Task.Run(() =>
{
if (EnableTrigger && EnableAllTriggers)
{
Triggered?.Invoke(this, e);
}
}));
}
private void OnTimerTick(object sender, EventArgs e)
{
if ((DateTime.Now - _lastEventTime) < _delay)
{
return;
}
var eventArgs = new DelayEventTimerArgs(_data);
Triggered?.Invoke(this, eventArgs);
_timer.IsEnabled = eventArgs.RepeatEvent;
}
private void OnStateChanged(bool old, bool @new)
{
if (_mode == Mode.Falling && !@new)
{
Triggered?.Invoke();
}
else if (_mode == Mode.Rising && @new)
{
Triggered?.Invoke();
}
}
public void OnEvent(AddonEventKind evt)
{
foreach (var trigger in _eventTriggers)
{
if ((trigger.Option == EarTrumpetEventKind.Startup && evt == AddonEventKind.InitializeAddon) ||
(trigger.Option == EarTrumpetEventKind.Shutdown && evt == AddonEventKind.AppShuttingDown))
{
Triggered?.Invoke(trigger);
}
}
}
public void Trigger(string[] tags)
{
if (!enabled)
{
return;
}
foreach (var tag in tags)
{
Triggered?.Invoke(this, new SqlServiceTriggerEventArgs(tag));
}
}
private void Monitor_KeyEvent(object sender, EventSourceEventArgs <KeyboardEvent> e)
{
if (State.Next(e.Data) == StateMachineResult.Complete)
{
var args = new KeySequenceEventArgs()
{
Input = e,
Sequence = Sequence
};
Triggered?.Invoke(this, args);
}
}
public override void update(Clock clock, EventManager eventManager)
{
remainingTime -= clock.DeltaTimeMicro;
if (remainingTime <= 0)
{
if (Triggered != null)
{
Triggered.Invoke(this);
}
remainingTime = Clock.SecondsToMicroseconds(TimeSeconds);
}
}
public AnchorBasedActionView(LabelDescr lbl, string title = null)
{
if (lbl.Label == null && lbl.PreLabelIcon == null)
{
throw new Exception("cannot have labelless and icon less in the same time");
}
_a = new HTMLAnchorElement {
Href = "#",
ClassName = GetType().FullNameWithoutGenerics(),
Title = title ?? ""
};
var preLabel = Document.CreateElement("div");
_a.AppendChild(preLabel);
if (lbl.PreLabelIcon != null)
{
preLabel.AddClasses(lbl.PreLabelIcon.Item1.ToCssClassName());
preLabel.TextContent = lbl.PreLabelIcon.Item2;
}
var label = Document.CreateElement("div");
_a.AppendChild(label);
label.TextContent = lbl.Label ?? "";
Enabled = true; //initialize css class
_a.OnClick += ev => {
Logger.Debug(GetType(), "handling onclick");
if (OnClickPreventsDefault)
{
ev.PreventDefault();
}
if (ev.HasHtmlTarget() && !ShouldTriggerOnTarget(ev.HtmlTarget()))
{
return;
}
if (!Enabled || State.Type == ActionViewStateType.OperationRunning)
{
return;
}
Triggered?.Invoke();
};
}
public void Tick()
{
if (Count == 0 && active)
{
Count = Threshold;
Triggered?.Invoke();
return;
}
else if (active)
{
Count--;
}
}
public void Register(BaseTrigger trig)
{
if (trig is ProcessTrigger)
{
var trigger = (ProcessTrigger)trig;
if (!string.IsNullOrWhiteSpace(trigger.Text))
{
if (trigger.Option == ProcessEventKind.Start)
{
ProcessWatcher.Current.RegisterStart(trigger.Text, () => Triggered?.Invoke(trig));
}
else
{
ProcessWatcher.Current.RegisterStop(trigger.Text, () => Triggered?.Invoke(trig));
}
}
}
else if (trig is EventTrigger)
{
_eventTriggers.Add((EventTrigger)trig);
}
else if (trig is DeviceEventTrigger)
{
_audioManager.Register(trig);
}
else if (trig is AppEventTrigger)
{
_audioManager.Register(trig);
}
else if (trig is HotkeyTrigger)
{
var trigger = (HotkeyTrigger)trig;
HotkeyManager.Current.Register(trigger.Option);
HotkeyManager.Current.KeyPressed += (data) =>
{
if (data.Equals(trigger.Option))
{
Triggered?.Invoke(trig);
}
};
}
else if (trig is ContextMenuTrigger)
{
// Nothing to do.
}
else
{
throw new NotImplementedException();
}
}
private void OnDeviceAddOrRemove(IAudioDevice device, AudioDeviceEventKind option)
{
foreach (var trigger in _deviceTriggers)
{
if (trigger.Option == option)
{
// Default device: not supported
if (trigger.Device.Id == device.Id)
{
Triggered?.Invoke(trigger);
}
}
}
}
/// <summary>
/// Do not schedule trigger events so that the call stack is maintained.
/// </summary>
/// <param name="tripArgs"></param>
private void OnTriggered(TripEventArgs tripArgs)
{
try
{
// Add self to the route history.
tripArgs.Waypoints.AddLast(new Waypoint(this));
Triggered?.Invoke(this, tripArgs);
}
catch (Exception ex)
{
//TODO: remove self from route history?
_logger.Error($"{ex.GetType().Name} during {nameof(Triggered)} event from {Name} trigger.", ex);
}
}
public bool IsTriggered(KeyboardState state)
{
if (_keyMatcher(state))
{
if (!_pressing)
{
_pressing = true;
Triggered?.Invoke(this, EventArgs.Empty);
return(true);
}
}
else
{
_pressing = false;
}
return(false);
}
private void ProcessDefaultChanged(IAudioDevice newDefault)
{
foreach (var trigger in _deviceTriggers)
{
if (trigger.Device.Id == _defaultPlaybackDevice?.Id &&
trigger.Option == AudioDeviceEventKind.LeavingDefault)
{
Triggered?.Invoke(trigger);
}
if (trigger.Device.Id == newDefault.Id &&
trigger.Option == AudioDeviceEventKind.BecomingDefault)
{
Triggered?.Invoke(trigger);
}
}
}
private void OnTouch(TouchEvent evt)
{
SparrowSharp.MouseCursor = (_useHandCursor && _enabled && evt.InteractsWith(this)) ? MouseCursor.Hand : MouseCursor.Default;
if (!_enabled)
{
return;
}
Touch touch = evt.GetTouch(this);
if (touch == null)
{
State = ButtonState.Up;
}
else if (touch.Phase == TouchPhase.Stationary)
{
State = ButtonState.Over;
}
else if (touch.Phase == TouchPhase.Began && _state != ButtonState.Down)
{
_triggerBounds = GetBounds(Stage);
_triggerBounds.Inflate(MaxDragDist, MaxDragDist);
State = ButtonState.Down;
}
else if (touch.Phase == TouchPhase.Moved)
{
var isWithinBounds = _triggerBounds.Contains(touch.GlobalX, touch.GlobalY);
if (_state == ButtonState.Down && !isWithinBounds)
{
// reset button when finger is moved too far away ...
State = ButtonState.Up;
}
else if (_state == ButtonState.Up && isWithinBounds)
{
// ... and reactivate when the finger moves back into the bounds.
State = ButtonState.Down;
}
}
else if (touch.Phase == TouchPhase.Ended && _state == ButtonState.Down)
{
State = ButtonState.Up;
Triggered?.Invoke(this, evt);
}
}
