public static Collection <object> GetSelectedItems(IntPtr controlHandle)
{
if (!CanSelectMultiple(controlHandle))
{
return(null);
}
try
{
AutomationElement control = CommonUIAPatternHelpers.Prologue(SelectionPattern.Pattern, controlHandle);
AutomationElementCollection convRet = SelectionItemPatternHelper.GetSelectedItems(control);
Collection <object> ret = InternalUtilities.AutomationCollToObjectList(convRet);
LogController.ReceiveLogMessage(new LogMessage("List selected items: ", ret));
return(ret);
}
catch (InvalidOperationException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ElementNotAvailableException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ArgumentException err)
{
throw new ProdOperationException(err.Message, err);
}
}
public static Collection <object> GetItems(IntPtr controlHandle)
{
try
{
AutomationElement control = CommonUIAPatternHelpers.Prologue(SelectionPattern.Pattern, controlHandle);
AutomationElementCollection convRet = SelectionItemPatternHelper.GetListItems(control);
Collection <object> ret = InternalUtilities.AutomationCollToObjectList(convRet);
if (ret == null)
{
ProdListBoxNative.GetItemsNative(controlHandle);
}
LogController.ReceiveLogMessage(new LogMessage(control.Current.Name, ret));
return(ret);
}
catch (InvalidOperationException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ElementNotAvailableException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ArgumentException err)
{
throw new ProdOperationException(err.Message, err);
}
}
public static void DeselectItem(IntPtr controlHandle, string itemText)
{
try
{
AutomationElement control = CommonUIAPatternHelpers.Prologue(SelectionPattern.Pattern, controlHandle);
AutomationElement itemToSelect = SelectionItemPatternHelper.FindItemByText(control, itemText);
StaticEvents.RegisterEvent(SelectionItemPattern.ElementRemovedFromSelectionEvent, control);
SelectionItemPatternHelper.RemoveFromSelection(itemToSelect);
LogController.ReceiveLogMessage(new LogMessage("List Item deselected: " + itemText));
}
catch (InvalidOperationException)
{
/* Call native function */
ProdListBoxNative.DeSelectItemNative(controlHandle, itemText);
}
catch (ElementNotAvailableException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ArgumentException err)
{
throw new ProdOperationException(err.Message, err);
}
}
public static void AddToSelection(IntPtr controlHandle, int index)
{
try
{
AutomationElement control = CommonUIAPatternHelpers.Prologue(SelectionPattern.Pattern, controlHandle);
StaticEvents.RegisterEvent(SelectionItemPattern.ElementAddedToSelectionEvent, control);
SelectionItemPatternHelper.AddToSelection(control, index);
LogController.ReceiveLogMessage(new LogMessage(control.Current.Name));
}
catch (InvalidOperationException)
{
/* Call native function */
ProdListBoxNative.AddSelectedItemNative(controlHandle, index);
}
catch (ElementNotAvailableException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ArgumentException err)
{
throw new ProdOperationException(err.Message, err);
}
}
public static void SetSelectedItem(IntPtr controlHandle, string itemText)
{
try
{
AutomationElement control = CommonUIAPatternHelpers.Prologue(SelectionPattern.Pattern, controlHandle);
StaticEvents.RegisterEvent(SelectionItemPattern.ElementSelectedEvent, control);
AutomationElement indexedItem = SelectionItemPatternHelper.FindItemByText(control, itemText);
SelectionItemPatternHelper.SelectItem(indexedItem);
LogController.ReceiveLogMessage(new LogMessage(itemText));
}
catch (InvalidOperationException)
{
ProdListBoxNative.SelectItemNative(controlHandle, itemText);
}
catch (ElementNotAvailableException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ArgumentException err)
{
throw new ProdOperationException(err.Message, err);
}
}
private static bool UiaGetIsSelected(BaseProdControl control)
{
bool retVal = SelectionItemPatternHelper.IsItemSelected(control.UIAElement);
LogController.ReceiveLogMessage(new LogMessage(retVal.ToString()));
return(retVal);
}
/// <summary>
/// Determines whether the specified index is selected.
/// </summary>
/// <param name="controlHandle">The control handle.</param>
/// <param name="index">The zero-based index of the tab to select.</param>
/// <returns>
/// <c>true</c> if the specified index is selected; otherwise, <c>false</c>.
/// </returns>
///<exception cref="ProdOperationException">Examine inner exception</exception>
public static bool TabIsSelected(IntPtr controlHandle, int index)
{
bool ret;
try
{
AutomationElement control = CommonUIAPatternHelpers.Prologue(SelectionPattern.Pattern, controlHandle);
AutomationElement[] element = SelectionPatternHelper.GetSelection(control);
int retVal = SelectionItemPatternHelper.FindIndexByItem(control, element[0].Current.Name);
ret = (retVal == index);
LogController.ReceiveLogMessage(new LogMessage(ret.ToString()));
return(ret);
}
catch (InvalidOperationException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ElementNotAvailableException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ArgumentException err)
{
throw new ProdOperationException(err.Message, err);
}
}
public static int GetItemCount(IntPtr controlHandle)
{
try
{
AutomationElement control = CommonUIAPatternHelpers.Prologue(SelectionPattern.Pattern, controlHandle);
int ret = SelectionItemPatternHelper.GetListItemCount(control);
if (ret == -1)
{
if (control.Current.ControlType == ControlType.ComboBox)
{
ProdComboBoxNative.GetItemCountNative(controlHandle);
}
else
{
ProdListBoxNative.GetItemCountNative(controlHandle);
}
}
LogController.ReceiveLogMessage(new LogMessage(ret.ToString(CultureInfo.InvariantCulture)));
return(ret);
}
catch (InvalidOperationException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ElementNotAvailableException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ArgumentException err)
{
throw new ProdOperationException(err.Message, err);
}
}
public static int GetSelectedIndex(IntPtr controlHandle)
{
try
{
AutomationElement control = CommonUIAPatternHelpers.Prologue(SelectionPattern.Pattern, controlHandle);
AutomationElement[] element = SelectionPatternHelper.GetSelection(control);
int ret = SelectionItemPatternHelper.FindIndexByItem(control, element[0].Current.Name);
if (ret == -1)
{
/* Call native function */
ret = ProdListBoxNative.GetSelectedIndexNative(controlHandle);
}
LogController.ReceiveLogMessage(new LogMessage(ret.ToString(CultureInfo.InvariantCulture)));
return(ret);
}
catch (InvalidOperationException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ElementNotAvailableException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ArgumentException err)
{
throw new ProdOperationException(err.Message, err);
}
}
private static int UiaGetItemCount(BaseProdControl control)
{
AutomationElementCollection convRet = SelectionItemPatternHelper.GetListItems(control.UIAElement);
LogController.ReceiveLogMessage(new LogMessage("Items: " + convRet.Count));
return(convRet.Count);
}
public static void TabSelect(IntPtr controlHandle, int index)
{
try
{
AutomationElement control = CommonUIAPatternHelpers.Prologue(SelectionPattern.Pattern, controlHandle);
AutomationElementCollection aec = SelectionItemPatternHelper.GetListItems(control);
/* When using the GetListItems() methods, item index 0 is the tab control itself, so add on to get to correct TabItem */
if (index >= int.MaxValue)
{
throw new ProdOperationException("input must be less than Int32.MaxValue");
}
int adjustedIndex = index + 1;
string itemText = aec[adjustedIndex].Current.Name;
StaticEvents.RegisterEvent(SelectionItemPattern.ElementSelectedEvent, control);
SelectionItemPatternHelper.SelectItem(SelectionItemPatternHelper.FindItemByText(control, itemText));
LogController.ReceiveLogMessage(new LogMessage(control.Current.Name));
}
catch (InvalidOperationException)
{
/* Call native function */
ProdTabNative.SetSelectedTab(controlHandle, index);
}
catch (ElementNotAvailableException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ArgumentException err)
{
throw new ProdOperationException(err.Message, err);
}
}
/// <summary>
/// Gets the number of child tabs contained in the tab control
/// </summary>
/// <param name="controlHandle">The target controls handle.</param>
/// <returns>
/// The number of tabs in a TabControl
/// </returns>
/// <exception cref="ProdOperationException">Examine inner exception</exception>
public static int TabGetCount(IntPtr controlHandle)
{
try
{
AutomationElement control = CommonUIAPatternHelpers.Prologue(SelectionPattern.Pattern, controlHandle);
int retVal = SelectionItemPatternHelper.GetListItemCount(control);
if (retVal == -1)
{
ProdTabNative.GetTabCount(controlHandle);
}
LogController.ReceiveLogMessage(new LogMessage(retVal.ToString(CultureInfo.CurrentCulture)));
return(retVal);
}
catch (InvalidOperationException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ElementNotAvailableException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ArgumentException err)
{
throw new ProdOperationException(err.Message, err);
}
}
/// <summary>
/// Gets selection status of the item.
/// </summary>
/// <param name="control">The UI Automation element</param>
/// <param name="text">The text.</param>
/// <returns></returns>
private static bool UiaIsItemSelected(BaseProdControl control, string text)
{
AutomationElement element = SelectionItemPatternHelper.FindItemByText(control.UIAElement, text);
bool retVal = SelectionItemPatternHelper.IsItemSelected(element);
LogController.ReceiveLogMessage(new LogMessage(retVal.ToString()));
return(retVal);
}
private static int UiaSelectedIndex(BaseProdControl control)
{
AutomationElement[] element = SelectionPatternHelper.SelectedItems(control.UIAElement);
int retVal = SelectionItemPatternHelper.FindIndexByItem(control.UIAElement, element[0].Current.Name);
LogController.ReceiveLogMessage(new LogMessage(retVal.ToString(CultureInfo.CurrentCulture)));
return(retVal);
}
private static Collection <object> UiaGetItems(BaseProdControl control)
{
AutomationElementCollection convRet = SelectionItemPatternHelper.GetListItems(control.UIAElement);
Collection <object> retVal = InternalUtilities.AutomationCollToObjectList(convRet);
LogController.ReceiveLogMessage(new LogMessage("List Items: ", retVal));
return(retVal);
}
private static void UiaSetSelectedItem(BaseProdControl control, string itemText)
{
LogController.ReceiveLogMessage(new LogMessage("Selecting " + itemText));
AutomationEventVerifier.Register(new EventRegistrationMessage(control, SelectionItemPattern.ElementSelectedEvent));
AutomationElement element = SelectionItemPatternHelper.FindItemByText(control.UIAElement, itemText);
SelectionItemPatternHelper.SelectItem(element);
}
private static void UiaSetSelectedIndex(BaseProdControl control, int index)
{
LogController.ReceiveLogMessage(new LogMessage("Selecting " + index));
AutomationEventVerifier.Register(new EventRegistrationMessage(control, SelectionItemPattern.ElementSelectedEvent));
AutomationElement indexedItem = SelectionItemPatternHelper.FindItemByIndex(control.UIAElement, index);
SelectionItemPatternHelper.SelectItem(indexedItem);
}
/// <summary>
/// Adds the list item to the current selection using UIA
/// </summary>
/// <param name="control">The base ProdUI control.</param>
/// <param name="index">Zero based index of the item.</param>
private static void UiaAddToSelection(BaseProdControl control, int index)
{
if (!UiaCanSelectMultiple(control))
{
throw new ProdOperationException("Does not support multiple selection");
}
AutomationEventVerifier.Register(new EventRegistrationMessage(control, SelectionItemPattern.ElementAddedToSelectionEvent));
LogController.ReceiveLogMessage(new LogMessage("Adding " + index));
SelectionItemPatternHelper.AddToSelection(control.UIAElement, index);
}
private static void UiaSelectAll(BaseProdControl control)
{
if (!UiaCanSelectMultiple(control))
{
throw new ProdOperationException("Does not support multiple selection");
}
foreach (AutomationElement item in SelectionItemPatternHelper.GetListItems(control.UIAElement))
{
SelectionItemPatternHelper.AddToSelection(control.UIAElement, item.Current.Name);
}
}
private static void UiaRemoveFromSelection(BaseProdControl control, string itemText)
{
if (!UiaCanSelectMultiple(control))
{
throw new ProdOperationException("Does not support multiple selection");
}
AutomationElement itemToSelect = SelectionItemPatternHelper.FindItemByText(control.UIAElement, itemText);
AutomationEventVerifier.Register(new EventRegistrationMessage(control, SelectionItemPattern.ElementRemovedFromSelectionEvent));
LogController.ReceiveLogMessage(new LogMessage("Removing " + itemText));
SelectionItemPatternHelper.RemoveFromSelection(itemToSelect);
}
/// <summary>
/// Sets the selected item.
/// </summary>
/// <param name="control">The base ProdUI control.</param>
/// <param name="items">The items.</param>
private static void UiaSetSelectedItems(BaseProdControl control, IEnumerable <string> items)
{
if (!UiaCanSelectMultiple(control))
{
throw new ProdOperationException("Does not support multiple selection");
}
Collection <object> logList = new Collection <object> {
items
};
LogController.ReceiveLogMessage(new LogMessage("Adding", logList));
foreach (string item in items)
{
SelectionItemPatternHelper.AddToSelection(control.UIAElement, item);
}
}
/// <summary>
/// Gets the selected indexes using UIA
/// </summary>
/// <param name="control">The base ProdUI control</param>
/// <returns>
/// A List of all the indexes of currently selected list items.
/// </returns>
private static Collection <int> UiaGetSelectedIndexes(BaseProdControl control)
{
if (!UiaCanSelectMultiple(control))
{
throw new ProdOperationException("Does not support multiple selection");
}
AutomationElement[] selectedItems = SelectionPatternHelper.SelectedItems(control.UIAElement);
Collection <object> retList = new Collection <object> {
(selectedItems)
};
Collection <int> selectedIndexes = new Collection <int>();
foreach (AutomationElement item in selectedItems)
{
selectedIndexes.Add(SelectionItemPatternHelper.FindIndexByItem(control.UIAElement, item.Current.Name));
}
LogController.ReceiveLogMessage(new LogMessage("Selected Indexes", retList));
return(selectedIndexes);
}
/// <summary>
/// Gets a collection of all items in the list control
/// </summary>
/// <param name="controlHandle">The target controls handle.</param>
/// <returns>
/// list containing all items
/// </returns>
/// <exception cref="ProdOperationException">Examine inner exception</exception>
public static Collection <object> TabsGet(IntPtr controlHandle)
{
try
{
AutomationElement control = CommonUIAPatternHelpers.Prologue(SelectionPattern.Pattern, controlHandle);
AutomationElementCollection aec = SelectionItemPatternHelper.GetListItems(control);
LogController.ReceiveLogMessage(new LogMessage(control.Current.Name));
return(InternalUtilities.AutomationCollToObjectList(aec));
}
catch (InvalidOperationException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ElementNotAvailableException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ArgumentException err)
{
throw new ProdOperationException(err.Message, err);
}
}
/// <summary>
/// Determines whether the specified item text is selected.
/// </summary>
/// <param name="controlHandle">The control handle.</param>
/// <param name="itemText">The item text.</param>
/// <returns>
/// <c>true</c> if the specified item text is selected; otherwise, <c>false</c>.
/// </returns>
/// <exception cref="ProdOperationException">Examine inner exception</exception>
public static bool TabIsSelected(IntPtr controlHandle, string itemText)
{
try
{
AutomationElement control = CommonUIAPatternHelpers.Prologue(SelectionPattern.Pattern, controlHandle);
AutomationElement[] element = SelectionPatternHelper.GetSelection(control);
bool retVal = (SelectionItemPatternHelper.FindItemByText(control, itemText).Current.FrameworkId == element[0].Current.FrameworkId);
LogController.ReceiveLogMessage(new LogMessage(retVal.ToString()));
return(retVal);
}
catch (InvalidOperationException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ElementNotAvailableException err)
{
throw new ProdOperationException(err.Message, err);
}
catch (ArgumentException err)
{
throw new ProdOperationException(err.Message, err);
}
}
