internal static SynchronizedInputType GetPairedInputType(SynchronizedInputType inputType)
{
SynchronizedInputType pairedInputType = SynchronizedInputType.KeyDown;
switch (inputType)
{
case SynchronizedInputType.KeyDown:
pairedInputType = SynchronizedInputType.KeyUp;
break;
case SynchronizedInputType.KeyUp:
pairedInputType = SynchronizedInputType.KeyDown;
break;
case SynchronizedInputType.MouseLeftButtonDown:
pairedInputType = SynchronizedInputType.MouseLeftButtonUp;
break;
case SynchronizedInputType.MouseLeftButtonUp:
pairedInputType = SynchronizedInputType.MouseLeftButtonDown;
break;
case SynchronizedInputType.MouseRightButtonDown:
pairedInputType = SynchronizedInputType.MouseRightButtonUp;
break;
case SynchronizedInputType.MouseRightButtonUp:
pairedInputType = SynchronizedInputType.MouseRightButtonDown;
break;
}
return pairedInputType;
}
/// <summary>
/// This method is called by automation framework to trigger synchronized input processing.
/// </summary>
/// <param name="inputType"> Synchronized input type</param>
void ISynchronizedInputProvider.StartListening(SynchronizedInputType inputType)
{
UIElement e = _owner as UIElement;
if (e != null)
{
if (!e.StartListeningSynchronizedInput(inputType))
{
throw new InvalidOperationException(SR.Get(SRID.Automation_RecursivePublicCall));
}
}
else
{
ContentElement ce = _owner as ContentElement;
if (ce != null)
{
if (!ce.StartListeningSynchronizedInput(inputType))
{
throw new InvalidOperationException(SR.Get(SRID.Automation_RecursivePublicCall));
}
}
else
{
UIElement3D e3D = (UIElement3D)_owner;
if (!e3D.StartListeningSynchronizedInput(inputType))
{
throw new InvalidOperationException(SR.Get(SRID.Automation_RecursivePublicCall));
}
}
}
}
public void StartListening(SynchronizedInputType type)
{
try
{
this._pattern.StartListening((UIAutomationClient.SynchronizedInputType)type);
}
catch (System.Runtime.InteropServices.COMException e)
{
Exception newEx; if (Utility.ConvertException(e, out newEx)) { throw newEx; } else { throw; }
}
}
// When called, InputManager will get into synchronized input processing mode.
internal static bool StartListeningSynchronizedInput(DependencyObject d, SynchronizedInputType inputType)
{
lock (_synchronizedInputLock)
{
if (_isSynchronizedInput)
{
return(false);
}
else
{
_isSynchronizedInput = true;
_synchronizedInputState = SynchronizedInputStates.NoOpportunity;
_listeningElement = d;
_synchronizedInputType = inputType;
_synchronizedInputEvents = SynchronizedInputHelper.MapInputTypeToRoutedEvents(inputType);
_pairedSynchronizedInputEvents = SynchronizedInputHelper.MapInputTypeToRoutedEvents(SynchronizedInputHelper.GetPairedInputType(inputType));
return(true);
}
}
}
/// <summary>
/// This method is called by automation framework to trigger synchronized input processing.
/// </summary>
/// <param name="inputType"> Synchronized input type</param>
void ISynchronizedInputProvider.StartListening(SynchronizedInputType inputType)
{
if (inputType != SynchronizedInputType.KeyDown &&
inputType != SynchronizedInputType.KeyUp &&
inputType != SynchronizedInputType.MouseLeftButtonDown &&
inputType != SynchronizedInputType.MouseLeftButtonUp &&
inputType != SynchronizedInputType.MouseRightButtonDown &&
inputType != SynchronizedInputType.MouseRightButtonUp)
{
throw new ArgumentException(SR.Get(SRID.Automation_InvalidSynchronizedInputType, inputType));
}
UIElement e = _owner as UIElement;
if (e != null)
{
if (!e.StartListeningSynchronizedInput(inputType))
{
throw new InvalidOperationException(SR.Get(SRID.Automation_RecursivePublicCall));
}
}
else
{
ContentElement ce = _owner as ContentElement;
if (ce != null)
{
if (!ce.StartListeningSynchronizedInput(inputType))
{
throw new InvalidOperationException(SR.Get(SRID.Automation_RecursivePublicCall));
}
}
else
{
UIElement3D e3D = (UIElement3D)_owner;
if (!e3D.StartListeningSynchronizedInput(inputType))
{
throw new InvalidOperationException(SR.Get(SRID.Automation_RecursivePublicCall));
}
}
}
}
/// <summary>
/// This method is called by automation framework to trigger synchronized input processing.
/// </summary>
/// <param name="inputType"> Synchronized input type</param>
void ISynchronizedInputProvider.StartListening(SynchronizedInputType inputType)
{
if (inputType != SynchronizedInputType.KeyDown &&
inputType != SynchronizedInputType.KeyUp &&
inputType != SynchronizedInputType.MouseLeftButtonDown &&
inputType != SynchronizedInputType.MouseLeftButtonUp &&
inputType != SynchronizedInputType.MouseRightButtonDown &&
inputType != SynchronizedInputType.MouseRightButtonUp)
{
throw new ArgumentException(SR.Get(SRID.Automation_InvalidSynchronizedInputType, inputType));
}
UIElement e = _owner as UIElement;
if (e != null)
{
if (!e.StartListeningSynchronizedInput(inputType))
{
throw new InvalidOperationException(SR.Get(SRID.Automation_RecursivePublicCall));
}
}
else
{
ContentElement ce = _owner as ContentElement;
if (ce != null)
{
if (!ce.StartListeningSynchronizedInput(inputType))
{
throw new InvalidOperationException(SR.Get(SRID.Automation_RecursivePublicCall));
}
}
else
{
UIElement3D e3D = (UIElement3D)_owner;
if (!e3D.StartListeningSynchronizedInput(inputType))
{
throw new InvalidOperationException(SR.Get(SRID.Automation_RecursivePublicCall));
}
}
}
}
public override void StartListening(SynchronizedInputType inputType)
{
Com.Call(() => this.NativePattern.StartListening((Interop.UIAutomationClient.SynchronizedInputType)inputType));
}
// Map a Synchronized input type received from automation client to routed event
internal static RoutedEvent MapInputTypeToRoutedEvent(SynchronizedInputType inputType)
{
RoutedEvent e = null;
switch (inputType)
{
case SynchronizedInputType.KeyUp:
e = Keyboard.KeyUpEvent;
break;
case SynchronizedInputType.KeyDown:
e = Keyboard.KeyDownEvent;
break;
case SynchronizedInputType.MouseLeftButtonDown:
case SynchronizedInputType.MouseRightButtonDown:
e = Mouse.MouseDownEvent;
break;
case SynchronizedInputType.MouseLeftButtonUp:
case SynchronizedInputType.MouseRightButtonUp:
e = Mouse.MouseUpEvent;
break;
default:
Debug.Assert(false);
e = null;
break;
}
return e;
}
//------------------------------------------------------
//
// Interface ISynchronizedInputProvider
//
//------------------------------------------------------
#region Interface ISynchronizedInputProvider
public void StartListening(SynchronizedInputType inputType)
{
ElementUtil.Invoke( _peer, new DispatcherOperationCallback( StartListening ), inputType );
}
public void StartListening(SynchronizedInputType inputType)
{
this.Pattern.StartListening(inputType);
}
public override void StartListening(SynchronizedInputType inputType)
{
NativePattern.StartListening((UIA.SynchronizedInputType)inputType);
}
public abstract void StartListening(SynchronizedInputType inputType);
// When called, InputManager will get into synchronized input processing mode.
internal static bool StartListeningSynchronizedInput(DependencyObject d, SynchronizedInputType inputType)
{
lock (_synchronizedInputLock)
{
if (_isSynchronizedInput)
{
return false;
}
else
{
_isSynchronizedInput = true;
_synchronizedInputState = SynchronizedInputStates.NoOpportunity;
_listeningElement = d;
_synchronizedInputType = inputType;
_synchronizedInputEvents = SynchronizedInputHelper.MapInputTypeToRoutedEvents(inputType);
_pairedSynchronizedInputEvents = SynchronizedInputHelper.MapInputTypeToRoutedEvents(SynchronizedInputHelper.GetPairedInputType(inputType));
return true;
}
}
}
//------------------------------------------------------
//
// Interface ISynchronizedInputProvider
//
//------------------------------------------------------
#region Interface ISynchronizedInputProvider
public void StartListening(SynchronizedInputType inputType)
{
ElementUtil.Invoke(_peer, new DispatcherOperationCallback(StartListening), inputType);
}
// Map a Synchronized input type received from automation client to routed event
internal static RoutedEvent[] MapInputTypeToRoutedEvents(SynchronizedInputType inputType)
{
RoutedEvent[] e = null;
switch (inputType)
{
case SynchronizedInputType.KeyUp:
e = new RoutedEvent[] {Keyboard.KeyUpEvent};
break;
case SynchronizedInputType.KeyDown:
e = new RoutedEvent[] {Keyboard.KeyDownEvent, TextCompositionManager.TextInputEvent};
break;
case SynchronizedInputType.MouseLeftButtonDown:
case SynchronizedInputType.MouseRightButtonDown:
e = new RoutedEvent[] {Mouse.MouseDownEvent};
break;
case SynchronizedInputType.MouseLeftButtonUp:
case SynchronizedInputType.MouseRightButtonUp:
e = new RoutedEvent[] {Mouse.MouseUpEvent};
break;
default:
Debug.Assert(false);
e = null;
break;
}
return e;
}
//------------------------------------------------------
//
// Public Methods
//
//------------------------------------------------------
#region Public Methods
/// <summary>
/// The client calls this method to indicate the current element should start listening
/// for input event of the given type.
/// </summary>
public void StartListening(SynchronizedInputType inputType)
{
UiaCoreApi.SynchronizedInputPattern_StartListening(_hPattern, inputType);
}
// Called by automation peer, when called this element will be the listening element for synchronized input.
internal bool StartListeningSynchronizedInput(SynchronizedInputType inputType)
{
if (InputManager.IsSynchronizedInput)
{
return false;
}
else
{
InputManager.StartListeningSynchronizedInput(this, inputType);
return true;
}
}
public override void StartListening(SynchronizedInputType inputType)
{
ComCallWrapper.Call(() => NativePattern.StartListening((UIA.SynchronizedInputType)inputType));
}
//------------------------------------------------------
//
// Public Methods
//
//------------------------------------------------------
#region Public Methods
/// <summary>
/// The client calls this method to indicate the current element should start listening
/// for input event of the given type.
/// </summary>
public void StartListening(SynchronizedInputType inputType)
{
UiaCoreApi.SynchronizedInputPattern_StartListening(_hPattern,inputType);
}
