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
- ToolboxDataAttribute.cs
- StretchValidation.cs
- MarkedHighlightComponent.cs
- EntityDataSourceContextCreatedEventArgs.cs
- FocusChangedEventArgs.cs
- Border.cs
- AttributeData.cs
- XmlIlVisitor.cs
- TreeBuilderBamlTranslator.cs
- AsyncResult.cs
- RepeaterItemEventArgs.cs
- LayoutUtils.cs
- StackSpiller.Bindings.cs
- TextureBrush.cs
- JsonUriDataContract.cs
- XsdDuration.cs
- TableLayoutPanelDesigner.cs
- MultiByteCodec.cs
- SerialPort.cs
- XmlSerializerVersionAttribute.cs
- FileDialog.cs
- Italic.cs
- PasswordBox.cs
- PartialTrustVisibleAssemblyCollection.cs
- TaskFileService.cs
- DbModificationCommandTree.cs
- EllipseGeometry.cs
- KnownTypeDataContractResolver.cs
- ParagraphVisual.cs
- ListBox.cs
- UserControl.cs
- ImmutableCollection.cs
- RedBlackList.cs
- InstalledFontCollection.cs
- RegistryConfigurationProvider.cs
- SqlFacetAttribute.cs
- BitmapCodecInfo.cs
- OleStrCAMarshaler.cs
- OdbcConnectionStringbuilder.cs
- BridgeDataReader.cs
- ViewLoader.cs
- JsonUriDataContract.cs
- ChannelEndpointElement.cs
- CodeTypeOfExpression.cs
- PartialCachingControl.cs
- PeerPresenceInfo.cs
- SrgsGrammarCompiler.cs
- RequestCache.cs
- StructuredType.cs
- ComplusEndpointConfigContainer.cs
- DESCryptoServiceProvider.cs
- RichTextBoxConstants.cs
- XmlDownloadManager.cs
- SchemaType.cs
- RouteParameter.cs
- DocumentCollection.cs
- StatusStrip.cs
- GPPOINT.cs
- DeviceContext2.cs
- Font.cs
- SmiRequestExecutor.cs
- HtmlInputFile.cs
- InstanceNormalEvent.cs
- DataGridViewColumn.cs
- LicenseProviderAttribute.cs
- CreateUserErrorEventArgs.cs
- TypeUtils.cs
- XmlAnyElementAttributes.cs
- SafeFindHandle.cs
- QilStrConcatenator.cs
- UnauthorizedAccessException.cs
- ResourcePart.cs
- SHA1Managed.cs
- CancelRequestedQuery.cs
- XmlCodeExporter.cs
- CallTemplateAction.cs
- ContainerVisual.cs
- DataGridViewCellMouseEventArgs.cs
- XmlCharacterData.cs
- DelegatingTypeDescriptionProvider.cs
- SqlDataSource.cs
- Trustee.cs
- WorkingDirectoryEditor.cs
- ClientApiGenerator.cs
- ValidatingReaderNodeData.cs
- SendActivityDesignerTheme.cs
- BasicExpressionVisitor.cs
- SubordinateTransaction.cs
- XPathException.cs
- MouseEvent.cs
- SQLBytes.cs
- _NTAuthentication.cs
- CompilerParameters.cs
- XmlObjectSerializerContext.cs
- Condition.cs
- ButtonAutomationPeer.cs
- BigInt.cs
- CurrentChangingEventManager.cs
- FullTrustAssemblyCollection.cs
- RoutingBehavior.cs