public static ITextImplementor GetImplementor(Adapter adapter,
IRawElementProviderSimple prov)
{
ITextProvider textProvider
= prov.GetPatternProvider(TextPatternIdentifiers.Pattern.Id)
as ITextProvider;
if (textProvider != null)
{
return(new TextProviderTextImplementor(adapter, textProvider));
}
IValueProvider valueProvider
= prov.GetPatternProvider(ValuePatternIdentifiers.Pattern.Id)
as IValueProvider;
if (valueProvider != null)
{
return(new ValueProviderTextImplementor(adapter, valueProvider));
}
IRangeValueProvider rangeValueProvider
= prov.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id)
as IRangeValueProvider;
if (rangeValueProvider != null)
{
return(new RangeValueProviderTextImplementor(adapter, rangeValueProvider));
}
return(new NamePropertyTextImplementor(adapter, prov));
}
public Slider (IRawElementProviderSimple provider) : base (provider)
{
Role = Atk.Role.Slider;
rangeValueProvider = (IRangeValueProvider)provider.GetPatternProvider (RangeValuePatternIdentifiers.Pattern.Id);
textExpert = TextImplementorFactory.GetImplementor (this, provider);
oldText = textExpert.Text;
}
public SplitContainer(IRawElementProviderSimple provider) : base(provider)
{
Role = Atk.Role.SplitPane;
rangeValueProvider = (IRangeValueProvider)provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
object o = provider.GetPropertyValue(AutomationElementIdentifiers.OrientationProperty.Id);
if (o is OrientationType)
{
orientation = (OrientationType)o;
}
else
{
IDockProvider dockProvider = (IDockProvider)provider.GetPatternProvider(DockPatternIdentifiers.Pattern.Id);
if (dockProvider != null)
{
orientation = (dockProvider.DockPosition == DockPosition.Top || dockProvider.DockPosition == DockPosition.Bottom)?
OrientationType.Horizontal:
OrientationType.Vertical;
}
else
{
Log.Warn("SplitContainer: Couldn't get orientation for splitter. Does not support DockProvider.");
orientation = OrientationType.Horizontal;
}
}
}
public Slider(IRawElementProviderSimple provider) : base(provider)
{
Role = Atk.Role.Slider;
rangeValueProvider = (IRangeValueProvider)provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
textExpert = TextImplementorFactory.GetImplementor(this, provider);
oldText = textExpert.Text;
}
private readonly ITextProvider2 publicITextProvider2; // AccessibleObject as ITextProvider2
/// <summary>
/// Create a new wrapper.
/// </summary>
internal InternalAccessibleObject(AccessibleObject accessibleImplemention)
{
// Get all the casts done here to catch any issues early
publicIAccessible = (IAccessible)accessibleImplemention;
publicIEnumVariant = (Oleaut32.IEnumVariant)accessibleImplemention;
publicIOleWindow = (Ole32.IOleWindow)accessibleImplemention;
publicIReflect = (IReflect)accessibleImplemention;
publicIServiceProvider = (Ole32.IServiceProvider)accessibleImplemention;
publicIAccessibleEx = (IAccessibleEx)accessibleImplemention;
publicIRawElementProviderSimple = (IRawElementProviderSimple)accessibleImplemention;
publicIRawElementProviderFragment = (IRawElementProviderFragment)accessibleImplemention;
publicIRawElementProviderFragmentRoot = (IRawElementProviderFragmentRoot)accessibleImplemention;
publicIInvokeProvider = (IInvokeProvider)accessibleImplemention;
publicIValueProvider = (IValueProvider)accessibleImplemention;
publicIRangeValueProvider = (IRangeValueProvider)accessibleImplemention;
publicIExpandCollapseProvider = (IExpandCollapseProvider)accessibleImplemention;
publicIToggleProvider = (IToggleProvider)accessibleImplemention;
publicITableProvider = (ITableProvider)accessibleImplemention;
publicITableItemProvider = (ITableItemProvider)accessibleImplemention;
publicIGridProvider = (IGridProvider)accessibleImplemention;
publicIGridItemProvider = (IGridItemProvider)accessibleImplemention;
publicILegacyIAccessibleProvider = (ILegacyIAccessibleProvider)accessibleImplemention;
publicISelectionProvider = (ISelectionProvider)accessibleImplemention;
publicISelectionItemProvider = (ISelectionItemProvider)accessibleImplemention;
publicIScrollItemProvider = (IScrollItemProvider)accessibleImplemention;
publicIRawElementProviderHwndOverride = (IRawElementProviderHwndOverride)accessibleImplemention;
publicIMultiViewProvider = (IMultipleViewProvider)accessibleImplemention;
publicITextProvider = (ITextProvider)accessibleImplemention;
publicITextProvider2 = (ITextProvider2)accessibleImplemention;
// Note: Deliberately not holding onto AccessibleObject to enforce all access through the interfaces
}
public void IRangeValueProviderSetValueTest()
{
ProgressBar progressBar = CreateProgressBar();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(progressBar);
IRangeValueProvider rangeValueProvider = (IRangeValueProvider)
provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
Assert.IsNotNull(rangeValueProvider,
"Not returning RangeValuePatternIdentifiers.");
try {
double minValue = progressBar.Minimum - 1;
rangeValueProvider.SetValue(minValue);
Assert.Fail("ArgumentOutOfRangeException not thrown.");
} catch (ArgumentOutOfRangeException) { }
try {
double maxValue = progressBar.Maximum + 1;
rangeValueProvider.SetValue(maxValue);
Assert.Fail("ArgumentOutOfRangeException not thrown.");
} catch (ArgumentOutOfRangeException) { }
double value = 50;
rangeValueProvider.SetValue(value);
Assert.AreEqual(value, progressBar.Value, "SetValue value");
}
public DistinctInputFactory(IRangeValueProvider <T> RangeValueProvider)
{
if (RangeValueProvider == null)
{
throw new ArgumentNullException("RangeValueProvider");
}
this.provider = RangeValueProvider;
}
public TerminalRangeInputCollection(IRangeValueProvider <T> RangeValueProvider)
{
if (RangeValueProvider == null)
{
throw new ArgumentNullException("RangeValueProvider");
}
this.provider = RangeValueProvider;
items = new List <ITerminalRangeInput <T> >();
}
public virtual void NumericUpDownPeerIsIRangeValueProvider()
{
NumericUpDown item = new NumericUpDown();
IRangeValueProvider provider = null;
TestAsync(
item,
() => provider = FrameworkElementAutomationPeer.CreatePeerForElement(item) as IRangeValueProvider,
() => Assert.IsNotNull(provider, "NumericUpDownAutomationPeer should implement IRangeValueProvider!"));
}
private static void HandleRangeValueProperty(ProxySimple el, IntPtr hwnd, int eventId)
{
IRangeValueProvider rangeValue = el.GetPatternProvider(RangeValuePattern.Pattern) as IRangeValueProvider;
if (rangeValue == null)
{
return;
}
RaisePropertyChangedEvent(el, RangeValuePattern.ValueProperty, rangeValue.Value);
}
public Spinner (IRawElementProviderSimple provider) : base (provider)
{
Role = Atk.Role.SpinButton;
rangeValueProvider = (IRangeValueProvider)provider.GetPatternProvider (RangeValuePatternIdentifiers.Pattern.Id);
editableRange
= provider.GetPatternProvider (EditableRangePatternIdentifiers.Pattern.Id) as IEditableRangeProvider;
valueProvider = (IValueProvider)provider.GetPatternProvider (ValuePatternIdentifiers.Pattern.Id);
textExpert = TextImplementorFactory.GetImplementor (this, provider);
oldText = textExpert.Text;
}
public Spinner(IRawElementProviderSimple provider) : base(provider)
{
Role = Atk.Role.SpinButton;
rangeValueProvider = (IRangeValueProvider)provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
editableRange
= provider.GetPatternProvider(EditableRangePatternIdentifiers.Pattern.Id) as IEditableRangeProvider;
valueProvider = (IValueProvider)provider.GetPatternProvider(ValuePatternIdentifiers.Pattern.Id);
textExpert = TextImplementorFactory.GetImplementor(this, provider);
oldText = textExpert.Text;
}
public virtual void NumericUpDownPeerSupportsRangeValue()
{
NumericUpDown item = new NumericUpDown();
NumericUpDownAutomationPeer peer = null;
IRangeValueProvider provider = null;
TestAsync(
item,
() => peer = FrameworkElementAutomationPeer.CreatePeerForElement(item) as NumericUpDownAutomationPeer,
() => provider = peer.GetPattern(PatternInterface.RangeValue) as IRangeValueProvider,
() => Assert.IsNotNull(provider, "IRangeValueProvider peer should not be null!"));
}
public override void TestHasKeyboardFocusAfterPattern()
{
Slider fe = CreateConcreteFrameworkElement() as Slider;
AutomationPeer peer = FrameworkElementAutomationPeer.CreatePeerForElement(fe);
IRangeValueProvider provider = null;
CreateAsyncTest(fe,
() => {
provider = (IRangeValueProvider)peer.GetPattern(PatternInterface.RangeValue);
Assert.IsNotNull(provider, "#0");
},
() => provider.SetValue(.5),
() => Assert.IsFalse(peer.HasKeyboardFocus(), "#1"));
}
public void IRangeValueProviderValueTest()
{
ProgressBar progressBar = CreateProgressBar();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(progressBar);
IRangeValueProvider rangeValueProvider = (IRangeValueProvider)
provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
Assert.IsNotNull(rangeValueProvider,
"Not returning RangeValuePatternIdentifiers.");
double value = (double)progressBar.Value;
Assert.AreEqual(rangeValueProvider.Value, value, "Value value");
}
public void IRangeValueProviderLargeChangeTest()
{
NumericUpDown numericUpDown = new NumericUpDown();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(numericUpDown);
IRangeValueProvider rangeValueProvider = (IRangeValueProvider)
provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
Assert.IsNotNull(rangeValueProvider,
"Not returning RangeValuePatternIdentifiers.");
Assert.AreEqual(double.NaN,
rangeValueProvider.LargeChange,
"LargeChange value");
}
public void IRangeValueProviderIsReadOnlyTest()
{
NumericUpDown numericUpDown = new NumericUpDown();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(numericUpDown);
IRangeValueProvider rangeValueProvider = (IRangeValueProvider)
provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
Assert.IsNotNull(rangeValueProvider,
"Not returning RangeValuePatternIdentifiers.");
Assert.AreEqual(numericUpDown.ReadOnly,
rangeValueProvider.IsReadOnly,
"IsReadOnly value");
}
public void IRangeValueProviderValueTest()
{
TrackBar trackBar = new TrackBar();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(trackBar);
IRangeValueProvider rangeValueProvider = (IRangeValueProvider)
provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
Assert.IsNotNull(rangeValueProvider,
"Not returning RangeValuePatternIdentifiers.");
Assert.AreEqual((double)trackBar.Value,
rangeValueProvider.Value,
"Value value");
}
public void IRangeValueProviderMinimumTest()
{
NumericUpDown numericUpDown = new NumericUpDown();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(numericUpDown);
IRangeValueProvider rangeValueProvider = (IRangeValueProvider)
provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
Assert.IsNotNull(rangeValueProvider,
"Not returning RangeValuePatternIdentifiers.");
Assert.AreEqual((double)numericUpDown.Minimum,
rangeValueProvider.Minimum,
"Minimum value");
}
public void IRangeValueProviderIsReadOnlyTest()
{
TrackBar trackBar = new TrackBar();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(trackBar);
IRangeValueProvider rangeValueProvider = (IRangeValueProvider)
provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
Assert.IsNotNull(rangeValueProvider,
"Not returning RangeValuePatternIdentifiers.");
Assert.AreNotEqual(trackBar.Enabled && trackBar.Visible,
rangeValueProvider.IsReadOnly,
"IsReadOnly value");
}
public void IRangeValueProviderMaximumTest()
{
ProgressBar progressBar = CreateProgressBar();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(progressBar);
IRangeValueProvider rangeValueProvider = (IRangeValueProvider)
provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
Assert.IsNotNull(rangeValueProvider,
"Not returning RangeValuePatternIdentifiers.");
Assert.AreEqual(rangeValueProvider.Maximum,
100.0,
"Maximum value");
}
public void IRangeValueProviderIsReadOnlyTest()
{
ProgressBar progressBar = CreateProgressBar();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(progressBar);
IRangeValueProvider rangeValueProvider = (IRangeValueProvider)
provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
Assert.IsNotNull(rangeValueProvider,
"Not returning RangeValuePatternIdentifiers.");
Assert.AreEqual(rangeValueProvider.IsReadOnly,
true,
"IsReadOnly value");
}
public void IRangeValueProviderSmallChangeTest()
{
ProgressBar progressBar = CreateProgressBar();
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(progressBar);
IRangeValueProvider rangeValueProvider = (IRangeValueProvider)
provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
Assert.IsNotNull(rangeValueProvider,
"Not returning RangeValuePatternIdentifiers.");
Assert.AreEqual(rangeValueProvider.SmallChange,
Double.NaN,
"SmallChange value");
}
public SplitContainer (IRawElementProviderSimple provider) : base (provider)
{
Role = Atk.Role.SplitPane;
rangeValueProvider = (IRangeValueProvider)provider.GetPatternProvider (RangeValuePatternIdentifiers.Pattern.Id);
object o = provider.GetPropertyValue (AutomationElementIdentifiers.OrientationProperty.Id);
if (o is OrientationType)
orientation = (OrientationType)o;
else {
IDockProvider dockProvider = (IDockProvider)provider.GetPatternProvider (DockPatternIdentifiers.Pattern.Id);
if (dockProvider != null) {
orientation = (dockProvider.DockPosition == DockPosition.Top || dockProvider.DockPosition == DockPosition.Bottom)?
OrientationType.Horizontal:
OrientationType.Vertical;
} else {
Log.Warn ("SplitContainer: Couldn't get orientation for splitter. Does not support DockProvider.");
orientation = OrientationType.Horizontal;
}
}
}
public override void TestHasKeyboardFocusAfterPattern()
{
ProgressBar fe = CreateConcreteFrameworkElement() as ProgressBar;
AutomationPeer peer = FrameworkElementAutomationPeer.CreatePeerForElement(fe);
IRangeValueProvider provider = null;
CreateAsyncTest(fe,
() => {
provider = (IRangeValueProvider)peer.GetPattern(PatternInterface.RangeValue);
Assert.IsNotNull(provider, "#0");
},
() => {
Assert.Throws <InvalidOperationException> (() => {
global::System.Console.WriteLine(">>>>>>>>>>>>>>>>>>>provider is {0}", provider.GetType());
provider.SetValue(.5);
});
},
() => Assert.IsFalse(peer.HasKeyboardFocus(), "#1"));
}
public ProgressBar (IRawElementProviderSimple provider) : base (provider)
{
rangeValueProvider = (IRangeValueProvider)provider.GetPatternProvider (RangeValuePatternIdentifiers.Pattern.Id);
Role = Atk.Role.ProgressBar;
}
public RangeValuePatternWrapper (IRangeValueProvider provider)
{
this.provider = provider;
}
public DistinctInputFactory(IRangeValueProvider <Token> RangeValueProvider) : base(RangeValueProvider)
{
}
public void ToggleTest()
{
picker.Format = DateTimePickerFormat.Long;
picker.ShowCheckBox = false;
IRawElementProviderSimple child
= ((IRawElementProviderFragmentRoot)pickerProvider)
.Navigate(NavigateDirection.FirstChild);
IToggleProvider toggleProvider
= child.GetPatternProvider(
TogglePatternIdentifiers.Pattern.Id) as IToggleProvider;
Assert.IsNull(toggleProvider,
"With ShowCheckBox = false, DateTimePicker does not implement IToggleProvider");
picker.ShowCheckBox = true;
// FirstChild changes when ShowCheckBox = true
child = ((IRawElementProviderFragmentRoot)pickerProvider)
.Navigate(NavigateDirection.FirstChild);
TestProperty(child,
AutomationElementIdentifiers.ControlTypeProperty,
ControlType.CheckBox.Id);
toggleProvider = child.GetPatternProvider(
TogglePatternIdentifiers.Pattern.Id) as IToggleProvider;
Assert.IsNotNull(toggleProvider,
"With ShowCheckBox = true, DateTimePicker does not implement IToggleProvider");
picker.Checked = false;
Assert.AreEqual(ToggleState.Off, toggleProvider.ToggleState,
"With Checked = false, toggleProvider is not returning ToggleState.Off");
picker.Checked = true;
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState,
"With Checked = true, toggleProvider is not returning ToggleState.On");
toggleProvider.Toggle();
Assert.IsFalse(picker.Checked, "After toggling off, Checked is still true");
Assert.AreEqual(ToggleState.Off, toggleProvider.ToggleState,
"After toggling off, toggleProvider is not returning ToggleState.Off");
// Verify that parts aren't enabled
for (int i = 0; i < 6; i++)
{
child = ((IRawElementProviderFragment)child).Navigate(
NavigateDirection.NextSibling);
}
TestProperty(child, AutomationElementIdentifiers.ControlTypeProperty,
ControlType.Spinner.Id);
TestProperty(child, AutomationElementIdentifiers.IsEnabledProperty,
false);
IRangeValueProvider rangeValueProvider = child.GetPatternProvider(
RangeValuePatternIdentifiers.Pattern.Id) as IRangeValueProvider;
bool gotException = false;
try {
rangeValueProvider.SetValue(1);
} catch (ElementNotEnabledException) {
gotException = true;
}
if (!gotException)
{
Assert.Fail("Able to set RangeValue's value when picker is disabled");
}
toggleProvider.Toggle();
Assert.IsTrue(picker.Checked, "After toggling on, Checked is still false");
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState,
"After toggling on, toggleProvider is not returning ToggleState.On");
}
public void RangeValueTest()
{
// This format should have 8 parts
picker.Format = DateTimePickerFormat.Long;
picker.ShowUpDown = false;
picker.Value = awesome;
double[] awesome_values = new double[] {
-1, -1, -1, -1, -1, 20, -1, -1, 2009
};
double[] awesome_min_values = new double[] {
-1, -1, -1, -1, -1, 1, -1, -1, 1753
};
double[] awesome_max_values = new double[] {
-1, -1, -1, -1, -1, 31, -1, -1, 9998
};
double[] set_value_value = new double[] {
-1, -1, -1, -1, -1, 30, -1, -1, 2007
};
IRawElementProviderSimple child
= ((IRawElementProviderFragmentRoot)pickerProvider)
.Navigate(NavigateDirection.FirstChild);
int i = 0;
do
{
if (long_pattern_part_type[i] == PartType.Spinner)
{
TestProperty(child,
AutomationElementIdentifiers.ControlTypeProperty,
ControlType.Spinner.Id);
IRangeValueProvider rangeValueProvider
= child.GetPatternProvider(
RangeValuePatternIdentifiers.Pattern.Id)
as IRangeValueProvider;
Assert.IsNotNull(rangeValueProvider,
"Spinner control does not implement RangeValue");
Assert.AreEqual(awesome_values[i], rangeValueProvider.Value,
"Value returned by RangeValue is incorrect");
Assert.AreEqual(awesome_min_values[i], rangeValueProvider.Minimum,
"Minimum returned by RangeValue is incorrect");
Assert.AreEqual(awesome_max_values[i], rangeValueProvider.Maximum,
"Maximum returned by RangeValue is incorrect");
bridge.ResetEventLists();
rangeValueProvider.SetValue(set_value_value[i]);
Assert.AreEqual(set_value_value[i], rangeValueProvider.Value,
"After setting, Value returned by RangeValue is incorrect");
Assert.AreEqual(1, bridge.GetAutomationPropertyEventCount(
RangeValuePatternIdentifiers.ValueProperty), "Event count");
Assert.AreEqual(3, bridge.GetAutomationPropertyEventCount(
AutomationElementIdentifiers.NameProperty),
"NameProperty Event count");
rangeValueProvider.SetValue(awesome_values[i]);
picker.ShowCheckBox = true;
picker.Checked = true;
Assert.IsFalse(rangeValueProvider.IsReadOnly,
"RangeValue is read only when Checked = true and ShowCheckBox = true");
bridge.ResetEventLists();
picker.Checked = false;
// Two events are generated because there are 2 active spinner parts
Assert.AreEqual(2, bridge.GetAutomationPropertyEventCount(
RangeValuePatternIdentifiers.IsReadOnlyProperty), "Event count");
Assert.IsTrue(rangeValueProvider.IsReadOnly,
"RangeValue is not read only when Checked = false and ShowCheckBox = true");
picker.ShowCheckBox = false;
Assert.IsFalse(rangeValueProvider.IsReadOnly,
"RangeValue is read only when ShowCheckBox = false");
}
i++;
child = ((IRawElementProviderFragment)child)
.Navigate(NavigateDirection.NextSibling);
} while (child != null && i < long_pattern_num_parts);
}
public ScrollBar (IRawElementProviderSimple provider) : base (provider)
{
Role = Atk.Role.ScrollBar;
rangeValueProvider = (IRangeValueProvider)provider.GetPatternProvider (RangeValuePatternIdentifiers.Pattern.Id);
orientation = (OrientationType)provider.GetPropertyValue (AutomationElementIdentifiers.OrientationProperty.Id);
}
public RangeValueProviderTextImplementor (Adapter resource, IRangeValueProvider rangeValueProvider)
: base (resource)
{
this.rangeValueProvider = rangeValueProvider;
}
public RangeValuePatternWrapper(IRangeValueProvider provider)
{
this.provider = provider;
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
private RangeValueProviderWrapper(AutomationPeer peer, IRangeValueProvider iface)
{
_peer = peer;
_iface = iface;
}
public void RangeValueProvider_Events()
{
if (!EventsManager.Instance.AutomationSingletonExists)
{
return;
}
RangeBaseConcrete rangeBase = new RangeBaseConcrete();
AutomationPeer peer = FrameworkElementAutomationPeer.CreatePeerForElement(rangeBase);
IRangeValueProvider provider
= (IRangeValueProvider)peer.GetPattern(PatternInterface.RangeValue);
Assert.IsNotNull(provider, "GetPattern #0");
provider.SetValue(0); // Setting old value
EventsManager.Instance.Reset();
AutomationPropertyEventTuple tuple
= EventsManager.Instance.GetAutomationEventFrom(peer, RangeValuePatternIdentifiers.ValueProperty);
Assert.IsNull(tuple, "GetAutomationEventFrom #0");
provider.SetValue(0.9);
tuple = EventsManager.Instance.GetAutomationEventFrom(peer, RangeValuePatternIdentifiers.ValueProperty);
Assert.IsNotNull(tuple, "GetAutomationEventFrom #1");
Assert.AreEqual((double)tuple.OldValue, 0, "OldValue #1");
Assert.AreEqual((double)tuple.NewValue, 0.9, "NewValue #1");
EventsManager.Instance.Reset();
provider.SetValue(0.5);
tuple = EventsManager.Instance.GetAutomationEventFrom(peer, RangeValuePatternIdentifiers.ValueProperty);
Assert.IsNotNull(tuple, "GetAutomationEventFrom #2");
Assert.AreEqual((double)tuple.OldValue, 0.9, "OldValue #2");
Assert.AreEqual((double)tuple.NewValue, 0.5, "NewValue #2");
EventsManager.Instance.Reset();
tuple = EventsManager.Instance.GetAutomationEventFrom(peer, RangeValuePatternIdentifiers.IsReadOnlyProperty);
Assert.IsNull(tuple, "GetAutomationEventFrom #3");
rangeBase.IsEnabled = false;
tuple = EventsManager.Instance.GetAutomationEventFrom(peer, RangeValuePatternIdentifiers.IsReadOnlyProperty);
Assert.IsNotNull(tuple, "GetAutomationEventFrom #4");
Assert.IsTrue((bool)tuple.OldValue, "OldValue #4");
Assert.IsFalse((bool)tuple.NewValue, "NewValue #4");
EventsManager.Instance.Reset();
rangeBase.IsEnabled = true;
tuple = EventsManager.Instance.GetAutomationEventFrom(peer, RangeValuePatternIdentifiers.IsReadOnlyProperty);
Assert.IsNotNull(tuple, "GetAutomationEventFrom #5");
Assert.IsFalse((bool)tuple.OldValue, "OldValue #5");
Assert.IsTrue((bool)tuple.NewValue, "NewValue #5");
EventsManager.Instance.Reset();
rangeBase.Maximum = 10.0;
tuple = EventsManager.Instance.GetAutomationEventFrom(peer, RangeValuePatternIdentifiers.MaximumProperty);
Assert.IsNotNull(tuple, "GetAutomationEventFrom #6");
Assert.AreEqual(1d, (double)tuple.OldValue, "OldValue #6");
Assert.AreEqual(10d, (double)tuple.NewValue, "NewValue #6");
EventsManager.Instance.Reset();
rangeBase.Minimum = 5.0;
tuple = EventsManager.Instance.GetAutomationEventFrom(peer, RangeValuePatternIdentifiers.MinimumProperty);
Assert.IsNotNull(tuple, "GetAutomationEventFrom #7");
Assert.AreEqual(0d, (double)tuple.OldValue, "OldValue #7");
Assert.AreEqual(5d, (double)tuple.NewValue, "NewValue #7");
EventsManager.Instance.Reset();
rangeBase.LargeChange = 2.0;
tuple = EventsManager.Instance.GetAutomationEventFrom(peer, RangeValuePatternIdentifiers.LargeChangeProperty);
Assert.IsNotNull(tuple, "GetAutomationEventFrom #8");
Assert.AreEqual(1d, (double)tuple.OldValue, "OldValue #8");
Assert.AreEqual(2d, (double)tuple.NewValue, "NewValue #8");
EventsManager.Instance.Reset();
rangeBase.SmallChange = 1.0;
tuple = EventsManager.Instance.GetAutomationEventFrom(peer, RangeValuePatternIdentifiers.SmallChangeProperty);
Assert.IsNotNull(tuple, "GetAutomationEventFrom #9");
Assert.AreEqual(0.1d, (double)tuple.OldValue, "OldValue #9");
Assert.AreEqual(1d, (double)tuple.NewValue, "NewValue #9");
}
public RangeValueProviderTextImplementor(Adapter resource, IRangeValueProvider rangeValueProvider)
: base(resource)
{
this.rangeValueProvider = rangeValueProvider;
}
public ProgressBar(IRawElementProviderSimple provider) : base(provider)
{
rangeValueProvider = (IRangeValueProvider)provider.GetPatternProvider(RangeValuePatternIdentifiers.Pattern.Id);
Role = Atk.Role.ProgressBar;
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
private RangeValueProviderWrapper( AutomationPeer peer, IRangeValueProvider iface )
{
_peer = peer;
_iface = iface;
}
