Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / 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
- SafeNativeMethodsMilCoreApi.cs
- QilPatternFactory.cs
- HtmlControlAdapter.cs
- DiscoveryInnerClientManaged11.cs
- NativeConfigurationLoader.cs
- DbConnectionPool.cs
- typedescriptorpermissionattribute.cs
- WebPartEditorCancelVerb.cs
- LateBoundBitmapDecoder.cs
- CookielessHelper.cs
- HttpResponseInternalWrapper.cs
- ProofTokenCryptoHandle.cs
- ByteKeyFrameCollection.cs
- MissingSatelliteAssemblyException.cs
- UserControl.cs
- FormsAuthenticationConfiguration.cs
- SqlDataSourceStatusEventArgs.cs
- ResXFileRef.cs
- HostingEnvironmentSection.cs
- GrammarBuilderPhrase.cs
- ListViewInsertedEventArgs.cs
- SecureConversationDriver.cs
- Rect.cs
- DataGridViewCellParsingEventArgs.cs
- NetworkCredential.cs
- SqlParameter.cs
- CompressedStack.cs
- MappingException.cs
- InternalCache.cs
- _SafeNetHandles.cs
- MimeFormReflector.cs
- CodeMemberProperty.cs
- FixedHyperLink.cs
- SelectionPattern.cs
- UrlMapping.cs
- RowVisual.cs
- InvalidCastException.cs
- GraphicsState.cs
- validationstate.cs
- AliasedSlot.cs
- Pkcs7Recipient.cs
- ImageListDesigner.cs
- Visual3DCollection.cs
- OdbcPermission.cs
- DispatcherOperation.cs
- loginstatus.cs
- AssemblyGen.cs
- XPathAxisIterator.cs
- DocumentViewerAutomationPeer.cs
- StylesEditorDialog.cs
- SelectedDatesCollection.cs
- MasterPage.cs
- EntityObject.cs
- SQLBytes.cs
- ContainerCodeDomSerializer.cs
- ObjectFullSpanRewriter.cs
- OleDbConnection.cs
- TypeConverterHelper.cs
- WindowsRegion.cs
- DLinqDataModelProvider.cs
- AtlasWeb.Designer.cs
- ClientUriBehavior.cs
- DesignerView.xaml.cs
- SpellCheck.cs
- ArglessEventHandlerProxy.cs
- loginstatus.cs
- XmlQualifiedName.cs
- ArrayWithOffset.cs
- MetabaseServerConfig.cs
- PasswordDeriveBytes.cs
- _TransmitFileOverlappedAsyncResult.cs
- BufferedStream.cs
- ControlAdapter.cs
- BitConverter.cs
- ArgumentNullException.cs
- PerformanceCounterManager.cs
- ResourceManager.cs
- PersonalizationState.cs
- SaveFileDialog.cs
- PageContent.cs
- DataGridItemCollection.cs
- UpdateProgress.cs
- DeviceContexts.cs
- XNodeValidator.cs
- EdmMember.cs
- DisplayMemberTemplateSelector.cs
- StreamingContext.cs
- __Error.cs
- KnowledgeBase.cs
- XmlSchemaIdentityConstraint.cs
- PaintValueEventArgs.cs
- ExtenderProvidedPropertyAttribute.cs
- XmlRawWriter.cs
- RectangleGeometry.cs
- HtmlControl.cs
- ActivityTrace.cs
- WindowsTooltip.cs
- ObjectTypeMapping.cs
- ControlCachePolicy.cs
- OdbcDataReader.cs