// Removes this element from the selection void ISelectionItemProvider.RemoveFromSelection() { // Make sure that the control is enabled if (!SafeNativeMethods.IsWindowEnabled(_hwnd)) { throw new ElementNotEnabledException(); } // simple case: item is not selected if (!WindowsListView.IsItemSelected(_hwnd, _item)) { return; } // object does not support multi-selection if (!WindowsListView.MultiSelected(_hwnd)) { IRawElementProviderSimple container = ((ISelectionItemProvider)this).SelectionContainer; bool selectionRequired = container != null ? ((ISelectionProvider)container).IsSelectionRequired : true; // For single selection containers that IsSelectionRequired == false a // RemoveFromSelection is valid. if (selectionRequired) { throw new InvalidOperationException(SR.Get(SRID.SelectionRequired)); } } // try to unselect the item if (!WindowsListView.UnSelectItem(_hwnd, _item)) { throw new InvalidOperationException(SR.Get(SRID.OperationCannotBePerformed)); } }
//------------------------------------------------------ // // Private Methods // //------------------------------------------------------ #region Private Methods // retrieve current ToggleState private ToggleState GetToggleState() { ListViewItem.CheckState current = (ListViewItem.CheckState)WindowsListView.GetCheckedState(_hwnd, _listviewItem); switch (current) { case ListViewItem.CheckState.NoCheckbox: { throw new InvalidOperationException(SR.Get(SRID.OperationCannotBePerformed)); } case ListViewItem.CheckState.Checked: { return(ToggleState.On); } case ListViewItem.CheckState.Unchecked: { return(ToggleState.Off); } } // developer defined custom values which cannot be interpret outside of the app's scope return(ToggleState.Indeterminate); }
// To test if a list view item is offscreen, we need to // take into account the fact that it may be obscured by // the list view header. internal override bool IsOffscreen() { IntPtr hwndHeader = WindowsListView.ListViewGetHeader(_hwnd); if (hwndHeader != IntPtr.Zero) { NativeMethods.Win32Rect listViewRect = new NativeMethods.Win32Rect(); NativeMethods.Win32Rect headerRect = new NativeMethods.Win32Rect(); if (Misc.GetWindowRect(hwndHeader, ref headerRect) && Misc.GetClientRectInScreenCoordinates(_hwnd, ref listViewRect)) { // Remove the listview header rect. listViewRect.top = headerRect.bottom; NativeMethods.Win32Rect itemRect = new NativeMethods.Win32Rect(BoundingRectangle); if (!listViewRect.IsEmpty && !Misc.IsItemVisible(ref listViewRect, ref itemRect)) { return(true); } } } return(false); }
internal bool AreGroupsValid() { int count = _groups.Count; for (int i = 0; i < count; i++) { Group group = (Group)_groups[i]; if (!ListViewHasGroup(_hwnd, group._groupID)) { return(false); } } // Make sure that no new group have been added, try to match all the GroupId to an // existing one. int itemCount = WindowsListView.GetItemCount(_hwnd); NativeMethods.LVITEM_V6 item = new NativeMethods.LVITEM_V6(); item.mask = NativeMethods.LVIF_GROUPID; for (item.iItem = 0; item.iItem < itemCount; item.iItem++) { if (!XSendMessage.GetItem(_hwnd, ref item) || GetGroup(item.iGroupID) == null) { return(false); } } return(true); }
internal GroupManager this[IntPtr hwnd] { get { if (!WindowsListView.IsGroupViewEnabled(hwnd)) { // Group was disabled but we did not get the needed event // since for some things events are not being sent // (e.g: Going from some LV modes to - List mode, List mode does not have Groups) // Microsoft - We may want to consider raising the event here // The M7 work on checking if LE is valid however is the better way of going // WindowsListView.RemoveGroupAndRaiseLogicalChangedEvent(_hwnd); throw new InvalidOperationException(SR.Get(SRID.OperationCannotBePerformed)); } // The group may have been discarded by the reorder winevent. EnsureCreation(hwnd); GroupManager manager = _groupManagers[hwnd] as GroupManager; if (manager == null) { // E.G. Going from the List mode to the something that has Group will cause this // Microsoft- We may want to consider raising the event here // The M7 work on checking if LE is valid however is the better way of going // WindowsListView.RaiseLogicalChangedEvent(hwnd); throw new InvalidOperationException(SR.Get(SRID.OperationCannotBePerformed)); } return(manager); } }
internal GroupManager this[IntPtr hwnd] { get { if (!WindowsListView.IsGroupViewEnabled(hwnd)) { // Group was disabled but we did not get the needed event // since for some things events are not being sent // (e.g: Going from some LV modes to - List mode, List mode does not have Groups) // alexsn @ throw new InvalidOperationException(SR.Get(SRID.OperationCannotBePerformed)); } // The group may have been discarded by the reorder winevent. EnsureCreation(hwnd); GroupManager manager = _groupManagers[hwnd] as GroupManager; if (manager == null) { // E.G. Going from the List mode to the something that has Group will cause this // alexsn @ throw new InvalidOperationException(SR.Get(SRID.OperationCannotBePerformed)); } return(manager); } }
//------------------------------------------------------ // // Patterns Implementation // //------------------------------------------------------ #region ProxySimple Interface // Returns a pattern interface if supported. internal override object GetPatternProvider(AutomationPattern iid) { if (iid == InvokePattern.Pattern && WindowsListView.ListViewInvokable(_hwnd)) { return(this); } if (iid == SelectionItemPattern.Pattern) { return(this); } if (iid == ValuePattern.Pattern && WindowsListView.ListViewEditable(_hwnd)) { return(this); } if (iid == GridItemPattern.Pattern && IsImplementingGrid(_hwnd)) { return(this); } if (iid == TogglePattern.Pattern && IsItemWithCheckbox(_hwnd, _item)) { return(CreateListViewItemCheckbox()); } if (iid == ScrollItemPattern.Pattern && WindowScroll.IsScrollable(_hwnd)) { return(this); } return(null); }
// ------------------------------------------------------ // // Constructors // //------------------------------------------------------ #region Constructors internal ListViewSubItem(IntPtr hwnd, ProxyFragment parent, int item, int itemParent) : base(hwnd, parent, item) { // Is used to discriminate between items in a collection. _itemParent = itemParent; _cControlType = WindowsListView.ListViewEditable(hwnd) ? ControlType.Edit : ControlType.Text; }
// retrieves listview item/subitem text internal static string GetText(IntPtr hwnd, int item, int subitem) { NativeMethods.LVITEM lvitem = new NativeMethods.LVITEM(); lvitem.mask = NativeMethods.LVIF_TEXT; lvitem.iItem = item; lvitem.iSubItem = subitem; return(WindowsListView.GetItemText(hwnd, lvitem)); }
//------------------------------------------------------ // // Protected Methods // //------------------------------------------------------ #region Protected Methods // This routine is only called on elements belonging to an hwnd that has the focus. protected override bool IsFocused() { if (Misc.IsComctrlV6OnOsVerV6orHigher(_hwnd)) { int column = (int)Misc.ProxySendMessage(_hwnd, NativeMethods.LVM_GETFOCUSEDCOLUMN, IntPtr.Zero, IntPtr.Zero); return(column == _item); } return(WindowsListView.IsItemFocused(_hwnd, _itemParent)); }
// detect if given listviewitem has a checkbox internal static bool IsItemWithCheckbox(IntPtr hwnd, int item) { if (!WindowsListView.CheckBoxes(hwnd)) { return(false); } // this listview supports checkbox, detect if // current item has it return(CheckState.NoCheckbox != (CheckState)WindowsListView.GetCheckedState(hwnd, item)); }
// detect if this listviewitem needs to support GridItem pattern static private bool IsImplementingGrid(IntPtr hwnd) { // in the detail mode, GridItem will be implemented on the subitem // and not item if (WindowsListView.IsDetailMode(hwnd)) { return(false); } return(WindowsListView.IsListMode(hwnd) || WindowsListView.ListViewAutoArrange(hwnd)); }
//------------------------------------------------------ // // Internal Methods // //------------------------------------------------------ #region Internal Methods // retrieve bounding rectangle of the listview checkbox internal static NativeMethods.Win32Rect ListViewCheckBoxRect(IntPtr hwnd, int item) { // Rare special case if (WindowsListView.FullRowSelect(hwnd) && WindowsListView.IsDetailMode(hwnd)) { // Get listview window rect NativeMethods.Win32Rect controlRectangle = NativeMethods.Win32Rect.Empty; if (!Misc.GetWindowRect(hwnd, ref controlRectangle)) { return(NativeMethods.Win32Rect.Empty); } // BOUNDS == SELECTBOUNDS, hence cannot rely on them // will rely on the ICON or LABEL // Try icon first since it is the closest to the checkbox NativeMethods.Win32Rect rc; if ((WindowsListView.GetItemRect(hwnd, item, NativeMethods.LVIR_ICON, out rc) && rc.left != rc.right) || (WindowsListView.GetItemRect(hwnd, item, NativeMethods.LVIR_LABEL, out rc) && rc.left != rc.right)) { int right = controlRectangle.left + (rc.left - controlRectangle.left); return(new NativeMethods.Win32Rect(controlRectangle.left, rc.top, right, rc.bottom)); } } else { // Very common, simple case NativeMethods.Win32Rect wholeItem; if (!WindowsListView.GetItemRect(hwnd, item, NativeMethods.LVIR_BOUNDS, out wholeItem)) { return(NativeMethods.Win32Rect.Empty); } NativeMethods.Win32Rect selectable; if (!WindowsListView.GetItemRect(hwnd, item, NativeMethods.LVIR_SELECTBOUNDS, out selectable)) { return(NativeMethods.Win32Rect.Empty); } if (Misc.IsControlRTL(hwnd)) { return(new NativeMethods.Win32Rect(selectable.right, wholeItem.top, wholeItem.right, wholeItem.bottom)); } else { return(new NativeMethods.Win32Rect(wholeItem.left, wholeItem.top, selectable.left, wholeItem.bottom)); } } return(NativeMethods.Win32Rect.Empty); }
IRawElementProviderSimple [] ITableItemProvider.GetColumnHeaderItems() { IntPtr hwndHeader = WindowsListView.ListViewGetHeader(_hwnd); if (SafeNativeMethods.IsWindowVisible(hwndHeader)) { WindowsSysHeader header = (WindowsSysHeader)WindowsSysHeader.Create(hwndHeader, 0); return(new IRawElementProviderSimple [] { new WindowsSysHeader.HeaderItem(hwndHeader, header, _item) }); } return(null); }
//------------------------------------------------------ // // Internal Methods // //------------------------------------------------------ #region Internal Methods internal static ProxySimple ElementProviderFromPoint(IntPtr hwnd, ProxyFragment parent, int item, int x, int y) { NativeMethods.LVHITTESTINFO_INTERNAL hitTest = WindowsListView.SubitemHitTest(hwnd, item, new NativeMethods.Win32Point(x, y)); if (hitTest.iSubItem >= 0) { return(new ListViewSubItem(hwnd, parent, hitTest.iSubItem, item)); } // subitems do not exist return(parent); }
internal NativeMethods.Win32Rect CalculateRectNoHeader() { NativeMethods.Win32Rect rcLv = NativeMethods.Win32Rect.Empty; if (!Misc.GetWindowRect(_hwnd, ref rcLv)) { return(NativeMethods.Win32Rect.Empty); } // set top to the top coordinate of the first item NativeMethods.Win32Rect item; WindowsListView.GetItemRect(_hwnd, _items[0], NativeMethods.LVIR_BOUNDS, out item); NativeMethods.Win32Rect groupRc; groupRc.top = item.top; // left coordinate defined by the left coordinate of the listview groupRc.left = rcLv.left; int count = Count; // bottom defined by the bottom coordinate of the last item if (count > 1) { // get the rect of the last item in the group WindowsListView.GetItemRect(_hwnd, _items[count - 1], NativeMethods.LVIR_BOUNDS, out item); } groupRc.bottom = item.bottom; // right coordinate defined by lv.right groupRc.right = rcLv.right; // when vertical scrollbar is present take it into account if (WindowScroll.Scrollable(_hwnd, NativeMethods.SB_VERT)) { NativeMethods.Win32Rect rc = GetScrollbarRect(); int width = rc.right - rc.left; if (Misc.IsControlRTL(_hwnd)) { // Right to left mirroring style groupRc.left += width; } else { groupRc.right -= width; } } return(groupRc); }
//------------------------------------------------------ // // Patterns Implementation // //------------------------------------------------------ #region ProxySimple Interface // Returns a pattern interface if supported. internal override object GetPatternProvider(AutomationPattern iid) { if (iid == GridPattern.Pattern) { return(this); } else if (iid == ExpandCollapsePattern.Pattern && WindowsListView.IsGroupViewEnabled(_hwnd)) { return(this); } return(null); }
// This method returns the count of either columns or rows // in the Grid. static private int GetCountOfItemsInDimension(IntPtr hwnd, int groupID, IsNewItemInDimension comparer) { // Algorithm: // Get the rect of the item. // Compare it using provided "comparer" with the previously obtained rect of the previous item in the grid // if comparer returns New increase the count int itemsCount = 0; GroupManager.GroupInfo groupInfo = GetGroupInfo(hwnd, groupID); if (groupInfo) { int [] items = groupInfo._items; NativeMethods.Win32Rect rc; NativeMethods.Win32Rect rcNext; // get coordinates of the first item in the grid if (WindowsListView.GetItemRect(hwnd, items[0], NativeMethods.LVIR_BOUNDS, out rc)) { NewItemInDimension result = NewItemInDimension.New; itemsCount++; // at least one exist for (int i = 1; result != NewItemInDimension.Stop && i < groupInfo._count; i++) { if (!WindowsListView.GetItemRect(hwnd, items[i], NativeMethods.LVIR_BOUNDS, out rcNext)) { // Fail to get rc, makes no sense to continue System.Diagnostics.Debug.Assert(false, "GetCountOfItemsInDimension: failed to get item rect"); return(0); } result = comparer(rc, rcNext); if (result == NewItemInDimension.New) { // found a change in the rect // we either have a new column or new raw itemsCount++; // update the rc with the new coordinates rc = rcNext; } } } return(itemsCount); } return(-1); }
// Scroll the specified headerItem horizontally into view. internal void ScrollIntoView(HeaderItem headerItem) { // Check if the parent is a ListView IntPtr hwndParent = NativeMethodsSetLastError.GetAncestor(_hwnd, NativeMethods.GA_PARENT); if (hwndParent != IntPtr.Zero) { if (Misc.GetClassName(hwndParent).IndexOf("SysListView32", StringComparison.Ordinal) >= 0) { // Determine the number of pixels or columns to scroll horizontally. int pixels = 0; int columns = 0; // Get first and last visible header items. HeaderItem firstVisibleHeaderItem; HeaderItem lastVisibleHeaderItem; GetVisibleHeaderItemRange(out firstVisibleHeaderItem, out lastVisibleHeaderItem); if (firstVisibleHeaderItem != null && firstVisibleHeaderItem._item > headerItem._item) { // Scroll backward. pixels = (int)(headerItem.BoundingRectangle.Left - firstVisibleHeaderItem.BoundingRectangle.Left); columns = headerItem._item - firstVisibleHeaderItem._item; } else if (lastVisibleHeaderItem != null && headerItem._item > lastVisibleHeaderItem._item) { // Scroll forward. pixels = (int)(headerItem.BoundingRectangle.Left - lastVisibleHeaderItem.BoundingRectangle.Left); columns = headerItem._item - lastVisibleHeaderItem._item; } int horizontalScrollAmount = 0; if (WindowsListView.IsListMode(hwndParent)) { // In list mode, LVM_SCROLL uses a column count. horizontalScrollAmount = columns; } else if (WindowsListView.IsDetailMode(hwndParent)) { // In details mode, LVM_SCROLL uses a pixel count. horizontalScrollAmount = pixels; } if (horizontalScrollAmount != 0) { Misc.ProxySendMessage(hwndParent, NativeMethods.LVM_SCROLL, new IntPtr(horizontalScrollAmount), IntPtr.Zero); } } } }
// retrieve an id of the group to which this lvitem belongs // valid only if lv has groups enabled static internal int GetGroupID(IntPtr hwnd, int lvItem) { System.Diagnostics.Debug.Assert(WindowsListView.IsGroupViewEnabled(hwnd), "GetGroupID: called when lv does not have groups"); NativeMethods.LVITEM_V6 item = new NativeMethods.LVITEM_V6(); item.mask = NativeMethods.LVIF_GROUPID; item.iItem = lvItem; if (XSendMessage.GetItem(hwnd, ref item)) { return(item.iGroupID); } return(-1); }
private void ScrollToNextWindowEntry(int count) { var maxIndex = WindowsListView.Items.Count - 1; if (WindowsListView.SelectedIndex >= maxIndex) { WindowsListView.SelectedIndex = 0; } else { var newIndex = WindowsListView.SelectedIndex + count; WindowsListView.SelectedIndex = newIndex >= maxIndex ? maxIndex : newIndex; } WindowsListView.ScrollIntoView(WindowsListView.SelectedItem); }
private void ScrollToPreviousWindowEntry(int count) { const int minIndex = 0; if (WindowsListView.SelectedIndex <= 0) { WindowsListView.SelectedIndex = WindowsListView.Items.Count - 1; } else { var newIndex = WindowsListView.SelectedIndex - count; WindowsListView.SelectedIndex = newIndex <= minIndex ? minIndex : newIndex; } WindowsListView.ScrollIntoView(WindowsListView.SelectedItem); }
// Returns the next sibling element in the raw hierarchy. // Peripheral controls have always negative values. // Returns null if no next child internal override ProxySimple GetNextSibling(ProxySimple child) { int item = child._item; if (WindowsListView.IsDetailMode(_hwnd)) { item++; int countCol = GetSubItemCount(_hwnd); if (item >= 0 && item < countCol) { return(CreateListViewSubItem(item)); } } return(null); }
// ------------------------------------------------------ // // Constructors // //------------------------------------------------------ #region Constructors internal ListViewItem(IntPtr hwnd, ProxyFragment parent, int item) : base(hwnd, parent, item) { // Set the strings to return properly the properties. if (WindowsListView.IsDetailMode(hwnd)) { _cControlType = ControlType.DataItem; } else { _cControlType = ControlType.ListItem; } _fHasPersistentID = false; _fIsKeyboardFocusable = true; _isComctrlV6OnOsVerV6orHigher = Misc.IsComctrlV6OnOsVerV6orHigher(hwnd); }
// Returns the first child element in the raw hierarchy. internal override ProxySimple GetFirstChild() { if (IsItemWithCheckbox(_hwnd, _item)) { return(CreateListViewItemCheckbox()); } else if (WindowsListView.IsDetailMode(_hwnd)) { int countCol = GetSubItemCount(_hwnd); if (countCol > 0) { return(CreateListViewSubItem(0)); } } return(null); }
void IScrollItemProvider.ScrollIntoView() { // Make sure that the control is enabled if (!SafeNativeMethods.IsWindowEnabled(_hwnd)) { throw new ElementNotEnabledException(); } // Currently this ignores the alignToTop, as there is no easy way to set something to the bottom of a listbox if (!WindowsListView.Scrollable(_hwnd)) { throw new InvalidOperationException(SR.Get(SRID.OperationCannotBePerformed)); } // ensure item vertical visibility WindowsListView.EnsureVisible(_hwnd, _item, false); }
//------------------------------------------------------ // // Internal Methods // //------------------------------------------------------ #region Internal Methods internal static int GetSubItemCount(IntPtr hwnd) { // Subitems are only available in details mode. if (WindowsListView.IsDetailMode(hwnd)) { IntPtr hwndHeader = WindowsListView.ListViewGetHeader(hwnd); if (hwndHeader == IntPtr.Zero) { return(0); } return(WindowsListView.HeaderItemCount(hwndHeader)); } return(-1); }
// Returns a Proxy element corresponding to the specified screen coordinates. internal override ProxySimple ElementProviderFromPoint(int x, int y) { NativeMethods.Win32Point pt = new NativeMethods.Win32Point(x, y); NativeMethods.LVHITTESTINFO_INTERNAL hitTest = WindowsListView.SubitemHitTest(_hwnd, pt); if ((hitTest.flags & NativeMethods.LVHT_EX_GROUP_HEADER) != 0) { return(this); } if ((hitTest.flags & NativeMethods.LVHT_ONITEM) != 0 && hitTest.iItem >= 0) { // create the item return(new ListViewItem(_hwnd, this, hitTest.iItem)); } // If we did not land on an item we may be at a subset link these only exist // in v6 comctrl and vista or later. if (_isComctrlV6OnOsVerV6orHigher) { // Allocate a local LVHITTESTINFO struct. NativeMethods.LVHITTESTINFO_V6 hitTestNative = new NativeMethods.LVHITTESTINFO_V6(hitTest); unsafe { XSendMessage.XSendGetIndex(_hwnd, NativeMethods.LVM_HITTEST, new IntPtr(-1), new IntPtr(&hitTestNative), Marshal.SizeOf(hitTestNative.GetType())); } if ((hitTestNative.flags & NativeMethods.LVHT_EX_GROUP_SUBSETLINK) != 0) { GroupManager.GroupInfo groupInfo = GetGroupInfo(_hwnd, ID); int [] items = groupInfo._items; if (groupInfo._count <= 0 || groupInfo._count > items.Length) { return(null); } int index = items [groupInfo._count - 1]; return(CreateGroupSubsetLink(index + 1)); } } return(this); }
// retrieve number of columns in the group static private int GetColumnCount(IntPtr hwnd, int groupID) { if (WindowsListView.IsDetailMode(hwnd)) { // check group for validity if (IsGroupValid(hwnd, groupID)) { // When lv in the detail mode, Group will have as many columns // as there header items int column = ListViewItem.GetSubItemCount(hwnd); return((column <= -1) ? 0 : column); } return(-1); } return(GetCountOfItemsInDimension(hwnd, groupID, new IsNewItemInDimension(IsNewColumn))); }
// Returns the previous sibling element in the raw hierarchy. // Peripheral controls have always negative values. // Returns null is no previous internal override ProxySimple GetPreviousSibling(ProxySimple child) { int item = child._item; if (IsItemWithCheckbox(_hwnd, _item) && item == 0) { return(CreateListViewItemCheckbox()); } else if (WindowsListView.IsDetailMode(_hwnd)) { int countCol = GetSubItemCount(_hwnd); if (item > 0 && item < countCol) { return(CreateListViewSubItem(item - 1)); } } return(null); }