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 bool SetCurrentValue(GLib.Value value)
{
double v = (double)value.Val;
if (rangeValueProvider != null)
{
if (v > rangeValueProvider.Maximum)
{
return(false);
}
if (v < rangeValueProvider.Minimum)
{
v = rangeValueProvider.Minimum;
}
try {
rangeValueProvider.SetValue(v);
} catch (ArgumentOutOfRangeException e) {
Log.Debug(e);
return(false);
} catch (ElementNotEnabledException e) {
Log.Debug(e);
return(false);
}
return(true);
}
return(false);
}
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 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 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);
}
void IRangeValueProvider.SetValue(double newValue) => publicIRangeValueProvider.SetValue(newValue);
public void SetValue(double value)
{
provider.SetValue(value);
}
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 bool SetCurrentValue(GLib.Value value)
{
double v = (double)value.Val;
if (rangeValueProvider != null)
{
if (v > rangeValueProvider.Maximum)
{
return(false);
}
if (v < rangeValueProvider.Minimum)
{
v = rangeValueProvider.Minimum;
}
try {
rangeValueProvider.SetValue(v);
} catch (ArgumentOutOfRangeException e) {
Log.Debug(e);
return(false);
} catch (ElementNotEnabledException e) {
Log.Debug(e);
return(false);
}
return(true);
}
if (parentScrollProvider == null)
{
GetScrollProviderFromParent();
}
//TODO: This double validation will be removed in future versions because
//if your SWF.ScrollBar.Parent doesn't support IScrollProvider then your
//ScrollBar is not ScrollBar is Pane!!
if (parentScrollProvider == null)
{
return(false);
}
if (orientation == OrientationType.Vertical)
{
try {
parentScrollProvider.SetScrollPercent(parentScrollProvider.HorizontalScrollPercent, v);
} catch (ArgumentOutOfRangeException e) {
Log.Debug(e);
return(false);
}
}
else
{
try {
parentScrollProvider.SetScrollPercent(v, parentScrollProvider.VerticalScrollPercent);
} catch (ArgumentOutOfRangeException e) {
Log.Debug(e);
return(false);
}
}
return(true);
}