public ListItem(IRawElementProviderSimple provider) : base(provider)
{
invokeProvider = (IInvokeProvider)provider.GetPatternProvider(InvokePatternIdentifiers.Pattern.Id);
selectionItemProvider = (ISelectionItemProvider)provider.GetPatternProvider(SelectionItemPatternIdentifiers.Pattern.Id);
if (selectionItemProvider == null)
{
throw new ArgumentException("ListItem should always implement ISelectionItemProvider");
}
toggleProvider = (IToggleProvider)provider.GetPatternProvider(TogglePatternIdentifiers.Pattern.Id);
textExpert = TextImplementorFactory.GetImplementor(this, provider);
imageExpert = new ImageImplementorHelper(this);
actionExpert = new ActionImplementorHelper();
editableTextExpert = new EditableTextImplementorHelper(this, this, textExpert);
// TODO: Localize the name?s
actionExpert.Add("click", "click", null, DoClick);
if (toggleProvider != null)
{
actionExpert.Add("toggle", "toggle", null, DoToggle);
}
if (invokeProvider != null)
{
actionExpert.Add("invoke", "invoke", null, DoInvoke);
}
Role = (toggleProvider != null? Atk.Role.CheckBox: Atk.Role.ListItem);
}
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 ToggleTest()
{
CheckBox checkbox = new CheckBox();
IRawElementProviderSimple provider = ProviderFactory.GetProvider(checkbox);
IToggleProvider toggleProvider = (IToggleProvider)
provider.GetPatternProvider(TogglePatternIdentifiers.Pattern.Id);
// Test two-state toggling
Assert.AreEqual(CheckState.Unchecked, checkbox.CheckState, "Start two-state Unchecked");
TestToggleEventWithToggle(toggleProvider, ToggleState.On);
Assert.AreEqual(CheckState.Checked, checkbox.CheckState, "First two-state toggle: Checked");
TestToggleEventWithToggle(toggleProvider, ToggleState.Off);
Assert.AreEqual(CheckState.Unchecked, checkbox.CheckState, "Second two-state toggle: Unchecked");
TestToggleEventWithToggle(toggleProvider, ToggleState.On);
Assert.AreEqual(CheckState.Checked, checkbox.CheckState, "Third two-state toggle: Checked");
checkbox.ThreeState = true;
// Test three-state toggling
Assert.AreEqual(CheckState.Checked, checkbox.CheckState, "Start three-state Checked");
TestToggleEventWithToggle(toggleProvider, ToggleState.Off);
Assert.AreEqual(CheckState.Unchecked, checkbox.CheckState, "First three-state toggle: Unchecked");
TestToggleEventWithToggle(toggleProvider, ToggleState.Indeterminate);
Assert.AreEqual(CheckState.Indeterminate, checkbox.CheckState, "Second three-state toggle: Intermediate");
TestToggleEventWithToggle(toggleProvider, ToggleState.On);
Assert.AreEqual(CheckState.Checked, checkbox.CheckState, "Third three-state toggle: Checked");
checkbox.Enabled = false;
// Test that an exception is thrown when not enabled
try {
toggleProvider.Toggle();
Assert.Fail("Should throw ElementNotEnabledException");
} catch (ElementNotEnabledException) { }
}
public RecoverabilityIntegrityReportReaderFactory(
IToggleProvider toggleProvider,
IConnectionFactory connectionFactory)
{
this.toggleProvider = toggleProvider;
this.connectionFactory = connectionFactory;
}
private void TestToggleEventWithToggle(IToggleProvider provider,
ToggleState expectedState)
{
bridge.ResetEventLists();
object oldState = provider.ToggleState;
provider.Toggle();
// Test IToggleProvider.ToggleState
Assert.AreEqual(expectedState, provider.ToggleState, "ToggleState");
// Test event was fired as expected
Assert.AreEqual(1,
bridge.AutomationPropertyChangedEvents.Count,
"event count");
AutomationPropertyChangedEventArgs eventArgs =
bridge.AutomationPropertyChangedEvents [0].e;
Assert.AreEqual(TogglePatternIdentifiers.ToggleStateProperty,
eventArgs.Property,
"event args property");
Assert.AreEqual(oldState,
eventArgs.OldValue,
"old value");
Assert.AreEqual(expectedState,
eventArgs.NewValue,
"new value");
}
internal override object GetElementProperty(AutomationProperty propertyId)
{
if (propertyId == AutomationElement.ClickablePointProperty)
{
// Special case ClickablePoint - for details view, we need to
// return a point on the first item. (The default impl in proxy simple
// excludes the children when looking for a point.)
NativeMethods.Win32Point clickPoint;
if (GetListviewitemClickablePoint(out clickPoint))
{
return(new double[] { clickPoint.x, clickPoint.y });
}
}
// EventManager.DispatchEvent() genericaly uses GetElementProperty()
// to get properties during a property change event. Proccess ToggleStateProperty
// so the ToggleStateProperty Change Event can get the correct state.
else if (propertyId == TogglePattern.ToggleStateProperty &&
IsItemWithCheckbox(_hwnd, _item))
{
IToggleProvider listViewItemCheckbox =
(IToggleProvider)CreateListViewItemCheckbox();
if (listViewItemCheckbox != null)
{
return(listViewItemCheckbox.ToggleState);
}
}
return(base.GetElementProperty(propertyId));
}
public MenuItem(IRawElementProviderSimple provider) : base(provider)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
if ((provider as IRawElementProviderFragment) == null)
{
throw new ArgumentException("Provider for ParentMenu should be IRawElementProviderFragment");
}
textExpert = TextImplementorFactory.GetImplementor(this, provider);
Role = Atk.Role.MenuItem;
string name = (string)provider.GetPropertyValue(AutomationElementIdentifiers.NameProperty.Id);
if (!String.IsNullOrEmpty(name))
{
Name = name;
}
invokeProvider = (IInvokeProvider)
provider.GetPatternProvider(InvokePatternIdentifiers.Pattern.Id);
toggleProvider = (IToggleProvider)
provider.GetPatternProvider(TogglePatternIdentifiers.Pattern.Id);
selectionItemProvider = (ISelectionItemProvider)
provider.GetPatternProvider(SelectionItemPatternIdentifiers.Pattern.Id);
expandCollapseProvider = (IExpandCollapseProvider)
provider.GetPatternProvider(ExpandCollapsePatternIdentifiers.Pattern.Id);
actionExpert.Add("click", "click", null, DoClick);
}
public MenuItem (IRawElementProviderSimple provider) : base (provider)
{
if (provider == null)
throw new ArgumentNullException ("provider");
if ((provider as IRawElementProviderFragment) == null)
throw new ArgumentException ("Provider for ParentMenu should be IRawElementProviderFragment");
textExpert = TextImplementorFactory.GetImplementor (this, provider);
Role = Atk.Role.MenuItem;
string name = (string) provider.GetPropertyValue (AutomationElementIdentifiers.NameProperty.Id);
if (!String.IsNullOrEmpty (name))
Name = name;
invokeProvider = (IInvokeProvider)
provider.GetPatternProvider (InvokePatternIdentifiers.Pattern.Id);
toggleProvider = (IToggleProvider)
provider.GetPatternProvider (TogglePatternIdentifiers.Pattern.Id);
selectionItemProvider = (ISelectionItemProvider)
provider.GetPatternProvider (SelectionItemPatternIdentifiers.Pattern.Id);
expandCollapseProvider = (IExpandCollapseProvider)
provider.GetPatternProvider (ExpandCollapsePatternIdentifiers.Pattern.Id);
actionExpert.Add ("click", "click", null, DoClick);
}
public virtual void ToggleProvider_Toggle()
{
ToggleButton toggleButton = CreateConcreteFrameworkElement() as ToggleButton;
FrameworkElementAutomationPeerContract feap
= CreateConcreteFrameworkElementAutomationPeer(toggleButton);
toggleButton.IsEnabled = false;
IToggleProvider toggleProvider = feap as IToggleProvider;
try {
toggleProvider.Toggle();
Assert.Fail("Should throw ElementNotEnabledException");
} catch (ElementNotEnabledException) { }
toggleButton.IsEnabled = true;
// TODO: Test eventing
// Test two-state toggling
toggleButton.IsThreeState = false;
toggleButton.IsChecked = false;
Assert.AreEqual(ToggleState.Off, toggleProvider.ToggleState,
"Start two-state toggle: Unchecked");
toggleProvider.Toggle();
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState,
"First two-state toggle: Checked");
toggleProvider.Toggle();
Assert.AreEqual(ToggleState.Off, toggleProvider.ToggleState,
"Second two-state toggle: Unchecked");
toggleProvider.Toggle();
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState,
"Third two-state toggle: Checked");
// Test three-state toggling
toggleButton.IsThreeState = true;
toggleButton.IsChecked = true;
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState,
"Start three-state Checked");
toggleProvider.Toggle();
Assert.AreEqual(ToggleState.Indeterminate, toggleProvider.ToggleState,
"First three-state toggle: Indeterminate");
toggleProvider.Toggle();
Assert.AreEqual(ToggleState.Off, toggleProvider.ToggleState,
"Second three-state Off: Intermediate");
toggleProvider.Toggle();
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState,
"Third three-state toggle: Checked");
}
public void ToggleTextBoxVisibility(bool visible)
{
if (btnToggle.IsChecked == visible && IsBreadcrumbEnabled)
{
ToggleButtonAutomationPeer bap = new ToggleButtonAutomationPeer(btnToggle);
IToggleProvider iip = bap.GetPattern(PatternInterface.Toggle) as IToggleProvider;
iip.Toggle();
}
}
internal TogglePattern (IToggleProvider source, AutomationElement element, bool cached)
{
this.element = element;
this.cached = cached;
this.Source = source;
currentInfo = new TogglePatternInformation (this, false);
if (cached)
cachedInfo = new TogglePatternInformation (this, true);
}
public CheckBoxButton (IRawElementProviderSimple provider) : base (provider)
{
toggleProvider = (IToggleProvider) provider.GetPatternProvider (TogglePatternIdentifiers.Pattern.Id);
imageImplementor = new ImageImplementorHelper (this);
if (toggleProvider == null)
throw new ArgumentException ("The provider for CheckBox should implement the Toggle pattern");
Role = Atk.Role.CheckBox;
}
protected override Atk.StateSet OnRefStateSet()
{
Atk.StateSet states = base.OnRefStateSet();
if (states.ContainsState(Atk.StateType.Defunct))
{
return(states);
}
states.AddState(Atk.StateType.Transient);
states.AddState(Atk.StateType.SingleLine);
if (selectionItemProvider != null)
{
states.AddState(Atk.StateType.Selectable);
if (selectionItemProvider.IsSelected)
{
states.AddState(Atk.StateType.Selected);
}
}
IToggleProvider toggleProvider = ToggleProvider;
if (toggleProvider != null)
{
ToggleState state = toggleProvider.ToggleState;
if (state == ToggleState.On)
{
states.AddState(Atk.StateType.Checked);
}
else
{
states.RemoveState(Atk.StateType.Checked);
}
}
if (expandCollapseProvider != null)
{
ExpandCollapseState expandCollapseState
= (ExpandCollapseState)Provider.GetPropertyValue(
ExpandCollapsePatternIdentifiers.ExpandCollapseStateProperty.Id);
if (expandCollapseState != ExpandCollapseState.LeafNode)
{
states.AddState(Atk.StateType.Expandable);
}
if (expandCollapseState == ExpandCollapseState.Expanded)
{
states.AddState(Atk.StateType.Expanded);
}
}
editableTextExpert.UpdateStates(states);
return(states);
}
public ToggleButton(IRawElementProviderSimple provider) : base(provider)
{
toggleProvider = (IToggleProvider)provider.GetPatternProvider(TogglePatternIdentifiers.Pattern.Id);
imageImplementor = new ImageImplementorHelper(this);
if (toggleProvider == null)
{
throw new ArgumentException("The provider for ToggleButton should implement the Toggle pattern");
}
Role = Atk.Role.ToggleButton;
}
private static void HandleToggleStateProperty(ProxySimple el, IntPtr hwnd, int eventId)
{
IToggleProvider toggle = el.GetPatternProvider(TogglePattern.Pattern) as IToggleProvider;
if (toggle == null)
{
return;
}
RaisePropertyChangedEvent(el, TogglePattern.ToggleStateProperty, toggle.ToggleState);
}
internal TogglePattern(IToggleProvider source, AutomationElement element, bool cached)
{
this.element = element;
this.cached = cached;
this.Source = source;
currentInfo = new TogglePatternInformation(this, false);
if (cached)
{
cachedInfo = new TogglePatternInformation(this, true);
}
}
public void SetValuesWithAutomationPeers()
{
DataClass dataClass = null;
IInvokeProvider invokeProvider;
this.EnqueueCallback(() =>
{
dataClass = DataClassList.GetDataClassList(1, ListOperations.All)[0];
this.DataForm.CurrentItem = dataClass;
});
this.AddToPanelAndWaitForLoad();
this.EnqueueCallback(() =>
{
this.GetAutomationPeer();
this.GetChildAutomationPeers();
Assert.AreEqual(true, dataClass.BoolProperty);
Assert.AreEqual("test string 0", dataClass.StringProperty);
invokeProvider = this._editButtonAutomationPeer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
this.ExpectContentLoaded();
invokeProvider.Invoke();
});
this.WaitForContentLoaded();
this.EnqueueCallback(() =>
{
this.GetChildAutomationPeers();
IToggleProvider toggleProvider = (this._inputControlAutomationPeers[0] as CheckBoxAutomationPeer).GetPattern(PatternInterface.Toggle) as IToggleProvider;
IValueProvider valueProvider = (this._inputControlAutomationPeers[2] as TextBoxAutomationPeer).GetPattern(PatternInterface.Value) as IValueProvider;
toggleProvider.Toggle();
valueProvider.SetValue("new string");
invokeProvider = this._commitButtonAutomationPeer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
this.ExpectContentLoaded();
invokeProvider.Invoke();
});
this.WaitForContentLoaded();
this.EnqueueCallback(() =>
{
Assert.AreEqual(false, dataClass.BoolProperty);
Assert.AreEqual("new string", dataClass.StringProperty);
});
this.EnqueueTestComplete();
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkspaceAuditServiceFactory"/> class.
/// Constructs the WorkspaceAuditServiceFactory
/// </summary>
/// <param name="relativityApplicationRepository">relativity app repo</param>
/// <param name="sqlWorkspaceAuditServiceProvider">provides the ISqlWorkspaceAuditService</param>
/// <param name="datagridWorkspaceAuditServiceProvider"> *** This will be null if the data grid references can't be loaded *** </param>
/// <param name="toggleProvider">toggle provider</param>
/// <param name="logger">logger</param>
/// <param name="dataGridCacheRepository">data grid cache repo</param>
public WorkspaceAuditServiceFactory(
IRelativityApplicationRepository relativityApplicationRepository,
IWorkspaceAuditServiceProvider <ISqlWorkspaceAuditService> sqlWorkspaceAuditServiceProvider,
IWorkspaceAuditServiceProvider <IDataGridWorkspaceAuditService> datagridWorkspaceAuditServiceProvider,
IToggleProvider toggleProvider,
ILogger logger,
IDataGridCacheRepository dataGridCacheRepository)
{
this.relativityApplicationRepository = relativityApplicationRepository;
this.sqlWorkspaceAuditServiceProvider = sqlWorkspaceAuditServiceProvider;
this.datagridWorkspaceAuditServiceProvider = datagridWorkspaceAuditServiceProvider;
this.toggleProvider = toggleProvider;
this.logger = logger.WithClassName().WithCategory(Names.LogCategory.Audit);
this.dataGridCacheRepository = dataGridCacheRepository;
}
public virtual void TestHasKeyboardFocusAfterPattern()
{
ToggleButton fe = CreateConcreteFrameworkElement()
as ToggleButton;
AutomationPeer peer = FrameworkElementAutomationPeer.CreatePeerForElement(fe);
IToggleProvider provider = null;
CreateAsyncTest(fe,
() => {
provider = (IToggleProvider)peer.GetPattern(PatternInterface.Toggle);
Assert.IsNotNull(provider, "#0");
},
() => provider.Toggle(),
() => Assert.IsTrue(peer.HasKeyboardFocus(), "#1"));
}
public static void autoCheckResolution(DataModels.FilterDataModel filters)
{
//ShowingDevices _devicesobj = new ShowingDevices();
foreach (CheckBox cb in ShowingDevices.AppWindow.filter3Stack.Children)
{
foreach (var resolution in filters.resolution)
{
if (cb.Content.Equals(resolution))
{
CheckBoxAutomationPeer peer = new CheckBoxAutomationPeer(cb);
IToggleProvider toggleProvider = peer.GetPattern(PatternInterface.Toggle) as IToggleProvider;
toggleProvider.Toggle();
}
}
}
}
public static void autoCheckWeight(DataModels.FilterDataModel filters)
{
//ShowingDevices _devicesobj = new ShowingDevices();
foreach (CheckBox cb in ShowingDevices.AppWindow.filter2Stack.Children)
{
foreach (var weight in filters.weight)
{
if (weight.Equals(cb.Content.ToString().Split(' ')[0]))
{
CheckBoxAutomationPeer peer = new CheckBoxAutomationPeer(cb);
IToggleProvider toggleProvider = peer.GetPattern(PatternInterface.Toggle) as IToggleProvider;
toggleProvider.Toggle();
}
}
}
}
public static void autoCheckBatteryCapacity(DataModels.FilterDataModel filters)
{
//ShowingDevices _devicesobj = new ShowingDevices();
foreach (CheckBox cb in ShowingDevices.AppWindow.filter4Stack.Children)
{
foreach (var fil in filters.batterycapacity)
{
if ((int)cb.Content == int.Parse(fil))
{
CheckBoxAutomationPeer peer = new CheckBoxAutomationPeer(cb);
IToggleProvider toggleProvider = peer.GetPattern(PatternInterface.Toggle) as IToggleProvider;
toggleProvider.Toggle();
}
}
}
}
public override void OnRefStateSet(ref Atk.StateSet states)
{
IExpandCollapseProvider expandCollapse
= peer.GetPattern(PatternInterface.ExpandCollapse)
as IExpandCollapseProvider;
if (expandCollapse != null)
{
var state = expandCollapse.ExpandCollapseState;
// If it's not a leaf, it can be expanded
if (state != ExpandCollapseState.LeafNode)
{
states.AddState(Atk.StateType.Expandable);
}
if (state == ExpandCollapseState.Expanded ||
state == ExpandCollapseState.PartiallyExpanded)
{
states.AddState(Atk.StateType.Expanded);
}
else
{
states.RemoveState(Atk.StateType.Expanded);
}
}
IToggleProvider toggle
= peer.GetPattern(PatternInterface.Toggle)
as IToggleProvider;
if (toggle != null)
{
states.RemoveState(Atk.StateType.Checked);
states.RemoveState(Atk.StateType.Indeterminate);
var state = toggle.ToggleState;
if (state == ToggleState.On)
{
states.AddState(Atk.StateType.Checked);
}
else if (state == ToggleState.Indeterminate)
{
states.AddState(Atk.StateType.Indeterminate);
}
}
}
public virtual void ToggleProvider_ToggleState()
{
ToggleButton toggleButton = CreateConcreteFrameworkElement()
as ToggleButton;
FrameworkElementAutomationPeerContract feap
= CreateConcreteFrameworkElementAutomationPeer(toggleButton);
IToggleProvider toggleProvider = feap as IToggleProvider;
// Test two-state toggling
toggleButton.IsThreeState = false;
toggleButton.IsChecked = false;
Assert.AreEqual(ToggleState.Off, toggleProvider.ToggleState,
"Start two-state toggle: Unchecked");
toggleButton.IsChecked = true;
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState,
"First two-state toggle: Checked");
toggleButton.IsChecked = false;
Assert.AreEqual(ToggleState.Off, toggleProvider.ToggleState,
"Second two-state toggle: Unchecked");
toggleButton.IsChecked = true;
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState,
"Third two-state toggle: Checked");
// Test three-state toggling
toggleButton.IsThreeState = true;
toggleButton.IsChecked = true;
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState,
"Start three-state Checked");
toggleButton.IsChecked = false;
Assert.AreEqual(ToggleState.Off, toggleProvider.ToggleState,
"First three-state toggle: Unchecked");
toggleButton.IsChecked = null;
Assert.AreEqual(ToggleState.Indeterminate, toggleProvider.ToggleState,
"Second three-state toggle: Intermediate");
toggleButton.IsChecked = true;
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState,
"Third three-state toggle: Checked");
}
public void ToggleTest()
{
ToolBarButton toggleButton = new ToolBarButton();
toggleButton.Style = ToolBarButtonStyle.ToggleButton;
toolBar.Buttons.Add(toggleButton);
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(toggleButton);
Assert.IsFalse(toggleButton.Pushed, "Button is not pushed by default.");
IToggleProvider toggleProvider = (IToggleProvider)
provider.GetPatternProvider(TogglePatternIdentifiers.Pattern.Id);
toggleProvider.Toggle();
Assert.IsTrue(toggleButton.Pushed, "Button is pushed.");
}
public override void RaiseAutomationPropertyChangedEvent(AutomationPropertyChangedEventArgs e)
{
if (editableTextExpert.RaiseAutomationPropertyChangedEvent(e))
{
return;
}
if (e.Property == AutomationElementIdentifiers.HasKeyboardFocusProperty)
{
bool focused = (bool)e.NewValue;
Adapter parentAdapter = (Adapter)Parent;
if (parentAdapter is List)
{
((List)parentAdapter).HandleItemFocus(this, focused);
return;
}
parentAdapter.NotifyStateChange(Atk.StateType.Focused, focused);
if (focused)
{
Atk.Focus.TrackerNotify(parentAdapter);
}
}
else if (e.Property == TogglePatternIdentifiers.ToggleStateProperty)
{
NotifyStateChange(Atk.StateType.Checked, IsChecked((ToggleState)e.NewValue));
}
else if (e.Property == AutomationElementIdentifiers.IsTogglePatternAvailableProperty)
{
if ((bool)e.NewValue == true)
{
toggleProvider = (IToggleProvider)Provider.GetPatternProvider(TogglePatternIdentifiers.Pattern.Id);
actionExpert.Add("toggle", "toggle", null, DoToggle);
}
else
{
toggleProvider = null;
actionExpert.Remove("toggle");
}
}
else
{
base.RaiseAutomationPropertyChangedEvent(e);
}
}
public HourlyScoringLogic(
ICategoryScoreRepository categoryScoreRepository,
ICategoryRepository categoryRepository,
IHourRepository hourRepository,
ILogService logService,
IFcmRepository fcmRepository,
IToggleProvider toggleProvider,
ILegacyRecoverabilityIntegrityRepository legacyRecoverabilityIntegrityRepository,
ILogger logger)
{
this.categoryScoreRepository = categoryScoreRepository;
this.categoryRepository = categoryRepository;
this.hourRepository = hourRepository;
this.logService = logService;
this.fcmRepository = fcmRepository;
this.toggleProvider = toggleProvider;
this.legacyRecoverabilityIntegrityRepository = legacyRecoverabilityIntegrityRepository;
this.logger = logger.WithTypeName(this); // .WithClassName(); -- doesn't work
}
public override void ToggleProvider_Toggle()
{
RadioButton radioButton = CreateConcreteFrameworkElement() as RadioButton;
FrameworkElementAutomationPeerContract feap
= CreateConcreteFrameworkElementAutomationPeer(radioButton);
radioButton.IsEnabled = false;
IToggleProvider toggleProvider = feap as IToggleProvider;
try {
toggleProvider.Toggle();
Assert.Fail("Should throw ElementNotEnabledException");
} catch (ElementNotEnabledException) { }
radioButton.IsEnabled = true;
// Test two-state toggling
radioButton.IsThreeState = false;
radioButton.IsChecked = false;
Assert.AreEqual(ToggleState.Off, toggleProvider.ToggleState,
"Start two-state toggle: Unchecked");
toggleProvider.Toggle();
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState,
"First two-state toggle: Checked");
// Test three-state toggling
radioButton.IsThreeState = true;
radioButton.IsChecked = false;
Assert.AreEqual(ToggleState.Off, toggleProvider.ToggleState,
"Start three-state Checked");
toggleProvider.Toggle();
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState,
"First three-state toggle: Checked");
// NOTE: I don't think it will ever be indeterminate
}
public ListItem (IRawElementProviderSimple provider) : base (provider)
{
invokeProvider = (IInvokeProvider)provider.GetPatternProvider(InvokePatternIdentifiers.Pattern.Id);
selectionItemProvider = (ISelectionItemProvider)provider.GetPatternProvider(SelectionItemPatternIdentifiers.Pattern.Id);
if (selectionItemProvider == null)
throw new ArgumentException ("ListItem should always implement ISelectionItemProvider");
toggleProvider = (IToggleProvider) provider.GetPatternProvider (TogglePatternIdentifiers.Pattern.Id);
textExpert = TextImplementorFactory.GetImplementor (this, provider);
imageExpert = new ImageImplementorHelper (this);
actionExpert = new ActionImplementorHelper ();
editableTextExpert = new EditableTextImplementorHelper (this, this, textExpert);
// TODO: Localize the name?s
actionExpert.Add ("click", "click", null, DoClick);
if (toggleProvider != null)
actionExpert.Add ("toggle", "toggle", null, DoToggle);
if (invokeProvider != null)
actionExpert.Add ("invoke", "invoke", null, DoInvoke);
Role = (toggleProvider != null? Atk.Role.CheckBox: Atk.Role.ListItem);
}
public override void RaiseAutomationPropertyChangedEvent(AutomationPropertyChangedEventArgs e)
{
if (e.Property.Id == AutomationElementIdentifiers.IsOffscreenProperty.Id)
{
selected = (bool)e.NewValue ? false : selected;
NotifyStateChange(Atk.StateType.Showing);
}
else if (e.Property.Id == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id)
{
NotifyStateChange(Atk.StateType.Selected, (bool)e.NewValue);
base.RaiseAutomationPropertyChangedEvent(e);
}
else if (e.Property == AutomationElementIdentifiers.IsTogglePatternAvailableProperty)
{
toggleProvider = (IToggleProvider)
Provider.GetPatternProvider(TogglePatternIdentifiers.Pattern.Id);
NotifyStateChange(Atk.StateType.Checked, Checked);
}
else if (e.Property == AutomationElementIdentifiers.IsInvokePatternAvailableProperty)
{
invokeProvider = (IInvokeProvider)
Provider.GetPatternProvider(InvokePatternIdentifiers.Pattern.Id);
}
else if (e.Property == AutomationElementIdentifiers.IsExpandCollapsePatternAvailableProperty)
{
expandCollapseProvider = (IExpandCollapseProvider)
Provider.GetPatternProvider(ExpandCollapsePatternIdentifiers.Pattern.Id);
}
else if (e.Property == AutomationElementIdentifiers.IsSelectionItemPatternAvailableProperty)
{
selectionItemProvider = (ISelectionItemProvider)
Provider.GetPatternProvider(SelectionItemPatternIdentifiers.Pattern.Id);
NotifyStateChange(Atk.StateType.Checked, SelectionItemSelected);
}
else
{
base.RaiseAutomationPropertyChangedEvent(e);
}
}
public void ToggleStatePropertyChangedEventTest()
{
CheckBox checkbox = new CheckBox();
IRawElementProviderSimple provider = ProviderFactory.GetProvider(checkbox);
IToggleProvider toggleProvider = (IToggleProvider)
provider.GetPatternProvider(TogglePatternIdentifiers.Pattern.Id);
checkbox.Checked = false;
TestToggleEvent(checkbox,
toggleProvider,
CheckState.Checked,
ToggleState.On);
TestToggleEvent(checkbox,
toggleProvider,
CheckState.Unchecked,
ToggleState.Off);
TestToggleEvent(checkbox,
toggleProvider,
CheckState.Indeterminate,
ToggleState.Indeterminate);
}
public void ToggleEventTest()
{
ToolBarButton toggleButton = new ToolBarButton();
toggleButton.Style = ToolBarButtonStyle.ToggleButton;
toolBar.Buttons.Add(toggleButton);
IRawElementProviderSimple provider =
ProviderFactory.GetProvider(toggleButton);
IToggleProvider toggleProvider = (IToggleProvider)
provider.GetPatternProvider(TogglePatternIdentifiers.Pattern.Id);
Label label = new Label();
label.Text = "Old Text";
toolBar.Controls.Add(label);
Assert.AreEqual(label.Text, "Old Text", "Button is not pushed by default.");
toolBar.ButtonClick += delegate(object sender, ToolBarButtonClickEventArgs e) {
label.Text = "New Text";
};
toggleProvider.Toggle();
Assert.AreEqual(label.Text, "New Text", "Button is pushed.");
}
public void ToggleTest()
{
IRawElementProviderSimple provider
= ProviderFactory.GetProvider(button);
IToggleProvider toggleProvider =
provider.GetPatternProvider(TogglePatternIdentifiers.Pattern.Id)
as IToggleProvider;
// LAMESPEC: We're going against the spec here -- if
// CheckOnClick is set, support Toggle provider.
button.CheckOnClick = false;
// Depends -> No
Assert.IsNull(toggleProvider, "Implements IToggleProvider");
button.CheckOnClick = true;
toggleProvider =
provider.GetPatternProvider(TogglePatternIdentifiers.Pattern.Id) as IToggleProvider;
// Depends -> Yes
Assert.IsNotNull(toggleProvider, "Should implement IToggleProvider");
Assert.AreEqual(ToggleState.Off, toggleProvider.ToggleState, "ToggleState");
bridge.ResetEventLists();
toggleProvider.Toggle();
Assert.AreEqual(ToggleState.On, toggleProvider.ToggleState, "ToggleState");
Assert.AreEqual(1, bridge.AutomationPropertyChangedEvents.Count,
"event count");
}
public override void RaiseAutomationPropertyChangedEvent (AutomationPropertyChangedEventArgs e)
{
if (editableTextExpert.RaiseAutomationPropertyChangedEvent (e))
return;
if (e.Property == AutomationElementIdentifiers.HasKeyboardFocusProperty) {
bool focused = (bool) e.NewValue;
Adapter parentAdapter = (Adapter) Parent;
if (parentAdapter is List) {
((List)parentAdapter).HandleItemFocus (this, focused);
return;
}
parentAdapter.NotifyStateChange (Atk.StateType.Focused, focused);
if (focused)
Atk.Focus.TrackerNotify (parentAdapter);
} else if (e.Property == TogglePatternIdentifiers.ToggleStateProperty)
NotifyStateChange (Atk.StateType.Checked, IsChecked ((ToggleState)e.NewValue));
else if (e.Property == AutomationElementIdentifiers.IsTogglePatternAvailableProperty) {
if ((bool)e.NewValue == true) {
toggleProvider = (IToggleProvider) Provider.GetPatternProvider (TogglePatternIdentifiers.Pattern.Id);
actionExpert.Add ("toggle", "toggle", null, DoToggle);
} else {
toggleProvider = null;
actionExpert.Remove ("toggle");
}
} else
base.RaiseAutomationPropertyChangedEvent (e);
}
private void TestToggleEventWithToggle (IToggleProvider provider,
ToggleState expectedState)
{
bridge.ResetEventLists ();
object oldState = provider.ToggleState;
provider.Toggle ();
// Test IToggleProvider.ToggleState
Assert.AreEqual (expectedState, provider.ToggleState, "ToggleState");
// Test event was fired as expected
Assert.AreEqual (1,
bridge.AutomationPropertyChangedEvents.Count,
"event count");
AutomationPropertyChangedEventArgs eventArgs =
bridge.AutomationPropertyChangedEvents [0].e;
Assert.AreEqual (TogglePatternIdentifiers.ToggleStateProperty,
eventArgs.Property,
"event args property");
Assert.AreEqual (oldState,
eventArgs.OldValue,
"old value");
Assert.AreEqual (expectedState,
eventArgs.NewValue,
"new value");
}
public TogglePatternWrapper (IToggleProvider provider)
{
this.provider = provider;
}
public virtual void ToggleProvider_ToggleEvents()
{
if (!EventsManager.Instance.AutomationSingletonExists)
{
EnqueueTestComplete();
return;
}
ToggleButton toggleButton = CreateConcreteFrameworkElement() as ToggleButton;
AutomationPeer peer
= FrameworkElementAutomationPeer.CreatePeerForElement(toggleButton);
AutomationPropertyEventTuple tuple = null;
IToggleProvider toggleProvider = (IToggleProvider)peer;
CreateAsyncTest(toggleButton,
() => {
EventsManager.Instance.Reset();
toggleButton.IsThreeState = false;
toggleButton.IsChecked = false;
},
// Test two-state toggling
() => {
tuple = EventsManager.Instance.GetAutomationEventFrom(peer,
TogglePatternIdentifiers.ToggleStateProperty);
Assert.IsNull(tuple, "#0");
Assert.AreEqual(ToggleState.Off, toggleProvider.ToggleState,
"Start two-state toggle: Unchecked");
},
() => {
EventsManager.Instance.Reset();
toggleProvider.Toggle();
},
() => {
tuple = EventsManager.Instance.GetAutomationEventFrom(peer,
TogglePatternIdentifiers.ToggleStateProperty);
Assert.IsNotNull(tuple, "#1");
Assert.AreEqual(ToggleState.Off,
(ToggleState)tuple.OldValue,
"#2");
Assert.AreEqual(ToggleState.On,
(ToggleState)tuple.NewValue,
"#3");
},
() => {
EventsManager.Instance.Reset();
toggleProvider.Toggle();
},
() => {
tuple = EventsManager.Instance.GetAutomationEventFrom(peer,
TogglePatternIdentifiers.ToggleStateProperty);
Assert.IsNotNull(tuple, "#4");
Assert.AreEqual(ToggleState.On,
(ToggleState)tuple.OldValue,
"#5");
Assert.AreEqual(ToggleState.Off,
(ToggleState)tuple.NewValue,
"#6");
},
// Test three-state toggling
() => {
EventsManager.Instance.Reset();
toggleButton.IsThreeState = true;
toggleButton.IsChecked = true;
},
() => {
tuple = EventsManager.Instance.GetAutomationEventFrom(peer,
TogglePatternIdentifiers.ToggleStateProperty);
Assert.IsNotNull(tuple, "#7");
Assert.AreEqual(ToggleState.Off,
(ToggleState)tuple.OldValue,
"#8");
Assert.AreEqual(ToggleState.On,
(ToggleState)tuple.NewValue,
"#9");
},
() => {
EventsManager.Instance.Reset();
toggleProvider.Toggle();
},
() => {
tuple = EventsManager.Instance.GetAutomationEventFrom(peer,
TogglePatternIdentifiers.ToggleStateProperty);
Assert.IsNotNull(tuple, "#10");
Assert.AreEqual(ToggleState.On,
(ToggleState)tuple.OldValue,
"#11");
Assert.AreEqual(ToggleState.Indeterminate,
(ToggleState)tuple.NewValue,
"#12");
},
() => {
EventsManager.Instance.Reset();
toggleProvider.Toggle();
},
() => {
tuple = EventsManager.Instance.GetAutomationEventFrom(peer,
TogglePatternIdentifiers.ToggleStateProperty);
Assert.IsNotNull(tuple, "#13");
Assert.AreEqual(ToggleState.Indeterminate,
(ToggleState)tuple.OldValue,
"#14");
Assert.AreEqual(ToggleState.Off,
(ToggleState)tuple.NewValue,
"#15");
},
() => {
EventsManager.Instance.Reset();
toggleProvider.Toggle();
},
() => {
tuple = EventsManager.Instance.GetAutomationEventFrom(peer,
TogglePatternIdentifiers.ToggleStateProperty);
Assert.IsNotNull(tuple, "#16");
Assert.AreEqual(ToggleState.Off,
(ToggleState)tuple.OldValue,
"#17");
Assert.AreEqual(ToggleState.On,
(ToggleState)tuple.NewValue,
"#18");
});
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
private ToggleProviderWrapper( AutomationPeer peer, IToggleProvider iface )
{
_peer = peer;
_iface = iface;
}
public override void RaiseAutomationPropertyChangedEvent (AutomationPropertyChangedEventArgs e)
{
if (e.Property.Id == AutomationElementIdentifiers.IsOffscreenProperty.Id) {
selected = (bool) e.NewValue ? false : selected;
NotifyStateChange (Atk.StateType.Showing);
} else if (e.Property.Id == AutomationElementIdentifiers.HasKeyboardFocusProperty.Id) {
NotifyStateChange (Atk.StateType.Selected, (bool) e.NewValue);
base.RaiseAutomationPropertyChangedEvent (e);
} else if (e.Property == AutomationElementIdentifiers.IsTogglePatternAvailableProperty) {
toggleProvider = (IToggleProvider)
Provider.GetPatternProvider (TogglePatternIdentifiers.Pattern.Id);
NotifyStateChange (Atk.StateType.Checked, Checked);
} else if (e.Property == AutomationElementIdentifiers.IsInvokePatternAvailableProperty) {
invokeProvider = (IInvokeProvider)
Provider.GetPatternProvider (InvokePatternIdentifiers.Pattern.Id);
} else if (e.Property == AutomationElementIdentifiers.IsExpandCollapsePatternAvailableProperty) {
expandCollapseProvider = (IExpandCollapseProvider)
Provider.GetPatternProvider (ExpandCollapsePatternIdentifiers.Pattern.Id);
} else if (e.Property == AutomationElementIdentifiers.IsSelectionItemPatternAvailableProperty) {
selectionItemProvider = (ISelectionItemProvider)
Provider.GetPatternProvider (SelectionItemPatternIdentifiers.Pattern.Id);
NotifyStateChange (Atk.StateType.Checked, SelectionItemSelected);
} else {
base.RaiseAutomationPropertyChangedEvent (e);
}
}
