public static Point CorrectGetPosition(Visual relativeTo)
{
var w32Mouse = new NativeMethods.Win32Point();
NativeMethods.GetCursorPos(ref w32Mouse);
return(relativeTo.PointFromScreen(new Point(w32Mouse.X, w32Mouse.Y)));
}
// Returns a Proxy element corresponding to the specified screen coordinates.
internal override ProxySimple ElementProviderFromPoint(int x, int y)
{
int x1 = x;
int y1 = y;
NativeMethods.Win32Rect rebarRect = new NativeMethods.Win32Rect();
if (!Misc.GetWindowRect(_hwnd, ref rebarRect))
{
return(null);
}
if (x >= rebarRect.left && x <= rebarRect.right &&
y >= rebarRect.top && y <= rebarRect.bottom)
{
x = x - rebarRect.left;
y = y - rebarRect.top;
NativeMethods.Win32Point pt = new NativeMethods.Win32Point(x, y);
int BandID = getRebarBandIDFromPoint(pt);
if (-1 != BandID)
{
return(CreateRebarItem(BandID).ElementProviderFromPoint(x1, y1));
}
}
return(null);
}
public static Point CorrectGetPosition()
{
var w32Mouse = new NativeMethods.Win32Point();
NativeMethods.GetCursorPos(ref w32Mouse);
return(new Point(w32Mouse.X, w32Mouse.Y));
}
ITextRangeProvider ITextProvider.RangeFromPoint(Point screenLocation)
{
// convert screen to client coordinates.
// (Essentially ScreenToClient but MapWindowPoints accounts for window mirroring using WS_EX_LAYOUTRTL.)
NativeMethods.Win32Point clientLocation = (NativeMethods.Win32Point)screenLocation;
if (!Misc.MapWindowPoints(IntPtr.Zero, WindowHandle, ref clientLocation, 1))
{
return(null);
}
// we have to deal with the possibility that the coordinate is inside the window rect
// but outside the client rect. in that case we just scoot it over so it is at the nearest
// point in the client rect.
NativeMethods.Win32Rect clientRect = new NativeMethods.Win32Rect();
if (!Misc.GetClientRect(WindowHandle, ref clientRect))
{
return(null);
}
clientLocation.x = Math.Max(clientLocation.x, clientRect.left);
clientLocation.x = Math.Min(clientLocation.x, clientRect.right);
clientLocation.y = Math.Max(clientLocation.y, clientRect.top);
clientLocation.y = Math.Min(clientLocation.y, clientRect.bottom);
// get the character at those client coordinates
int start = CharFromPosEx(clientLocation);
return(new WindowsEditBoxRange(this, start, start));
}
// Returns a Proxy element corresponding to the specified screen coordinates.
internal override ProxySimple ElementProviderFromPoint(int x, int y)
{
ProxySimple proxyElement = null;
// Convert screen to client coords.
NativeMethods.Win32Point pt = new NativeMethods.Win32Point(x, y);
if (Misc.MapWindowPoints(System.IntPtr.Zero, _hwnd, ref pt, 1))
{
// GetClientRect
NativeMethods.Win32Rect clientRect = new NativeMethods.Win32Rect();
if (Misc.GetClientRect(_hwnd, ref clientRect))
{
if (Misc.PtInRect(ref clientRect, pt.x, pt.y))
{
int column = (pt.x - _altTabInfo.ptStart.x) / _altTabInfo.cxItem;
int row = (pt.y - _altTabInfo.ptStart.y) / _altTabInfo.cyItem;
if (column >= 0 && column < Columns && row >= 0 && row < Rows)
{
proxyElement = CreateAltTabItem(ItemIndex(row, column));
}
}
}
}
if (proxyElement == null)
{
proxyElement = base.ElementProviderFromPoint(x, y);
}
return(proxyElement);
}
public static Point GetMousePosition()
{
var mouse = new NativeMethods.Win32Point();
NativeMethods.GetCursorPos(ref mouse);
return(new Point(mouse.X, mouse.Y));
}
// Same as clicking on an hyperlink
void IInvokeProvider.Invoke()
{
// Check that button can be clicked.
//
// This state could change anytime.
//
// Make sure that the control is enabled
if (!SafeNativeMethods.IsWindowEnabled(_hwnd))
{
throw new ElementNotEnabledException();
}
if (!SafeNativeMethods.IsWindowVisible(_hwnd))
{
throw new InvalidOperationException(SR.Get(SRID.OperationCannotBePerformed));
}
Misc.SetFocus(_hwnd);
NativeMethods.Win32Point pt = new NativeMethods.Win32Point();
if (GetClickablePoint(out pt, false))
{
Misc.MouseClick(pt.x, pt.y);
}
}
// ------------------------------------------------------
//
// Private Methods
//
// ------------------------------------------------------
#region Private Methods
private static bool ClickableInRect(IntPtr hwnd, ref NativeMethods.Win32Point pt, bool fRiAsInsideRect, ArrayList alIn, ArrayList alOut)
{
if (!SafeNativeMethods.IsWindowVisible(hwnd))
{
return(fRiAsInsideRect);
}
// Get the window rect. If this window has a width and it is effectivly invisible
NativeMethods.Win32Rect rc = new NativeMethods.Win32Rect();
if (!Misc.GetWindowRect(hwnd, ref rc))
{
return(fRiAsInsideRect);
}
if ((rc.right - rc.left) <= 0 || (rc.bottom - rc.top) <= 0)
{
return(fRiAsInsideRect);
}
// Try for transparency...
if (fRiAsInsideRect)
{
int x = (rc.right + rc.left) / 2;
int y = (rc.top + rc.bottom) / 2;
try
{
int lr = Misc.ProxySendMessageInt(hwnd, NativeMethods.WM_NCHITTEST, IntPtr.Zero, NativeMethods.Util.MAKELPARAM(x, y));
if (lr == NativeMethods.HTTRANSPARENT)
{
return(true);
}
}
// PRESHARP: Warning - Catch statements should not have empty bodies
#pragma warning disable 6502
catch (TimeoutException)
{
// Ignore this timeout error. Avalon HwndWrappers have a problem with this WM_NCHITTEST call sometimes.
}
#pragma warning restore 6502
}
// Copy the output bits
alIn.Clear();
alIn.AddRange(alOut);
CPRect rcp = new CPRect(ref rc, false);
ClickablePoint.SplitRect(alIn, ref rcp, alOut, fRiAsInsideRect);
if (!GetClickablePoint(alOut, out pt.x, out pt.y))
{
return(false);
}
return(true);
}
private unsafe int getRebarBandIDFromPoint(NativeMethods.Win32Point pt)
{
NativeMethods.RB_HITTESTINFO rbHitTestInfo = new NativeMethods.RB_HITTESTINFO();
rbHitTestInfo.pt = pt;
rbHitTestInfo.uFlags = 0;
rbHitTestInfo.iBand = 0;
return(XSendMessage.XSendGetIndex(_hwnd, NativeMethods.RB_HITTEST, IntPtr.Zero, new IntPtr(&rbHitTestInfo), Marshal.SizeOf(rbHitTestInfo.GetType())));
}
private void OnWindowMessage(uint messageId, IntPtr wParam, IntPtr lParam)
{
if (messageId != iconData.uCallbackMessage)
{
// Ignore messages not associated with this icon
return;
}
switch (lParam.ToInt32())
{
case (int)NativeMethods.WindowMessages.WM_LBUTTONDOWN:
case (int)NativeMethods.WindowMessages.WM_LBUTTONDBLCLK:
{
// Invoke the command object on left click
if (Command != null && Command.CanExecute(CommandParameter))
{
Command.Execute(CommandParameter);
}
}
break;
case (int)NativeMethods.WindowMessages.WM_RBUTTONDOWN:
{
// Open the context menu on right click
var cursorPosition = new NativeMethods.Win32Point();
NativeMethods.GetCursorPos(ref cursorPosition);
using (var hWndSource = new HwndSource(new HwndSourceParameters()))
{
// Adjust for non-standard DPI settings
var scaleFactor = new Point(hWndSource?.CompositionTarget?.TransformToDevice.M11 ?? 1,
hWndSource?.CompositionTarget?.TransformToDevice.M22 ?? 1);
cursorPosition = new NativeMethods.Win32Point
{
X = (int)(cursorPosition.X / scaleFactor.X), Y = (int)(cursorPosition.Y / scaleFactor.Y)
};
}
if (ContextMenu != null && MessageSink != null)
{
ContextMenu.DataContext = DataContext;
ContextMenu.Placement = PlacementMode.AbsolutePoint;
ContextMenu.HorizontalOffset = cursorPosition.X;
ContextMenu.VerticalOffset = cursorPosition.Y;
ContextMenu.IsOpen = true;
var handle = (PresentationSource.FromVisual(ContextMenu) as HwndSource)?.Handle ??
MessageSink.WindowHandle;
NativeMethods.SetForegroundWindow(handle);
}
}
break;
}
}
// retrieve a point which will invoke the
// headeritem
private bool GetInvokationPoint(out NativeMethods.Win32Point pt)
{
if (!GetClickablePoint(out pt, false))
{
//If there is no clickable point, there is no use of calling MapWindowPoints
return(false);
}
// Map to client
return(Misc.MapWindowPoints(IntPtr.Zero, _hwnd, ref pt, 1));
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
// send an EM_CHARPOS message with an (x,y) coordinate in lParam and
// report the returned character index and line number.
// IMPORTANT: the character index and line number are each 16-bit (half of the lResult).
// the high-order word is zero.
internal void CharFromPos(NativeMethods.Win32Point point, out ushort indexLowWord, out ushort lineLowWord)
{
Debug.Assert(point.x >= 0 && point.x < 65536, "WindowsEditBox.CharFromPos() x coordinate out of range.");
Debug.Assert(point.y >= 0 && point.y < 65536, "WindowsEditBox.CharFromPos() y coordinate out of range.");
// ask edit control for line number and character offset at client coordinates.
// low order word of return value is the character position.
// high order word is the zero-based line index.
IntPtr lParam = NativeMethods.Util.MAKELPARAM(point.x, point.y);
int result = Misc.ProxySendMessageInt(WindowHandle, NativeMethods.EM_CHARFROMPOS, IntPtr.Zero, lParam);
indexLowWord = unchecked ((ushort)(NativeMethods.Util.LOWORD(result)));
lineLowWord = unchecked ((ushort)(NativeMethods.Util.HIWORD(result)));
}
private void Toggle()
{
// Convoluted way fake a mouse action
NativeMethods.Win32Point pt = new NativeMethods.Win32Point();
if (GetClickablePoint(out pt, false))
{
// Mouse method is used here because following methods fail:
// -BM_CLICK message doesn't work with all buttons (e.g. Start)
// -WM_MOUSEACTIVATE + WM_LBUTTONDOWN + WM_LBUTTONUP messages don't work with all buttons
// -WM_KEYDOWN + WM_KEYUP messages for space bar
// -SendKeyboardInput for space bar
// See prior versions of this file for alternative code.
//
Misc.MouseClick(pt.x, pt.y);
}
}
// 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);
}
private void Toggle()
{
// Make sure that the control is enabled
if (!SafeNativeMethods.IsWindowEnabled(_hwnd))
{
throw new ElementNotEnabledException();
}
Misc.SetFocus(_hwnd);
NativeMethods.Win32Rect rc = ListViewCheckBoxRect(_hwnd, _listviewItem);
NativeMethods.Win32Point pt = new NativeMethods.Win32Point((rc.left + rc.right) / 2, (rc.top + rc.bottom) / 2);
if (Misc.MapWindowPoints(IntPtr.Zero, _hwnd, ref pt, 1))
{
// "click" on the checkbox
Misc.ProxySendMessage(_hwnd, NativeMethods.WM_LBUTTONDOWN, (IntPtr)NativeMethods.MK_LBUTTON, NativeMethods.Util.MAKELPARAM(pt.x, pt.y));
Misc.ProxySendMessage(_hwnd, NativeMethods.WM_LBUTTONUP, IntPtr.Zero, NativeMethods.Util.MAKELPARAM(pt.x, pt.y));
}
}
// Adds this element to the selection
void ISelectionItemProvider.AddToSelection()
{
// Make sure that the control is enabled
if (!SafeNativeMethods.IsWindowEnabled(_hwnd))
{
throw new ElementNotEnabledException();
}
// If not selectable, can't add to selection
if (!IsSelectable())
{
throw new InvalidOperationException(SR.Get(SRID.OperationCannotBePerformed));
}
// If already selected, done
if (((ISelectionItemProvider)this).IsSelected)
{
return;
}
// If multiple selections allowed, add requested selection
if (WindowsTab.SupportMultipleSelection(_hwnd) == true)
{
// Press ctrl and mouse click tab
NativeMethods.Win32Point pt = new NativeMethods.Win32Point();
if (GetClickablePoint(out pt, true))
{
Input.SendKeyboardInput(Key.LeftCtrl, true);
Misc.MouseClick(pt.x, pt.y);
Input.SendKeyboardInput(Key.LeftCtrl, false);
return;
}
throw new InvalidOperationException(SR.Get(SRID.OperationCannotBePerformed));
}
// else only single selection allowed
else
{
throw new InvalidOperationException(SR.Get(SRID.DoesNotSupportMultipleSelection));
}
}
// an improvement on EM_CHARFROMPOS that handles edit controls with content greater than 65535 characters.
internal int CharFromPosEx(NativeMethods.Win32Point point)
{
// get the low words of the character position and line number at the coordinate.
ushort indexLowWord, lineLowWord;
CharFromPos(point, out indexLowWord, out lineLowWord);
// we handle multi-line edit controls differently than single line edit controls.
int index;
if (IsMultiline)
{
// note: an optimization would be to call GetTextLength and do the following only if the length is
// greater than 65535.
// to make the line number accurate in the case there are more than 65535 lines we get a 32-bit line number
// for the first visible line then use it to figure out the high-order word of our line number.
// this assumes that there aren't more than 65535 visible lines in the window, which is a
// pretty safe assumption.
int line = IntFromLowWord(lineLowWord, GetFirstVisibleLine());
// to make the character position accurate in case there are more than 65535 characters we use our line number to
// get the character position of the beginning of that line and use it to figure out the high-order word
// of our character position.
// this assumes that there aren't more than 65535 characters on the line before our target character,
// which is a pretty safe assumption.
index = IntFromLowWord(indexLowWord, LineIndex(line));
}
else
{
// single-line edit control
// to make the character position accurate in case there are more than 65535 characters we get a 32-bit
// character position from the first visible character, then use it to figure out the high-order word
// of our character position.
// this assumes that there aren't more than 65535 visible characters in the window,
// which is a pretty safe assumption.
index = IntFromLowWord(indexLowWord, GetFirstVisibleChar());
}
return(index);
}
// Obtain clickable point on the listviewitem
// in the case when one doesnot exist return false
private bool GetListviewitemClickablePoint(out NativeMethods.Win32Point clickPoint)
{
// When this method is called, lv was already scrolled vertically
// hence item is visible veritcally
clickPoint.x = clickPoint.y = 0;
NativeMethods.Win32Rect itemRectangle;
// Obtain rectangle
if (!WindowsListView.GetItemRect(_hwnd, _item, NativeMethods.LVIR_LABEL, out itemRectangle))
{
return(false);
}
if (WindowsListView.IsDetailMode(_hwnd) && !WindowsListView.FullRowSelect(_hwnd))
{
// LVS_REPORT - possible that we may need to scroll horizontaly
//
NativeMethods.Win32Point pt = new NativeMethods.Win32Point(itemRectangle.left, 0);
if (!Misc.MapWindowPoints(IntPtr.Zero, _hwnd, ref pt, 1))
{
return(false);
}
// In client coordinates, hence negative indicates that item is to the left of lv client area
if (pt.x < 0)
{
((IScrollItemProvider)this).ScrollIntoView();
if (!WindowsListView.GetItemRect(_hwnd, _item, NativeMethods.LVIR_LABEL, out itemRectangle))
{
return(false);
}
}
}
clickPoint.x = Math.Min((itemRectangle.left + 5), (itemRectangle.left + itemRectangle.right) / 2);
clickPoint.y = (itemRectangle.top + itemRectangle.bottom) / 2;
return(true);
}
//------------------------------------------------------
//
// Private Methods
//
//------------------------------------------------------
#region Private Methods
private NativeMethods.Win32Rect GetBoundingRect()
{
int columns = this._altTab._altTabInfo.cColumns;
int cxItem = this._altTab._altTabInfo.cxItem;
int cyItem = this._altTab._altTabInfo.cyItem;
int row = _item / columns;
int column = _item % columns;
NativeMethods.Win32Point ptStart = this._altTab._altTabInfo.ptStart;
int left = ptStart.x + column * cxItem;
int top = ptStart.y + row * cyItem;
NativeMethods.Win32Rect itemRect =
new NativeMethods.Win32Rect(left, top, left + cxItem, top + cyItem);
if (!Misc.MapWindowPoints(_hwnd, IntPtr.Zero, ref itemRect, 2))
{
// MapWindowPoints() failed.
itemRect = NativeMethods.Win32Rect.Empty;
}
return(itemRect);
}
// Press a tab
private void Select()
{
if (Misc.IsBitSet(WindowStyle, (NativeMethods.TCS_BUTTONS | NativeMethods.TCS_FOCUSNEVER)))
{
// The TCM_SETCURFOCUS message cannot be used with TCS_FOCUSNEVER
// use a convulated way faking a mouse action
NativeMethods.Win32Point pt = new NativeMethods.Win32Point();
if (GetClickablePoint(out pt, true))
{
// Convert screen coordinates to client coordinates.
if (Misc.MapWindowPoints(IntPtr.Zero, _hwnd, ref pt, 1))
{
Misc.PostMessage(_hwnd, NativeMethods.WM_LBUTTONDOWN, (IntPtr)NativeMethods.MK_LBUTTON, NativeMethods.Util.MAKELPARAM(pt.x, pt.y));
Misc.PostMessage(_hwnd, NativeMethods.WM_LBUTTONUP, (IntPtr)NativeMethods.MK_LBUTTON, NativeMethods.Util.MAKELPARAM(pt.x, pt.y));
}
}
}
else
{
Misc.ProxySendMessage(_hwnd, NativeMethods.TCM_SETCURFOCUS, new IntPtr(_item), IntPtr.Zero);
}
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
// Returns the clickable point on the element
// In the case when clickable point is obtained - method returns true
// In the case when clickable point cannot be obtained - method returns false
internal bool GetClickablePoint(out NativeMethods.Win32Point pt, bool fClipClientRect)
{
NativeMethods.Win32Rect rcItem = new NativeMethods.Win32Rect(BoundingRectangle);
// Intersect the bounding Rectangle with the client rectangle for framents
// and simple items - use the override flag (used mostly for the non client area
if (fClipClientRect && !_fNonClientAreaElement)
{
NativeMethods.Win32Rect rcOutside = new NativeMethods.Win32Rect();
Misc.GetClientRectInScreenCoordinates(_hwnd, ref rcOutside);
if (!Misc.IntersectRect(ref rcItem, ref rcOutside, ref rcItem))
{
pt.x = pt.y = 0;
return(false);
}
}
ArrayList alIn = new ArrayList(100);
ArrayList alOut = new ArrayList(100);
// Get the mid point to start with
pt.x = (rcItem.right - 1 + rcItem.left) / 2;
pt.y = (rcItem.bottom - 1 + rcItem.top) / 2;
alOut.Add(new ClickablePoint.CPRect(ref rcItem, true));
// First go through all the children to exclude whatever is on top
ProxyFragment proxyFrag = this as ProxyFragment;
if (proxyFrag != null)
{
ClickablePoint.ExcludeChildren(proxyFrag, alIn, alOut);
}
return(ClickablePoint.GetPoint(_hwnd, alIn, alOut, ref pt));
}
// Removes this element from the selection
void ISelectionItemProvider.RemoveFromSelection()
{
// Make sure that the control is enabled
if (!SafeNativeMethods.IsWindowEnabled(_hwnd))
{
throw new ElementNotEnabledException();
}
// If not selected, done
if (!((ISelectionItemProvider)this).IsSelected)
{
return;
}
// If multiple selections allowed, unselect element
if (WindowsTab.SupportMultipleSelection(_hwnd) == true)
{
NativeMethods.Win32Point pt = new NativeMethods.Win32Point();
if (GetClickablePoint(out pt, true))
{
Input.SendKeyboardInput(Key.LeftCtrl, true);
Misc.MouseClick(pt.x, pt.y);
Input.SendKeyboardInput(Key.LeftCtrl, false);
return;
}
throw new InvalidOperationException(SR.Get(SRID.OperationCannotBePerformed));
}
// else if button style and single select, send deselectall message
else if (Misc.IsBitSet(WindowStyle, NativeMethods.TCS_BUTTONS))
{
Misc.ProxySendMessage(_hwnd, NativeMethods.TCM_DESELECTALL, IntPtr.Zero, IntPtr.Zero);
return;
}
throw new InvalidOperationException(SR.Get(SRID.OperationCannotBePerformed));
}
internal static extern bool GetPhysicalCursorPos([In, Out] ref NativeMethods.Win32Point pt);
// For Vista getting the part of the titlebar that a tooltip belongs to is more
// reliable across themes
private string GetTitleBarToolTipTextForDWMEnabled()
{
// The mouse is over the titlebar item so get that point on the screen
NativeMethods.Win32Point pt = new NativeMethods.Win32Point();
if (!Misc.GetCursorPos(ref pt))
{
return("");
}
// Find the titlebar hwnd
IntPtr hwnd = UnsafeNativeMethods.WindowFromPhysicalPoint(pt.x, pt.y);
if (hwnd == IntPtr.Zero)
{
return("");
}
// Get the rects for each titlbar part
Rect[] rects = Misc.GetTitlebarRects(hwnd);
// Look from back to front - front is entire titlebar rect
int scan;
for (scan = rects.Length - 1; scan >= 0; scan--)
{
// Not using Misc.PtInRect because including the bounding pixels all the way around gives
// better results; tooltips may appear when the mouse is one or two pixels outside of the
// bounding rect so even this technique may miss.
if (pt.x >= rects[scan].Left && pt.x <= rects[scan].Right && pt.y >= rects[scan].Top && pt.y <= rects[scan].Bottom)
{
break;
}
}
switch (scan)
{
case NativeMethods.INDEX_TITLEBAR_MINBUTTON:
if (Misc.IsBitSet(WindowStyle, NativeMethods.WS_MINIMIZE))
{
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonRestore));
}
else
{
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonMinimize));
}
case NativeMethods.INDEX_TITLEBAR_HELPBUTTON:
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonContextHelp));
case NativeMethods.INDEX_TITLEBAR_MAXBUTTON:
if (Misc.IsBitSet(WindowStyle, NativeMethods.WS_MAXIMIZE))
{
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonRestore));
}
else
{
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonMaximize));
}
case NativeMethods.INDEX_TITLEBAR_CLOSEBUTTON:
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonClose));
case NativeMethods.INDEX_TITLEBAR_SELF:
return(Misc.ProxyGetText(hwnd));
default:
return("");
}
}
private string GetTitleBarToolTipTextHitTest()
{
NativeMethods.Win32Point pt = new NativeMethods.Win32Point();
if (!Misc.GetCursorPos(ref pt))
{
return("");
}
IntPtr hwnd = UnsafeNativeMethods.WindowFromPhysicalPoint(pt.x, pt.y);
if (hwnd == IntPtr.Zero)
{
return("");
}
int hit = Misc.ProxySendMessageInt(hwnd, NativeMethods.WM_NCHITTEST, IntPtr.Zero, NativeMethods.Util.MAKELPARAM(pt.x, pt.y));
switch (hit)
{
case NativeMethods.HTMINBUTTON:
if (Misc.IsBitSet(Misc.GetWindowStyle(hwnd), NativeMethods.WS_MINIMIZE))
{
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonRestore));
}
else
{
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonMinimize));
}
case NativeMethods.HTMAXBUTTON:
if (Misc.IsBitSet(Misc.GetWindowStyle(hwnd), NativeMethods.WS_MAXIMIZE))
{
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonRestore));
}
else
{
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonMaximize));
}
case NativeMethods.HTCLOSE:
case NativeMethods.HTMDICLOSE:
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonClose));
case NativeMethods.HTHELP:
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonContextHelp));
case NativeMethods.HTMDIMINBUTTON:
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonMinimize));
case NativeMethods.HTMDIMAXBUTTON:
return(ST.Get(STID.LocalizedNameWindowsTitleBarButtonMaximize));
case NativeMethods.HTCAPTION:
return(Misc.ProxyGetText(hwnd));
default:
break;
}
return("");
}
public static Point CorrectGetPosition(Visual relativeTo)
{
var w32Mouse = new NativeMethods.Win32Point();
NativeMethods.GetCursorPos(ref w32Mouse);
return relativeTo.PointFromScreen(new Point(w32Mouse.X, w32Mouse.Y));
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
/// <summary>
/// Return a clickable point in a Rectangle for a given window
///
/// The algorithm uses the Windows Z order.
/// To be visible, a rectangle must be enclosed in the hwnd of its parents
/// and must but at least partially on top of the all of siblings as predecessors.
/// In the windows ordered scheme, the first sibling comes on top followed by the
/// next, etc. For a given hwnd, it is sufficent then to look for all the
/// predecessor siblings.
///
/// The scheme below is using recursion. This is make slightly harder to read
/// But makes it a bit more efficent.
/// </summary>
/// <param name="hwnd">Window Handle</param>
/// <param name="alIn">Input list of Rectangles to check GetPoint against</param>
/// <param name="alOut">Output list of Rectangles after the exclusion test</param>
/// <param name="pt">Clickable Point</param>
/// <returns>True if there is a clickable in ro</returns>
static internal bool GetPoint(IntPtr hwnd, ArrayList alIn, ArrayList alOut, ref NativeMethods.Win32Point pt)
{
IntPtr hwndStart = hwnd;
IntPtr hwndCurrent = hwnd;
// Do the window on top exclusion
// Only one level deep is necessary as grand children are clipped to their parent (our children)
for (hwnd = Misc.GetWindow(hwnd, NativeMethods.GW_CHILD); hwnd != IntPtr.Zero; hwnd = Misc.GetWindow(hwnd, NativeMethods.GW_HWNDNEXT))
{
// For siblings, the element bounding rectangle must not be covered by the
// bounding rect of its siblings
if (!ClickableInRect(hwnd, ref pt, true, alIn, alOut))
{
return(false);
}
}
// Check for Parent and Sibling
hwnd = hwndStart;
while (true)
{
hwnd = Misc.GetWindow(hwnd, NativeMethods.GW_HWNDPREV);
if (hwnd == IntPtr.Zero)
{
// Very top of the Windows hierarchy we're done
if (hwndCurrent == _hwndDesktop)
{
break;
}
// The desktop is the parent we should stop here
if (Misc.IsBitSet(Misc.GetWindowStyle(hwndCurrent), NativeMethods.WS_POPUP))
{
hwnd = _hwndDesktop;
}
else
{
// We finished with all the hwnd siblings so get to the parent
hwnd = Misc.GetParent(hwndCurrent);
}
if (hwnd == IntPtr.Zero)
{
// final clipping against the desktop
hwnd = _hwndDesktop;
}
// For parent, the element bounding rectangle must be within it's parent bounding rect
// The desktop contains the bounding rectangle only for the main monintor, the
// The Progman window contains the area for the union of all the monitors
// Substitute the Desktop with the Progman hwnd for clipping calculation
IntPtr hwndClip = hwnd == _hwndDesktop ? _hwndProgman : hwnd;
if (!ClickableInRect(hwndClip, ref pt, false, alIn, alOut))
{
return(false);
}
// Current Parent
hwndCurrent = hwnd;
continue;
}
// For siblings, the element bounding rectangle must not be covered by the
// bounding rect of its siblings
if (!ClickableInRect(hwnd, ref pt, true, alIn, alOut))
{
return(false);
}
}
return(true);
}
private static Point GetMousePosition()
{
NativeMethods.Win32Point w32Mouse = new NativeMethods.Win32Point();
NativeMethods.GetCursorPos(ref w32Mouse);
return(new Point(w32Mouse.X, w32Mouse.Y));
}
internal void GetVisibleRangePoints(out int start, out int end)
{
start = 0;
end = 0;
NativeMethods.Win32Rect rect = new NativeMethods.Win32Rect();
if (Misc.GetClientRect(_hwnd, ref rect) && !rect.IsEmpty)
{
NativeMethods.SIZE size;
string s = new string('E', 1);
GetTextExtentPoint32(s, out size);
NativeMethods.Win32Point ptStart = new NativeMethods.Win32Point((int)(rect.left + size.cx / 4), (int)(rect.top + size.cy / 4));
NativeMethods.Win32Point ptEnd = new NativeMethods.Win32Point((int)(rect.right - size.cx / 8), (int)(rect.bottom - size.cy / 4));
start = CharFromPosEx(ptStart);
end = CharFromPosEx(ptEnd);
if (start > 0)
{
Point pt = PosFromChar(start);
if (pt.X < rect.left)
{
start++;
}
}
}
else
{
// multi-line edit controls are handled differently than single-line edit controls.
if (IsMultiline)
{
// get the line number of the first visible line and start the range at
// the beginning of that line.
int firstLine = GetFirstVisibleLine();
start = LineIndex(firstLine);
// calculate the line number of the first line scrolled off the bottom and
// end the range at the beginning of that line.
end = LineIndex(firstLine + LinesPerPage());
}
else
{
// single-line edit control
// the problem is that using a variable-width font the number of characters visible
// depends on the text that is in the edit control. so we can't just divide the
// width of the edit control by the width of a character.
// so instead we do a binary search of the characters from the first visible character
// to the end of the text to find the visibility boundary.
Rect r = GetRect();
int limit = GetTextLength();
start = GetFirstVisibleChar();
int lo = start; // known visible
int hi = limit; // known non-visible
while (lo + 1 < hi)
{
int mid = (lo + hi) / 2;
Point pt = PosFromChar(mid);
if (pt.X >= r.Left && pt.X < r.Right)
{
lo = mid;
}
else
{
hi = mid;
}
}
// trim off one character unless the range is empty or reaches the end.
end = hi > start && hi < limit ? hi - 1 : hi;
}
}
}
public static Point CorrectGetPosition()
{
var w32Mouse = new NativeMethods.Win32Point();
NativeMethods.GetCursorPos(ref w32Mouse);
return new Point(w32Mouse.X, w32Mouse.Y);
}
public static extern int MapWindowPoints(IntPtr hWndFrom, IntPtr hWndTo, [In, Out] ref NativeMethods.Win32Point pt, int cPoints);
private void Click(NativeMethods.Win32Point clickPoint)
{
Misc.MouseClick(clickPoint.x, clickPoint.y, !WindowsListView.ListViewSingleClickActivate(_hwnd));
}
