public bool ReportInput(InputDevice device, InputReport inputReport)
{
if (this._isDisposed)
{
throw new InvalidOperationException();
}
bool flag = false;
InputReportEventArgs input = new InputReportEventArgs(device, inputReport)
{
RoutedEvent = GHIElectronics.TinyCLR.UI.Input.InputManager.PreviewInputReportEvent
};
if (this._inputManager != null)
{
flag = this._inputManager.ProcessInput(input);
}
return(flag);
}
/// <summary>
/// Reports input to the input manager.
/// </summary>
/// <returns>
/// Whether or not any event generated as a consequence of this
/// event was handled.
/// </returns>
// do we really need this? Make the "providers" call InputManager.ProcessInput themselves.
// we currently need to map back to providers for other reasons.
public bool ReportInput(InputDevice device, InputReport inputReport)
{
if (this._isDisposed)
{
throw new InvalidOperationException();
}
var handled = false;
var input = new InputReportEventArgs(device, inputReport)
{
RoutedEvent = InputManager.PreviewInputReportEvent
};
if (this._inputManager != null)
{
handled = this._inputManager.ProcessInput(input);
}
return(handled);
}
private object ProcessStagingArea(object frame)
{
var handled = false;
// NOTE -- avalon caches the XXXEventArgs. In our system, the costs are different,
// so it is probably cheaper for us to just create them, since everything gets created
// on the heap anyways, and IL is expensive. we should reconsider this if
// its a performance impact.
// Because we can be reentered, we can't just enumerate over the
// staging area - that could throw an exception if the queue
// changes underneath us. Instead, just loop until we find a
// frame marker or until the staging area is empty.
try {
while (this._stagingArea.Count > 0)
{
this._currentStagingStack = this._stagingArea.Dequeue() as Stack;
do
{
var item = (StagingAreaInputItem)this._currentStagingStack.Pop();
// Pre-Process the input. This could modify the staging
// area, and it could cancel the processing of this
// input event.
//
var fCanceled = false;
var devType = (int)item.Input._inputDevice.DeviceType;
if (this.InputDeviceEvents[devType]._preProcessInput != null)
{
PreProcessInputEventArgs preProcessInputEventArgs;
this.InputDeviceEvents[devType]._preProcessInput(this, preProcessInputEventArgs = new PreProcessInputEventArgs(item));
fCanceled = preProcessInputEventArgs._canceled;
}
if (!fCanceled)
{
// Pre-Notify the input.
//
this.InputDeviceEvents[devType]._preNotifyInput?.Invoke(this, new NotifyInputEventArgs(item));
// Raise the input event being processed.
var input = item.Input;
// Some input events are explicitly associated with
// an element. Those that are not instead are associated with
// the target of the input device for this event.
var eventSource = input._source as UIElement;
if (eventSource == null && input._inputDevice != null)
{
eventSource = input._inputDevice.Target;
}
if (eventSource != null)
{
eventSource.RaiseEvent(input);
}
// Post-Notify the input.
//
this.InputDeviceEvents[devType]._postNotifyInput?.Invoke(this, new NotifyInputEventArgs(item));
// Post-Process the input. This could modify the staging
// area.
this.InputDeviceEvents[devType]._postProcessInput?.Invoke(this, new ProcessInputEventArgs(item));
// PreviewInputReport --> InputReport
if (item.Input._routedEvent == InputManager.PreviewInputReportEvent)
{
if (!item.Input.Handled)
{
var previewInputReport = (InputReportEventArgs)item.Input;
var inputReport = new InputReportEventArgs(previewInputReport.Device, previewInputReport.Report)
{
RoutedEvent = InputManager.InputReportEvent
};
this._currentStagingStack.Push(new StagingAreaInputItem(inputReport, item));
}
}
if (input.Handled)
{
handled = true;
}
}
} while (this._currentStagingStack.Count > 0);
}
}
finally {
// It is possible that we can be re-entered by a nested
// dispatcher frame. Continue processing the staging
// area if we need to.
if (this._stagingArea.Count > 0)
{
// Before we actually start to drain the staging area, we need
// to post a work item to process more input. This enables us
// to process more input if we enter a nested pump.
this.Dispatcher.BeginInvoke(this._continueProcessingStagingAreaCallback, this.Dispatcher.CurrentFrame);
}
this._frameStagingArea.Remove(frame);
}
return(handled);
}
private object ProcessStagingArea(object frame)
{
bool flag1 = false;
try
{
label_21:
if (this._stagingArea.Count > 0)
{
this._currentStagingStack = this._stagingArea.Dequeue() as Stack;
do
{
StagingAreaInputItem stagingAreaInputItem = (StagingAreaInputItem)this._currentStagingStack.Pop();
bool flag2 = false;
int deviceType = (int)stagingAreaInputItem.Input._inputDevice.DeviceType;
if (this.InputDeviceEvents[deviceType]._preProcessInput != null)
{
PreProcessInputEventArgs processInputEventArgs;
this.InputDeviceEvents[deviceType]._preProcessInput((object)this, processInputEventArgs = new PreProcessInputEventArgs(stagingAreaInputItem));
flag2 = processInputEventArgs._canceled;
}
if (!flag2)
{
NotifyInputEventHandler preNotifyInput = this.InputDeviceEvents[deviceType]._preNotifyInput;
if (preNotifyInput != null)
{
preNotifyInput((object)this, new NotifyInputEventArgs(stagingAreaInputItem));
}
InputEventArgs input1 = stagingAreaInputItem.Input;
UIElement uiElement = input1._source as UIElement;
if (uiElement == null && input1._inputDevice != null)
{
uiElement = input1._inputDevice.Target;
}
uiElement?.RaiseEvent((RoutedEventArgs)input1);
NotifyInputEventHandler postNotifyInput = this.InputDeviceEvents[deviceType]._postNotifyInput;
if (postNotifyInput != null)
{
postNotifyInput((object)this, new NotifyInputEventArgs(stagingAreaInputItem));
}
ProcessInputEventHandler postProcessInput = this.InputDeviceEvents[deviceType]._postProcessInput;
if (postProcessInput != null)
{
postProcessInput((object)this, new ProcessInputEventArgs(stagingAreaInputItem));
}
if (stagingAreaInputItem.Input._routedEvent == InputManager.PreviewInputReportEvent && !stagingAreaInputItem.Input.Handled)
{
InputReportEventArgs input2 = (InputReportEventArgs)stagingAreaInputItem.Input;
InputReportEventArgs inputReportEventArgs = new InputReportEventArgs(input2.Device, input2.Report);
inputReportEventArgs.RoutedEvent = InputManager.InputReportEvent;
this._currentStagingStack.Push((object)new StagingAreaInputItem((InputEventArgs)inputReportEventArgs, stagingAreaInputItem));
}
if (input1.Handled)
{
flag1 = true;
}
}
}while (this._currentStagingStack.Count > 0);
goto label_21;
}
}
finally
{
if (this._stagingArea.Count > 0)
{
this.Dispatcher.BeginInvoke(this._continueProcessingStagingAreaCallback, (object)this.Dispatcher.CurrentFrame);
}
this._frameStagingArea.Remove(frame);
}
return((object)flag1);
}
