Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / Shared / MS / Internal / PointUtil.cs / 1 / PointUtil.cs
using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Windows;
using System.Windows.Media;
using System.Windows.Interop;
using MS.Win32;
#if PRESENTATION_CORE
using MS.Internal.PresentationCore;
#else
#error There is an attempt to use this class from an unexpected assembly.
#endif
namespace MS.Internal
{
///
/// A utility class for converting Point and Rect data between co-ordinate spaces
///
///
/// To avoid confusion, Avalon based Point and Rect variables are prefixed with
/// "point" and "rect" respectively, whereas Win32 POINT and RECT variables are
/// prefixed with "pt" and "rc" respectively.
///
[FriendAccessAllowed] // Built into Core, also used by Framework.
internal static class PointUtil
{
///
/// Convert a point from "client" coordinate space of a window into
/// the coordinate space of the root element of the same window.
///
///
/// Critical: This code accesses presentationSource
/// TreatAsSafe: Transforming a Point is considered safe.
///
[SecurityCritical,SecurityTreatAsSafe]
public static Point ClientToRoot(Point point, PresentationSource presentationSource)
{
bool success = true;
return TryClientToRoot(point, presentationSource, true, out success);
}
[SecurityCritical,SecurityTreatAsSafe]
public static Point TryClientToRoot(Point point, PresentationSource presentationSource, bool throwOnError, out bool success)
{
// Only do if we allow throwing on error or have a valid PresentationSource and CompositionTarget.
if (throwOnError || (presentationSource != null && presentationSource.CompositionTarget != null && !presentationSource.CompositionTarget.IsDisposed))
{
// Convert from pixels into measure units.
point = presentationSource.CompositionTarget.TransformFromDevice.Transform(point);
//
point = TryApplyVisualTransform(point, presentationSource.RootVisual, true, throwOnError, out success);
}
else
{
success = false;
return new Point(0,0);
}
return point;
}
///
/// Convert a point from the coordinate space of a root element of
/// a window into the "client" coordinate space of the same window.
///
///
/// Critical: This code accesses presentationSource
/// TreatAsSafe: Transforming a point is considered safe.
///
[SecurityCritical,SecurityTreatAsSafe]
public static Point RootToClient(Point point, PresentationSource presentationSource)
{
//
point = ApplyVisualTransform(point, presentationSource.RootVisual, false);
// Convert from measure units into pixels.
point = presentationSource.CompositionTarget.TransformToDevice.Transform(point);
return point;
}
///
/// Convert a point from "above" the coordinate space of a
/// visual into the the coordinate space "below" the visual.
///
public static Point ApplyVisualTransform(Point point, Visual v, bool inverse)
{
bool success = true;
return TryApplyVisualTransform(point, v, inverse, true, out success);
}
///
/// Convert a point from "above" the coordinate space of a
/// visual into the the coordinate space "below" the visual.
///
public static Point TryApplyVisualTransform(Point point, Visual v, bool inverse, bool throwOnError, out bool success)
{
success = true;
// Notes:
// 1) First of all the MIL should provide a way of transforming
// a point from the window to the root element.
// 2) A visual can currently have two properties that affect
// its coordinate space:
// A) Transform - any matrix
// B) Offset - a simpification for just a 2D offset.
// 3) In the future a Visual may have other properties that
// affect its coordinate space, which is why the MIL should
// provide this API in the first place.
//
// The following code was copied from the MIL's TransformToAncestor
// method on 12/16/2005.
//
if(v != null)
{
Matrix m = GetVisualTransform(v);
if (inverse)
{
if(throwOnError || m.HasInverse)
{
m.Invert();
}
else
{
success = false;
return new Point(0,0);
}
}
point = m.Transform(point);
}
return point;
}
///
/// Gets the matrix that will convert a point
/// from "above" the coordinate space of a visual
/// into the the coordinate space "below" the visual.
///
internal static Matrix GetVisualTransform(Visual v)
{
if (v != null)
{
Matrix m = Matrix.Identity;
Transform transform = VisualTreeHelper.GetTransform(v);
if (transform != null)
{
Matrix cm = transform.Value;
m = Matrix.Multiply(m, cm);
}
Vector offset = VisualTreeHelper.GetOffset(v);
m.Translate(offset.X, offset.Y);
return m;
}
return Matrix.Identity;
}
///
/// Convert a point from "client" coordinate space of a window into
/// the coordinate space of the screen.
///
///
/// SecurityCritical: This code causes eleveation to unmanaged code via call to GetWindowLong
/// SecurityTreatAsSafe: This data is ok to give out
/// validate all code paths that lead to this.
///
[SecurityCritical, SecurityTreatAsSafe]
public static Point ClientToScreen(Point pointClient, PresentationSource presentationSource)
{
// For now we only know how to use HwndSource.
HwndSource inputSource = presentationSource as HwndSource;
if(inputSource == null)
{
return pointClient;
}
HandleRef handleRef = new HandleRef(inputSource, inputSource.CriticalHandle);
NativeMethods.POINT ptClient = FromPoint(pointClient);
NativeMethods.POINT ptClientRTLAdjusted = AdjustForRightToLeft(ptClient, handleRef);
UnsafeNativeMethods.ClientToScreen(handleRef, ptClientRTLAdjusted);
return ToPoint(ptClientRTLAdjusted);
}
///
/// Convert a point from the coordinate space of the screen into
/// the "client" coordinate space of a window.
///
///
/// Critical: This code accesses presentationSource
/// TreatAsSafe: Transforming a Point is considered safe.
///
[SecurityCritical,SecurityTreatAsSafe]
internal static Point ScreenToClient(Point pointScreen, PresentationSource presentationSource)
{
// For now we only know how to use HwndSource.
HwndSource inputSource = presentationSource as HwndSource;
if(inputSource == null)
{
return pointScreen;
}
HandleRef handleRef = new HandleRef(inputSource, inputSource.CriticalHandle);
NativeMethods.POINT ptClient = FromPoint(pointScreen);
SafeNativeMethods.ScreenToClient(handleRef, ptClient);
ptClient = AdjustForRightToLeft(ptClient, handleRef);
return ToPoint(ptClient);
}
///
/// Converts a rectangle from element co-ordinate space to that of the root visual
///
///
/// The rectangle to be converted
///
///
/// The element whose co-ordinate space you wish to convert from
///
///
/// The PresentationSource which hosts the specified Visual. This is passed in for performance reasons.
///
///
/// The rectangle in the co-ordinate space of the root visual
///
///
/// Critical: This code accesses presentationSource
/// TreatAsSafe: Transforming a point is considered safe.
///
[SecurityCritical, SecurityTreatAsSafe]
internal static Rect ElementToRoot(Rect rectElement, Visual element, PresentationSource presentationSource)
{
GeneralTransform transformElementToRoot = element.TransformToAncestor(presentationSource.RootVisual);
Rect rectRoot = transformElementToRoot.TransformBounds(rectElement);
return rectRoot;
}
///
/// Converts a rectangle from root visual co-ordinate space to Win32 client
///
///
/// RootToClient takes into account device DPI settings to convert to/from Avalon's assumed 96dpi
/// and any "root level" transforms applied to the root such as "right-to-left" inversions.
///
///
/// The rectangle to be converted
///
///
/// The PresentationSource which hosts the root visual. This is passed in for performance reasons.
///
///
/// The rectangle in Win32 client co-ordinate space
///
///
/// Critical: This code accesses presentationSource
/// TreatAsSafe: Transforming a point is considered safe.
///
[SecurityCritical, SecurityTreatAsSafe]
internal static Rect RootToClient(Rect rectRoot, PresentationSource presentationSource)
{
CompositionTarget target = presentationSource.CompositionTarget;
Matrix matrixRootTransform = PointUtil.GetVisualTransform(target.RootVisual);
Rect rectRootUntransformed = Rect.Transform(rectRoot, matrixRootTransform);
Matrix matrixDPI = target.TransformToDevice;
Rect rectClient = Rect.Transform(rectRootUntransformed, matrixDPI);
return rectClient;
}
///
/// Converts a rectangle from Win32 client co-ordinate space to Win32 screen
///
///
///
///
/// The rectangle to be converted
///
///
/// The HwndSource corresponding to the Win32 window containing the rectangle
///
///
/// The rectangle in Win32 screen co-ordinate space
///
///
/// Critical: UnsafeNativeMethods.ClientToScreen
/// TreatAsSafe: Transforming a Point is considered safe.
///
[SecurityCritical, SecurityTreatAsSafe]
internal static Rect ClientToScreen(Rect rectClient, HwndSource hwndSource)
{
Point corner1 = ClientToScreen(rectClient.TopLeft, hwndSource);
Point corner2 = ClientToScreen(rectClient.BottomRight, hwndSource);
return new Rect(corner1, corner2);
}
///
/// Adjusts a POINT to compensate for Win32 RTL conversion logic
///
///
/// MITIGATION: AVALON_RTL_AND_WIN32RTL
///
/// When a window is marked with the WS_EX_LAYOUTRTL style, Win32
/// mirrors the coordinates during the various translation APIs.
///
/// Avalon also sets up mirroring transforms so that we properly
/// mirror the output since we render to DirectX, not a GDI DC.
///
/// Unfortunately, this means that our coordinates are already mirrored
/// by Win32, and Avalon mirrors them again. To work around this
/// problem, we un-mirror the coordinates from Win32 before hit-testing
/// in Avalon.
///
///
/// The POINT to be adjusted
///
///
/// A HandleRef to the hwnd containing the point to be adjusted
///
///
/// The adjusted point
///
internal static NativeMethods.POINT AdjustForRightToLeft(NativeMethods.POINT pt, HandleRef handleRef)
{
int windowStyle = SafeNativeMethods.GetWindowStyle(handleRef, true);
if(( windowStyle & NativeMethods.WS_EX_LAYOUTRTL ) == NativeMethods.WS_EX_LAYOUTRTL)
{
NativeMethods.RECT rcClient = new NativeMethods.RECT();
SafeNativeMethods.GetClientRect(handleRef, ref rcClient);
pt.x = rcClient.right - pt.x;
}
return pt;
}
///
/// Adjusts a RECT to compensate for Win32 RTL conversion logic
///
///
/// MITIGATION: AVALON_RTL_AND_WIN32RTL
///
/// When a window is marked with the WS_EX_LAYOUTRTL style, Win32
/// mirrors the coordinates during the various translation APIs.
///
/// Avalon also sets up mirroring transforms so that we properly
/// mirror the output since we render to DirectX, not a GDI DC.
///
/// Unfortunately, this means that our coordinates are already mirrored
/// by Win32, and Avalon mirrors them again. To work around this
/// problem, we un-mirror the coordinates from Win32 before hit-testing
/// in Avalon.
///
///
/// The RECT to be adjusted
///
///
///
///
/// The adjusted rectangle
///
internal static NativeMethods.RECT AdjustForRightToLeft(NativeMethods.RECT rc, HandleRef handleRef)
{
int windowStyle = SafeNativeMethods.GetWindowStyle(handleRef, true);
if(( windowStyle & NativeMethods.WS_EX_LAYOUTRTL ) == NativeMethods.WS_EX_LAYOUTRTL)
{
NativeMethods.RECT rcClient = new NativeMethods.RECT();
SafeNativeMethods.GetClientRect(handleRef, ref rcClient);
int width = rc.right - rc.left; // preserve width
rc.right = rcClient.right - rc.left; // set right of rect to be as far from right of window as left of rect was from left of window
rc.left = rc.right - width; // restore width by adjusting left and preserving right
}
return rc;
}
///
/// Converts a location from an Avalon Point to a Win32 POINT
///
///
/// Rounds "double" values to the nearest "int"
///
///
/// The location as an Avalon Point
///
///
/// The location as a Win32 POINT
///
internal static NativeMethods.POINT FromPoint(Point point)
{
return new NativeMethods.POINT(DoubleUtil.DoubleToInt(point.X), DoubleUtil.DoubleToInt(point.Y));
}
///
/// Converts a location from a Win32 POINT to an Avalon Point
///
///
/// The location as a Win32 POINT
///
///
/// The location as an Avalon Point
///
internal static Point ToPoint(NativeMethods.POINT pt)
{
return new Point(pt.x, pt.y);
}
///
/// Converts a rectangle from an Avalon Rect to a Win32 RECT
///
///
/// Rounds "double" values to the nearest "int"
///
///
/// The rectangle as an Avalon Rect
///
///
/// The rectangle as a Win32 RECT
///
internal static NativeMethods.RECT FromRect(Rect rect)
{
NativeMethods.RECT rc = new NativeMethods.RECT();
rc.top = DoubleUtil.DoubleToInt(rect.Y);
rc.left = DoubleUtil.DoubleToInt(rect.X);
rc.bottom = DoubleUtil.DoubleToInt(rect.Bottom);
rc.right = DoubleUtil.DoubleToInt(rect.Right);
return rc;
}
///
/// Converts a rectangle from a Win32 RECT to an Avalon Rect
///
///
/// The rectangle as a Win32 RECT
///
///
/// The rectangle as an Avalon Rect
///
internal static Rect ToRect(NativeMethods.RECT rc)
{
Rect rect = new Rect();
rect.X = rc.left;
rect.Y = rc.top;
rect.Width = rc.right - rc.left;
rect.Height = rc.bottom - rc.top;
return rect;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
using System;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Windows;
using System.Windows.Media;
using System.Windows.Interop;
using MS.Win32;
#if PRESENTATION_CORE
using MS.Internal.PresentationCore;
#else
#error There is an attempt to use this class from an unexpected assembly.
#endif
namespace MS.Internal
{
///
/// A utility class for converting Point and Rect data between co-ordinate spaces
///
///
/// To avoid confusion, Avalon based Point and Rect variables are prefixed with
/// "point" and "rect" respectively, whereas Win32 POINT and RECT variables are
/// prefixed with "pt" and "rc" respectively.
///
[FriendAccessAllowed] // Built into Core, also used by Framework.
internal static class PointUtil
{
///
/// Convert a point from "client" coordinate space of a window into
/// the coordinate space of the root element of the same window.
///
///
/// Critical: This code accesses presentationSource
/// TreatAsSafe: Transforming a Point is considered safe.
///
[SecurityCritical,SecurityTreatAsSafe]
public static Point ClientToRoot(Point point, PresentationSource presentationSource)
{
bool success = true;
return TryClientToRoot(point, presentationSource, true, out success);
}
[SecurityCritical,SecurityTreatAsSafe]
public static Point TryClientToRoot(Point point, PresentationSource presentationSource, bool throwOnError, out bool success)
{
// Only do if we allow throwing on error or have a valid PresentationSource and CompositionTarget.
if (throwOnError || (presentationSource != null && presentationSource.CompositionTarget != null && !presentationSource.CompositionTarget.IsDisposed))
{
// Convert from pixels into measure units.
point = presentationSource.CompositionTarget.TransformFromDevice.Transform(point);
//
point = TryApplyVisualTransform(point, presentationSource.RootVisual, true, throwOnError, out success);
}
else
{
success = false;
return new Point(0,0);
}
return point;
}
///
/// Convert a point from the coordinate space of a root element of
/// a window into the "client" coordinate space of the same window.
///
///
/// Critical: This code accesses presentationSource
/// TreatAsSafe: Transforming a point is considered safe.
///
[SecurityCritical,SecurityTreatAsSafe]
public static Point RootToClient(Point point, PresentationSource presentationSource)
{
//
point = ApplyVisualTransform(point, presentationSource.RootVisual, false);
// Convert from measure units into pixels.
point = presentationSource.CompositionTarget.TransformToDevice.Transform(point);
return point;
}
///
/// Convert a point from "above" the coordinate space of a
/// visual into the the coordinate space "below" the visual.
///
public static Point ApplyVisualTransform(Point point, Visual v, bool inverse)
{
bool success = true;
return TryApplyVisualTransform(point, v, inverse, true, out success);
}
///
/// Convert a point from "above" the coordinate space of a
/// visual into the the coordinate space "below" the visual.
///
public static Point TryApplyVisualTransform(Point point, Visual v, bool inverse, bool throwOnError, out bool success)
{
success = true;
// Notes:
// 1) First of all the MIL should provide a way of transforming
// a point from the window to the root element.
// 2) A visual can currently have two properties that affect
// its coordinate space:
// A) Transform - any matrix
// B) Offset - a simpification for just a 2D offset.
// 3) In the future a Visual may have other properties that
// affect its coordinate space, which is why the MIL should
// provide this API in the first place.
//
// The following code was copied from the MIL's TransformToAncestor
// method on 12/16/2005.
//
if(v != null)
{
Matrix m = GetVisualTransform(v);
if (inverse)
{
if(throwOnError || m.HasInverse)
{
m.Invert();
}
else
{
success = false;
return new Point(0,0);
}
}
point = m.Transform(point);
}
return point;
}
///
/// Gets the matrix that will convert a point
/// from "above" the coordinate space of a visual
/// into the the coordinate space "below" the visual.
///
internal static Matrix GetVisualTransform(Visual v)
{
if (v != null)
{
Matrix m = Matrix.Identity;
Transform transform = VisualTreeHelper.GetTransform(v);
if (transform != null)
{
Matrix cm = transform.Value;
m = Matrix.Multiply(m, cm);
}
Vector offset = VisualTreeHelper.GetOffset(v);
m.Translate(offset.X, offset.Y);
return m;
}
return Matrix.Identity;
}
///
/// Convert a point from "client" coordinate space of a window into
/// the coordinate space of the screen.
///
///
/// SecurityCritical: This code causes eleveation to unmanaged code via call to GetWindowLong
/// SecurityTreatAsSafe: This data is ok to give out
/// validate all code paths that lead to this.
///
[SecurityCritical, SecurityTreatAsSafe]
public static Point ClientToScreen(Point pointClient, PresentationSource presentationSource)
{
// For now we only know how to use HwndSource.
HwndSource inputSource = presentationSource as HwndSource;
if(inputSource == null)
{
return pointClient;
}
HandleRef handleRef = new HandleRef(inputSource, inputSource.CriticalHandle);
NativeMethods.POINT ptClient = FromPoint(pointClient);
NativeMethods.POINT ptClientRTLAdjusted = AdjustForRightToLeft(ptClient, handleRef);
UnsafeNativeMethods.ClientToScreen(handleRef, ptClientRTLAdjusted);
return ToPoint(ptClientRTLAdjusted);
}
///
/// Convert a point from the coordinate space of the screen into
/// the "client" coordinate space of a window.
///
///
/// Critical: This code accesses presentationSource
/// TreatAsSafe: Transforming a Point is considered safe.
///
[SecurityCritical,SecurityTreatAsSafe]
internal static Point ScreenToClient(Point pointScreen, PresentationSource presentationSource)
{
// For now we only know how to use HwndSource.
HwndSource inputSource = presentationSource as HwndSource;
if(inputSource == null)
{
return pointScreen;
}
HandleRef handleRef = new HandleRef(inputSource, inputSource.CriticalHandle);
NativeMethods.POINT ptClient = FromPoint(pointScreen);
SafeNativeMethods.ScreenToClient(handleRef, ptClient);
ptClient = AdjustForRightToLeft(ptClient, handleRef);
return ToPoint(ptClient);
}
///
/// Converts a rectangle from element co-ordinate space to that of the root visual
///
///
/// The rectangle to be converted
///
///
/// The element whose co-ordinate space you wish to convert from
///
///
/// The PresentationSource which hosts the specified Visual. This is passed in for performance reasons.
///
///
/// The rectangle in the co-ordinate space of the root visual
///
///
/// Critical: This code accesses presentationSource
/// TreatAsSafe: Transforming a point is considered safe.
///
[SecurityCritical, SecurityTreatAsSafe]
internal static Rect ElementToRoot(Rect rectElement, Visual element, PresentationSource presentationSource)
{
GeneralTransform transformElementToRoot = element.TransformToAncestor(presentationSource.RootVisual);
Rect rectRoot = transformElementToRoot.TransformBounds(rectElement);
return rectRoot;
}
///
/// Converts a rectangle from root visual co-ordinate space to Win32 client
///
///
/// RootToClient takes into account device DPI settings to convert to/from Avalon's assumed 96dpi
/// and any "root level" transforms applied to the root such as "right-to-left" inversions.
///
///
/// The rectangle to be converted
///
///
/// The PresentationSource which hosts the root visual. This is passed in for performance reasons.
///
///
/// The rectangle in Win32 client co-ordinate space
///
///
/// Critical: This code accesses presentationSource
/// TreatAsSafe: Transforming a point is considered safe.
///
[SecurityCritical, SecurityTreatAsSafe]
internal static Rect RootToClient(Rect rectRoot, PresentationSource presentationSource)
{
CompositionTarget target = presentationSource.CompositionTarget;
Matrix matrixRootTransform = PointUtil.GetVisualTransform(target.RootVisual);
Rect rectRootUntransformed = Rect.Transform(rectRoot, matrixRootTransform);
Matrix matrixDPI = target.TransformToDevice;
Rect rectClient = Rect.Transform(rectRootUntransformed, matrixDPI);
return rectClient;
}
///
/// Converts a rectangle from Win32 client co-ordinate space to Win32 screen
///
///
///
///
/// The rectangle to be converted
///
///
/// The HwndSource corresponding to the Win32 window containing the rectangle
///
///
/// The rectangle in Win32 screen co-ordinate space
///
///
/// Critical: UnsafeNativeMethods.ClientToScreen
/// TreatAsSafe: Transforming a Point is considered safe.
///
[SecurityCritical, SecurityTreatAsSafe]
internal static Rect ClientToScreen(Rect rectClient, HwndSource hwndSource)
{
Point corner1 = ClientToScreen(rectClient.TopLeft, hwndSource);
Point corner2 = ClientToScreen(rectClient.BottomRight, hwndSource);
return new Rect(corner1, corner2);
}
///
/// Adjusts a POINT to compensate for Win32 RTL conversion logic
///
///
/// MITIGATION: AVALON_RTL_AND_WIN32RTL
///
/// When a window is marked with the WS_EX_LAYOUTRTL style, Win32
/// mirrors the coordinates during the various translation APIs.
///
/// Avalon also sets up mirroring transforms so that we properly
/// mirror the output since we render to DirectX, not a GDI DC.
///
/// Unfortunately, this means that our coordinates are already mirrored
/// by Win32, and Avalon mirrors them again. To work around this
/// problem, we un-mirror the coordinates from Win32 before hit-testing
/// in Avalon.
///
///
/// The POINT to be adjusted
///
///
/// A HandleRef to the hwnd containing the point to be adjusted
///
///
/// The adjusted point
///
internal static NativeMethods.POINT AdjustForRightToLeft(NativeMethods.POINT pt, HandleRef handleRef)
{
int windowStyle = SafeNativeMethods.GetWindowStyle(handleRef, true);
if(( windowStyle & NativeMethods.WS_EX_LAYOUTRTL ) == NativeMethods.WS_EX_LAYOUTRTL)
{
NativeMethods.RECT rcClient = new NativeMethods.RECT();
SafeNativeMethods.GetClientRect(handleRef, ref rcClient);
pt.x = rcClient.right - pt.x;
}
return pt;
}
///
/// Adjusts a RECT to compensate for Win32 RTL conversion logic
///
///
/// MITIGATION: AVALON_RTL_AND_WIN32RTL
///
/// When a window is marked with the WS_EX_LAYOUTRTL style, Win32
/// mirrors the coordinates during the various translation APIs.
///
/// Avalon also sets up mirroring transforms so that we properly
/// mirror the output since we render to DirectX, not a GDI DC.
///
/// Unfortunately, this means that our coordinates are already mirrored
/// by Win32, and Avalon mirrors them again. To work around this
/// problem, we un-mirror the coordinates from Win32 before hit-testing
/// in Avalon.
///
///
/// The RECT to be adjusted
///
///
///
///
/// The adjusted rectangle
///
internal static NativeMethods.RECT AdjustForRightToLeft(NativeMethods.RECT rc, HandleRef handleRef)
{
int windowStyle = SafeNativeMethods.GetWindowStyle(handleRef, true);
if(( windowStyle & NativeMethods.WS_EX_LAYOUTRTL ) == NativeMethods.WS_EX_LAYOUTRTL)
{
NativeMethods.RECT rcClient = new NativeMethods.RECT();
SafeNativeMethods.GetClientRect(handleRef, ref rcClient);
int width = rc.right - rc.left; // preserve width
rc.right = rcClient.right - rc.left; // set right of rect to be as far from right of window as left of rect was from left of window
rc.left = rc.right - width; // restore width by adjusting left and preserving right
}
return rc;
}
///
/// Converts a location from an Avalon Point to a Win32 POINT
///
///
/// Rounds "double" values to the nearest "int"
///
///
/// The location as an Avalon Point
///
///
/// The location as a Win32 POINT
///
internal static NativeMethods.POINT FromPoint(Point point)
{
return new NativeMethods.POINT(DoubleUtil.DoubleToInt(point.X), DoubleUtil.DoubleToInt(point.Y));
}
///
/// Converts a location from a Win32 POINT to an Avalon Point
///
///
/// The location as a Win32 POINT
///
///
/// The location as an Avalon Point
///
internal static Point ToPoint(NativeMethods.POINT pt)
{
return new Point(pt.x, pt.y);
}
///
/// Converts a rectangle from an Avalon Rect to a Win32 RECT
///
///
/// Rounds "double" values to the nearest "int"
///
///
/// The rectangle as an Avalon Rect
///
///
/// The rectangle as a Win32 RECT
///
internal static NativeMethods.RECT FromRect(Rect rect)
{
NativeMethods.RECT rc = new NativeMethods.RECT();
rc.top = DoubleUtil.DoubleToInt(rect.Y);
rc.left = DoubleUtil.DoubleToInt(rect.X);
rc.bottom = DoubleUtil.DoubleToInt(rect.Bottom);
rc.right = DoubleUtil.DoubleToInt(rect.Right);
return rc;
}
///
/// Converts a rectangle from a Win32 RECT to an Avalon Rect
///
///
/// The rectangle as a Win32 RECT
///
///
/// The rectangle as an Avalon Rect
///
internal static Rect ToRect(NativeMethods.RECT rc)
{
Rect rect = new Rect();
rect.X = rc.left;
rect.Y = rc.top;
rect.Width = rc.right - rc.left;
rect.Height = rc.bottom - rc.top;
return rect;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- HyperLinkField.cs
- HierarchicalDataBoundControl.cs
- FactoryRecord.cs
- UnmanagedMemoryAccessor.cs
- CompositeDuplexBindingElement.cs
- ContextMarshalException.cs
- JavaScriptString.cs
- PageBreakRecord.cs
- HTMLTagNameToTypeMapper.cs
- MessagePartProtectionMode.cs
- DataBoundControlHelper.cs
- GraphicsContainer.cs
- IImplicitResourceProvider.cs
- SimpleFieldTemplateFactory.cs
- HtmlMobileTextWriter.cs
- NavigationPropertyAccessor.cs
- Unit.cs
- DataGridViewTextBoxColumn.cs
- TextServicesProperty.cs
- DataServiceHost.cs
- NavigateEvent.cs
- Span.cs
- TraceRecord.cs
- BaseUriHelper.cs
- AllMembershipCondition.cs
- Vector3DIndependentAnimationStorage.cs
- OleDbRowUpdatingEvent.cs
- GridView.cs
- ResourceReferenceExpressionConverter.cs
- ListenerAdaptersInstallComponent.cs
- PageAdapter.cs
- ComplexPropertyEntry.cs
- RTTrackingProfile.cs
- UnionCqlBlock.cs
- HostingEnvironmentException.cs
- SqlBulkCopyColumnMapping.cs
- EditingMode.cs
- ViewGenResults.cs
- EqualityComparer.cs
- WizardStepCollectionEditor.cs
- LowerCaseStringConverter.cs
- IRCollection.cs
- PlaceHolder.cs
- CommandLineParser.cs
- LocalizationCodeDomSerializer.cs
- PassportIdentity.cs
- RequestBringIntoViewEventArgs.cs
- compensatingcollection.cs
- AccessDataSourceView.cs
- OdbcException.cs
- UserControl.cs
- WebEncodingValidatorAttribute.cs
- SqlProfileProvider.cs
- TextFormatter.cs
- HttpCacheParams.cs
- CharacterString.cs
- SessionStateUtil.cs
- QuaternionAnimationUsingKeyFrames.cs
- SmtpDigestAuthenticationModule.cs
- Color.cs
- AttachedPropertyBrowsableForTypeAttribute.cs
- ListViewCommandEventArgs.cs
- NotificationContext.cs
- WebFormsRootDesigner.cs
- EnumValidator.cs
- StyleConverter.cs
- UserUseLicenseDictionaryLoader.cs
- ProgramNode.cs
- HtmlImage.cs
- SiteMapSection.cs
- ManagedFilter.cs
- NonClientArea.cs
- BrowserCapabilitiesCompiler.cs
- TypeUtil.cs
- FullTextState.cs
- QueueProcessor.cs
- InvalidOperationException.cs
- ConfigurationValidatorAttribute.cs
- GPRECT.cs
- GroupBoxRenderer.cs
- DragEvent.cs
- FloatSumAggregationOperator.cs
- ToolStrip.cs
- StringKeyFrameCollection.cs
- LinkedResource.cs
- TrackBarDesigner.cs
- GPPOINT.cs
- CodeExpressionCollection.cs
- MetaModel.cs
- SaveFileDialogDesigner.cs
- UrlMappingCollection.cs
- Pipe.cs
- SQLByte.cs
- XmlDocument.cs
- followingsibling.cs
- ExtendedProtectionPolicy.cs
- RecommendedAsConfigurableAttribute.cs
- AutoScrollHelper.cs
- HttpHandler.cs
- DataGridViewCellContextMenuStripNeededEventArgs.cs