Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Core / CSharp / System / Windows / Media / Generated / RenderDataDrawingContext.cs / 1305600 / RenderDataDrawingContext.cs
//----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
// This file was generated, please do not edit it directly.
//
// Please see http://wiki/default.aspx/Microsoft.Projects.Avalon/MilCodeGen.html for more information.
//
//---------------------------------------------------------------------------
using MS.Internal;
using MS.Internal.PresentationCore;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Windows.Threading;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Media.Composition;
using System.Windows.Media.Effects;
using System.Windows.Media.Imaging;
using System.Windows.Media.Media3D;
using System.Diagnostics;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
using System.Security;
using System.Security.Permissions;
namespace System.Windows.Media
{
///
/// RenderDataDrawingContext - A DrawingContext which produces a Drawing.
///
internal partial class RenderDataDrawingContext : DrawingContext
{
///
/// DrawLine -
/// Draws a line with the specified pen.
/// Note that this API does not accept a Brush, as there is no area to fill.
///
/// The Pen with which to stroke the line.
/// The start Point for the line.
/// The end Point for the line.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawLine(
Pen pen,
Point point0,
Point point1)
{
VerifyApiNonstructuralChange();
if (pen == null)
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawLine(const)");
#endif
unsafe
{
EnsureRenderData();
// Always assume visual and drawing brushes need realization updates
MILCMD_DRAW_LINE record =
new MILCMD_DRAW_LINE (
_renderData.AddDependentResource(pen),
point0,
point1
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_LINE) == 40);
_renderData.WriteDataRecord(MILCMD.MilDrawLine,
(byte*)&record,
40 /* sizeof(MILCMD_DRAW_LINE) */);
}
}
///
/// DrawLine -
/// Draws a line with the specified pen.
/// Note that this API does not accept a Brush, as there is no area to fill.
///
/// The Pen with which to stroke the line.
/// The start Point for the line.
/// Optional AnimationClock for point0.
/// The end Point for the line.
/// Optional AnimationClock for point1.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawLine(
Pen pen,
Point point0,
AnimationClock point0Animations,
Point point1,
AnimationClock point1Animations)
{
VerifyApiNonstructuralChange();
if (pen == null)
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawLine(animate)");
#endif
unsafe
{
EnsureRenderData();
// Always assume visual and drawing brushes need realization updates
UInt32 hPoint0Animations = CompositionResourceManager.InvalidResourceHandle;
UInt32 hPoint1Animations = CompositionResourceManager.InvalidResourceHandle;
hPoint0Animations = UseAnimations(point0, point0Animations);
hPoint1Animations = UseAnimations(point1, point1Animations);
MILCMD_DRAW_LINE_ANIMATE record =
new MILCMD_DRAW_LINE_ANIMATE (
_renderData.AddDependentResource(pen),
point0,
hPoint0Animations,
point1,
hPoint1Animations
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_LINE_ANIMATE) == 48);
_renderData.WriteDataRecord(MILCMD.MilDrawLineAnimate,
(byte*)&record,
48 /* sizeof(MILCMD_DRAW_LINE_ANIMATE) */);
}
}
///
/// DrawRectangle -
/// Draw a rectangle with the provided Brush and/or Pen.
/// If both the Brush and Pen are null this call is a no-op.
///
///
/// The Brush with which to fill the rectangle.
/// This is optional, and can be null, in which case no fill is performed.
///
///
/// The Pen with which to stroke the rectangle.
/// This is optional, and can be null, in which case no stroke is performed.
///
/// The Rect to fill and/or stroke.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawRectangle(
Brush brush,
Pen pen,
Rect rectangle)
{
VerifyApiNonstructuralChange();
if ((brush == null) && (pen == null))
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawRectangle(const)");
#endif
unsafe
{
EnsureRenderData();
// Always assume visual and drawing brushes need realization updates
MILCMD_DRAW_RECTANGLE record =
new MILCMD_DRAW_RECTANGLE (
_renderData.AddDependentResource(brush),
_renderData.AddDependentResource(pen),
rectangle
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_RECTANGLE) == 40);
_renderData.WriteDataRecord(MILCMD.MilDrawRectangle,
(byte*)&record,
40 /* sizeof(MILCMD_DRAW_RECTANGLE) */);
}
}
///
/// DrawRectangle -
/// Draw a rectangle with the provided Brush and/or Pen.
/// If both the Brush and Pen are null this call is a no-op.
///
///
/// The Brush with which to fill the rectangle.
/// This is optional, and can be null, in which case no fill is performed.
///
///
/// The Pen with which to stroke the rectangle.
/// This is optional, and can be null, in which case no stroke is performed.
///
/// The Rect to fill and/or stroke.
/// Optional AnimationClock for rectangle.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawRectangle(
Brush brush,
Pen pen,
Rect rectangle,
AnimationClock rectangleAnimations)
{
VerifyApiNonstructuralChange();
if ((brush == null) && (pen == null))
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawRectangle(animate)");
#endif
unsafe
{
EnsureRenderData();
// Always assume visual and drawing brushes need realization updates
UInt32 hRectangleAnimations = CompositionResourceManager.InvalidResourceHandle;
hRectangleAnimations = UseAnimations(rectangle, rectangleAnimations);
MILCMD_DRAW_RECTANGLE_ANIMATE record =
new MILCMD_DRAW_RECTANGLE_ANIMATE (
_renderData.AddDependentResource(brush),
_renderData.AddDependentResource(pen),
rectangle,
hRectangleAnimations
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_RECTANGLE_ANIMATE) == 48);
_renderData.WriteDataRecord(MILCMD.MilDrawRectangleAnimate,
(byte*)&record,
48 /* sizeof(MILCMD_DRAW_RECTANGLE_ANIMATE) */);
}
}
///
/// DrawRoundedRectangle -
/// Draw a rounded rectangle with the provided Brush and/or Pen.
/// If both the Brush and Pen are null this call is a no-op.
///
///
/// The Brush with which to fill the rectangle.
/// This is optional, and can be null, in which case no fill is performed.
///
///
/// The Pen with which to stroke the rectangle.
/// This is optional, and can be null, in which case no stroke is performed.
///
/// The Rect to fill and/or stroke.
///
/// The radius in the X dimension of the rounded corners of this
/// rounded Rect. This value will be clamped to the range [0..rectangle.Width/2]
///
///
/// The radius in the Y dimension of the rounded corners of this
/// rounded Rect. This value will be clamped to the range [0..rectangle.Height/2].
///
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawRoundedRectangle(
Brush brush,
Pen pen,
Rect rectangle,
Double radiusX,
Double radiusY)
{
VerifyApiNonstructuralChange();
if ((brush == null) && (pen == null))
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawRoundedRectangle(const)");
#endif
unsafe
{
EnsureRenderData();
// Always assume visual and drawing brushes need realization updates
MILCMD_DRAW_ROUNDED_RECTANGLE record =
new MILCMD_DRAW_ROUNDED_RECTANGLE (
_renderData.AddDependentResource(brush),
_renderData.AddDependentResource(pen),
rectangle,
radiusX,
radiusY
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_ROUNDED_RECTANGLE) == 56);
_renderData.WriteDataRecord(MILCMD.MilDrawRoundedRectangle,
(byte*)&record,
56 /* sizeof(MILCMD_DRAW_ROUNDED_RECTANGLE) */);
}
}
///
/// DrawRoundedRectangle -
/// Draw a rounded rectangle with the provided Brush and/or Pen.
/// If both the Brush and Pen are null this call is a no-op.
///
///
/// The Brush with which to fill the rectangle.
/// This is optional, and can be null, in which case no fill is performed.
///
///
/// The Pen with which to stroke the rectangle.
/// This is optional, and can be null, in which case no stroke is performed.
///
/// The Rect to fill and/or stroke.
/// Optional AnimationClock for rectangle.
///
/// The radius in the X dimension of the rounded corners of this
/// rounded Rect. This value will be clamped to the range [0..rectangle.Width/2]
///
/// Optional AnimationClock for radiusX.
///
/// The radius in the Y dimension of the rounded corners of this
/// rounded Rect. This value will be clamped to the range [0..rectangle.Height/2].
///
/// Optional AnimationClock for radiusY.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawRoundedRectangle(
Brush brush,
Pen pen,
Rect rectangle,
AnimationClock rectangleAnimations,
Double radiusX,
AnimationClock radiusXAnimations,
Double radiusY,
AnimationClock radiusYAnimations)
{
VerifyApiNonstructuralChange();
if ((brush == null) && (pen == null))
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawRoundedRectangle(animate)");
#endif
unsafe
{
EnsureRenderData();
// Always assume visual and drawing brushes need realization updates
UInt32 hRectangleAnimations = CompositionResourceManager.InvalidResourceHandle;
UInt32 hRadiusXAnimations = CompositionResourceManager.InvalidResourceHandle;
UInt32 hRadiusYAnimations = CompositionResourceManager.InvalidResourceHandle;
hRectangleAnimations = UseAnimations(rectangle, rectangleAnimations);
hRadiusXAnimations = UseAnimations(radiusX, radiusXAnimations);
hRadiusYAnimations = UseAnimations(radiusY, radiusYAnimations);
MILCMD_DRAW_ROUNDED_RECTANGLE_ANIMATE record =
new MILCMD_DRAW_ROUNDED_RECTANGLE_ANIMATE (
_renderData.AddDependentResource(brush),
_renderData.AddDependentResource(pen),
rectangle,
hRectangleAnimations,
radiusX,
hRadiusXAnimations,
radiusY,
hRadiusYAnimations
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_ROUNDED_RECTANGLE_ANIMATE) == 72);
_renderData.WriteDataRecord(MILCMD.MilDrawRoundedRectangleAnimate,
(byte*)&record,
72 /* sizeof(MILCMD_DRAW_ROUNDED_RECTANGLE_ANIMATE) */);
}
}
///
/// DrawEllipse -
/// Draw an ellipse with the provided Brush and/or Pen.
/// If both the Brush and Pen are null this call is a no-op.
///
///
/// The Brush with which to fill the ellipse.
/// This is optional, and can be null, in which case no fill is performed.
///
///
/// The Pen with which to stroke the ellipse.
/// This is optional, and can be null, in which case no stroke is performed.
///
///
/// The center of the ellipse to fill and/or stroke.
///
///
/// The radius in the X dimension of the ellipse.
/// The absolute value of the radius provided will be used.
///
///
/// The radius in the Y dimension of the ellipse.
/// The absolute value of the radius provided will be used.
///
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawEllipse(
Brush brush,
Pen pen,
Point center,
Double radiusX,
Double radiusY)
{
VerifyApiNonstructuralChange();
if ((brush == null) && (pen == null))
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawEllipse(const)");
#endif
unsafe
{
EnsureRenderData();
// Always assume visual and drawing brushes need realization updates
MILCMD_DRAW_ELLIPSE record =
new MILCMD_DRAW_ELLIPSE (
_renderData.AddDependentResource(brush),
_renderData.AddDependentResource(pen),
center,
radiusX,
radiusY
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_ELLIPSE) == 40);
_renderData.WriteDataRecord(MILCMD.MilDrawEllipse,
(byte*)&record,
40 /* sizeof(MILCMD_DRAW_ELLIPSE) */);
}
}
///
/// DrawEllipse -
/// Draw an ellipse with the provided Brush and/or Pen.
/// If both the Brush and Pen are null this call is a no-op.
///
///
/// The Brush with which to fill the ellipse.
/// This is optional, and can be null, in which case no fill is performed.
///
///
/// The Pen with which to stroke the ellipse.
/// This is optional, and can be null, in which case no stroke is performed.
///
///
/// The center of the ellipse to fill and/or stroke.
///
/// Optional AnimationClock for center.
///
/// The radius in the X dimension of the ellipse.
/// The absolute value of the radius provided will be used.
///
/// Optional AnimationClock for radiusX.
///
/// The radius in the Y dimension of the ellipse.
/// The absolute value of the radius provided will be used.
///
/// Optional AnimationClock for radiusY.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawEllipse(
Brush brush,
Pen pen,
Point center,
AnimationClock centerAnimations,
Double radiusX,
AnimationClock radiusXAnimations,
Double radiusY,
AnimationClock radiusYAnimations)
{
VerifyApiNonstructuralChange();
if ((brush == null) && (pen == null))
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawEllipse(animate)");
#endif
unsafe
{
EnsureRenderData();
// Always assume visual and drawing brushes need realization updates
UInt32 hCenterAnimations = CompositionResourceManager.InvalidResourceHandle;
UInt32 hRadiusXAnimations = CompositionResourceManager.InvalidResourceHandle;
UInt32 hRadiusYAnimations = CompositionResourceManager.InvalidResourceHandle;
hCenterAnimations = UseAnimations(center, centerAnimations);
hRadiusXAnimations = UseAnimations(radiusX, radiusXAnimations);
hRadiusYAnimations = UseAnimations(radiusY, radiusYAnimations);
MILCMD_DRAW_ELLIPSE_ANIMATE record =
new MILCMD_DRAW_ELLIPSE_ANIMATE (
_renderData.AddDependentResource(brush),
_renderData.AddDependentResource(pen),
center,
hCenterAnimations,
radiusX,
hRadiusXAnimations,
radiusY,
hRadiusYAnimations
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_ELLIPSE_ANIMATE) == 56);
_renderData.WriteDataRecord(MILCMD.MilDrawEllipseAnimate,
(byte*)&record,
56 /* sizeof(MILCMD_DRAW_ELLIPSE_ANIMATE) */);
}
}
///
/// DrawGeometry -
/// Draw a Geometry with the provided Brush and/or Pen.
/// If both the Brush and Pen are null this call is a no-op.
///
///
/// The Brush with which to fill the Geometry.
/// This is optional, and can be null, in which case no fill is performed.
///
///
/// The Pen with which to stroke the Geometry.
/// This is optional, and can be null, in which case no stroke is performed.
///
/// The Geometry to fill and/or stroke.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawGeometry(
Brush brush,
Pen pen,
Geometry geometry)
{
VerifyApiNonstructuralChange();
if (((brush == null) && (pen == null)) || (geometry == null))
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawGeometry(const)");
#endif
unsafe
{
EnsureRenderData();
// Always assume visual and drawing brushes need realization updates
MILCMD_DRAW_GEOMETRY record =
new MILCMD_DRAW_GEOMETRY (
_renderData.AddDependentResource(brush),
_renderData.AddDependentResource(pen),
_renderData.AddDependentResource(geometry)
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_GEOMETRY) == 16);
_renderData.WriteDataRecord(MILCMD.MilDrawGeometry,
(byte*)&record,
16 /* sizeof(MILCMD_DRAW_GEOMETRY) */);
}
}
///
/// DrawImage -
/// Draw an Image into the region specified by the Rect.
/// The Image will potentially be stretched and distorted to fit the Rect.
/// For more fine grained control, consider filling a Rect with an ImageBrush via
/// DrawRectangle.
///
/// The ImageSource to draw.
///
/// The Rect into which the ImageSource will be fit.
///
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawImage(
ImageSource imageSource,
Rect rectangle)
{
VerifyApiNonstructuralChange();
if (imageSource == null)
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawImage(const)");
#endif
unsafe
{
EnsureRenderData();
MILCMD_DRAW_IMAGE record =
new MILCMD_DRAW_IMAGE (
_renderData.AddDependentResource(imageSource),
rectangle
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_IMAGE) == 40);
_renderData.WriteDataRecord(MILCMD.MilDrawImage,
(byte*)&record,
40 /* sizeof(MILCMD_DRAW_IMAGE) */);
}
}
///
/// DrawImage -
/// Draw an Image into the region specified by the Rect.
/// The Image will potentially be stretched and distorted to fit the Rect.
/// For more fine grained control, consider filling a Rect with an ImageBrush via
/// DrawRectangle.
///
/// The ImageSource to draw.
///
/// The Rect into which the ImageSource will be fit.
///
/// Optional AnimationClock for rectangle.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawImage(
ImageSource imageSource,
Rect rectangle,
AnimationClock rectangleAnimations)
{
VerifyApiNonstructuralChange();
if (imageSource == null)
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawImage(animate)");
#endif
unsafe
{
EnsureRenderData();
UInt32 hRectangleAnimations = CompositionResourceManager.InvalidResourceHandle;
hRectangleAnimations = UseAnimations(rectangle, rectangleAnimations);
MILCMD_DRAW_IMAGE_ANIMATE record =
new MILCMD_DRAW_IMAGE_ANIMATE (
_renderData.AddDependentResource(imageSource),
rectangle,
hRectangleAnimations
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_IMAGE_ANIMATE) == 40);
_renderData.WriteDataRecord(MILCMD.MilDrawImageAnimate,
(byte*)&record,
40 /* sizeof(MILCMD_DRAW_IMAGE_ANIMATE) */);
}
}
///
/// DrawGlyphRun -
/// Draw a GlyphRun
///
///
/// Foreground brush to draw the GlyphRun with.
///
/// The GlyphRun to draw.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawGlyphRun(
Brush foregroundBrush,
GlyphRun glyphRun)
{
VerifyApiNonstructuralChange();
if ((foregroundBrush == null) || (glyphRun == null))
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawGlyphRun(const)");
#endif
unsafe
{
EnsureRenderData();
// Always assume visual and drawing brushes need realization updates
MILCMD_DRAW_GLYPH_RUN record =
new MILCMD_DRAW_GLYPH_RUN (
_renderData.AddDependentResource(foregroundBrush),
_renderData.AddDependentResource(glyphRun)
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_GLYPH_RUN) == 8);
_renderData.WriteDataRecord(MILCMD.MilDrawGlyphRun,
(byte*)&record,
8 /* sizeof(MILCMD_DRAW_GLYPH_RUN) */);
}
}
///
/// DrawDrawing -
/// Draw a Drawing by appending a sub-Drawing to the current Drawing.
///
/// The drawing to draw.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawDrawing(
Drawing drawing)
{
VerifyApiNonstructuralChange();
if (drawing == null)
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawDrawing(const)");
#endif
unsafe
{
EnsureRenderData();
MILCMD_DRAW_DRAWING record =
new MILCMD_DRAW_DRAWING (
_renderData.AddDependentResource(drawing)
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_DRAWING) == 8);
_renderData.WriteDataRecord(MILCMD.MilDrawDrawing,
(byte*)&record,
8 /* sizeof(MILCMD_DRAW_DRAWING) */);
}
}
///
/// DrawVideo -
/// Draw a Video into the region specified by the Rect.
/// The Video will potentially be stretched and distorted to fit the Rect.
/// For more fine grained control, consider filling a Rect with an VideoBrush via
/// DrawRectangle.
///
/// The MediaPlayer to draw.
/// The Rect into which the media will be fit.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawVideo(
MediaPlayer player,
Rect rectangle)
{
VerifyApiNonstructuralChange();
if (player == null)
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawVideo(const)");
#endif
unsafe
{
EnsureRenderData();
MILCMD_DRAW_VIDEO record =
new MILCMD_DRAW_VIDEO (
_renderData.AddDependentResource(player),
rectangle
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_VIDEO) == 40);
_renderData.WriteDataRecord(MILCMD.MilDrawVideo,
(byte*)&record,
40 /* sizeof(MILCMD_DRAW_VIDEO) */);
}
}
///
/// DrawVideo -
/// Draw a Video into the region specified by the Rect.
/// The Video will potentially be stretched and distorted to fit the Rect.
/// For more fine grained control, consider filling a Rect with an VideoBrush via
/// DrawRectangle.
///
/// The MediaPlayer to draw.
/// The Rect into which the media will be fit.
/// Optional AnimationClock for rectangle.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void DrawVideo(
MediaPlayer player,
Rect rectangle,
AnimationClock rectangleAnimations)
{
VerifyApiNonstructuralChange();
if (player == null)
{
return;
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("DrawVideo(animate)");
#endif
unsafe
{
EnsureRenderData();
UInt32 hRectangleAnimations = CompositionResourceManager.InvalidResourceHandle;
hRectangleAnimations = UseAnimations(rectangle, rectangleAnimations);
MILCMD_DRAW_VIDEO_ANIMATE record =
new MILCMD_DRAW_VIDEO_ANIMATE (
_renderData.AddDependentResource(player),
rectangle,
hRectangleAnimations
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_DRAW_VIDEO_ANIMATE) == 40);
_renderData.WriteDataRecord(MILCMD.MilDrawVideoAnimate,
(byte*)&record,
40 /* sizeof(MILCMD_DRAW_VIDEO_ANIMATE) */);
}
}
///
/// PushClip -
/// Push a clip region, which will apply to all drawing primitives until the
/// corresponding Pop call.
///
/// The Geometry to which we will clip.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void PushClip(
Geometry clipGeometry)
{
VerifyApiNonstructuralChange();
#if DEBUG
MediaTrace.DrawingContextOp.Trace("PushClip(const)");
#endif
unsafe
{
EnsureRenderData();
MILCMD_PUSH_CLIP record =
new MILCMD_PUSH_CLIP (
_renderData.AddDependentResource(clipGeometry)
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_PUSH_CLIP) == 8);
_renderData.WriteDataRecord(MILCMD.MilPushClip,
(byte*)&record,
8 /* sizeof(MILCMD_PUSH_CLIP) */);
}
_stackDepth++;
}
///
/// PushOpacityMask -
/// Push an opacity mask which will blend the composite of all drawing primitives added
/// until the corresponding Pop call.
///
/// The opacity mask
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void PushOpacityMask(
Brush opacityMask)
{
VerifyApiNonstructuralChange();
#if DEBUG
MediaTrace.DrawingContextOp.Trace("PushOpacityMask(const)");
#endif
unsafe
{
EnsureRenderData();
// Always assume visual and drawing brushes need realization updates
MILCMD_PUSH_OPACITY_MASK record =
new MILCMD_PUSH_OPACITY_MASK (
_renderData.AddDependentResource(opacityMask)
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_PUSH_OPACITY_MASK) == 24);
_renderData.WriteDataRecord(MILCMD.MilPushOpacityMask,
(byte*)&record,
24 /* sizeof(MILCMD_PUSH_OPACITY_MASK) */);
}
_stackDepth++;
}
///
/// PushOpacity -
/// Push an opacity which will blend the composite of all drawing primitives added
/// until the corresponding Pop call.
///
///
/// The opacity with which to blend - 0 is transparent, 1 is opaque.
///
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void PushOpacity(
Double opacity)
{
VerifyApiNonstructuralChange();
#if DEBUG
MediaTrace.DrawingContextOp.Trace("PushOpacity(const)");
#endif
unsafe
{
EnsureRenderData();
MILCMD_PUSH_OPACITY record =
new MILCMD_PUSH_OPACITY (
opacity
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_PUSH_OPACITY) == 8);
_renderData.WriteDataRecord(MILCMD.MilPushOpacity,
(byte*)&record,
8 /* sizeof(MILCMD_PUSH_OPACITY) */);
}
_stackDepth++;
}
///
/// PushOpacity -
/// Push an opacity which will blend the composite of all drawing primitives added
/// until the corresponding Pop call.
///
///
/// The opacity with which to blend - 0 is transparent, 1 is opaque.
///
/// Optional AnimationClock for opacity.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void PushOpacity(
Double opacity,
AnimationClock opacityAnimations)
{
VerifyApiNonstructuralChange();
#if DEBUG
MediaTrace.DrawingContextOp.Trace("PushOpacity(animate)");
#endif
unsafe
{
EnsureRenderData();
UInt32 hOpacityAnimations = CompositionResourceManager.InvalidResourceHandle;
hOpacityAnimations = UseAnimations(opacity, opacityAnimations);
MILCMD_PUSH_OPACITY_ANIMATE record =
new MILCMD_PUSH_OPACITY_ANIMATE (
opacity,
hOpacityAnimations
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_PUSH_OPACITY_ANIMATE) == 16);
_renderData.WriteDataRecord(MILCMD.MilPushOpacityAnimate,
(byte*)&record,
16 /* sizeof(MILCMD_PUSH_OPACITY_ANIMATE) */);
}
_stackDepth++;
}
///
/// PushTransform -
/// Push a Transform which will apply to all drawing operations until the corresponding
/// Pop.
///
/// The Transform to push.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void PushTransform(
Transform transform)
{
VerifyApiNonstructuralChange();
#if DEBUG
MediaTrace.DrawingContextOp.Trace("PushTransform(const)");
#endif
unsafe
{
EnsureRenderData();
MILCMD_PUSH_TRANSFORM record =
new MILCMD_PUSH_TRANSFORM (
_renderData.AddDependentResource(transform)
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_PUSH_TRANSFORM) == 8);
_renderData.WriteDataRecord(MILCMD.MilPushTransform,
(byte*)&record,
8 /* sizeof(MILCMD_PUSH_TRANSFORM) */);
}
_stackDepth++;
}
///
/// PushGuidelineSet -
/// Push a set of guidelines which will apply to all drawing operations until the
/// corresponding Pop.
///
/// The GuidelineSet to push.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void PushGuidelineSet(
GuidelineSet guidelines)
{
VerifyApiNonstructuralChange();
#if DEBUG
MediaTrace.DrawingContextOp.Trace("PushGuidelineSet(const)");
#endif
unsafe
{
EnsureRenderData();
if (guidelines != null && guidelines.IsFrozen && guidelines.IsDynamic)
{
DoubleCollection guidelinesX = guidelines.GuidelinesX;
DoubleCollection guidelinesY = guidelines.GuidelinesY;
int countX = guidelinesX == null ? 0 : guidelinesX.Count;
int countY = guidelinesY == null ? 0 : guidelinesY.Count;
if (countX == 0 && (countY == 1 || countY == 2)
)
{
if (countY == 1)
{
MILCMD_PUSH_GUIDELINE_Y1 record =
new MILCMD_PUSH_GUIDELINE_Y1(
guidelinesY[0]
);
_renderData.WriteDataRecord(
MILCMD.MilPushGuidelineY1,
(byte*)&record,
sizeof(MILCMD_PUSH_GUIDELINE_Y1)
);
}
else
{
MILCMD_PUSH_GUIDELINE_Y2 record =
new MILCMD_PUSH_GUIDELINE_Y2(
guidelinesY[0],
guidelinesY[1] - guidelinesY[0]
);
_renderData.WriteDataRecord(
MILCMD.MilPushGuidelineY2,
(byte*)&record,
sizeof(MILCMD_PUSH_GUIDELINE_Y2)
);
}
}
}
else
{
MILCMD_PUSH_GUIDELINE_SET record =
new MILCMD_PUSH_GUIDELINE_SET (
_renderData.AddDependentResource(guidelines)
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_PUSH_GUIDELINE_SET) == 8);
_renderData.WriteDataRecord(MILCMD.MilPushGuidelineSet,
(byte*)&record,
8 /* sizeof(MILCMD_PUSH_GUIDELINE_SET) */);
}
}
_stackDepth++;
}
///
/// PushGuidelineY1 -
/// Explicitly push one horizontal guideline.
///
/// The coordinate of leading guideline.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
internal override void PushGuidelineY1(
Double coordinate)
{
VerifyApiNonstructuralChange();
#if DEBUG
MediaTrace.DrawingContextOp.Trace("PushGuidelineY1(const)");
#endif
unsafe
{
EnsureRenderData();
MILCMD_PUSH_GUIDELINE_Y1 record =
new MILCMD_PUSH_GUIDELINE_Y1 (
coordinate
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_PUSH_GUIDELINE_Y1) == 8);
_renderData.WriteDataRecord(MILCMD.MilPushGuidelineY1,
(byte*)&record,
8 /* sizeof(MILCMD_PUSH_GUIDELINE_Y1) */);
}
_stackDepth++;
}
///
/// PushGuidelineY2 -
/// Explicitly push a pair of horizontal guidelines.
///
///
/// The coordinate of leading guideline.
///
///
/// The offset from leading guideline to driven guideline.
///
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
internal override void PushGuidelineY2(
Double leadingCoordinate,
Double offsetToDrivenCoordinate)
{
VerifyApiNonstructuralChange();
#if DEBUG
MediaTrace.DrawingContextOp.Trace("PushGuidelineY2(const)");
#endif
unsafe
{
EnsureRenderData();
MILCMD_PUSH_GUIDELINE_Y2 record =
new MILCMD_PUSH_GUIDELINE_Y2 (
leadingCoordinate,
offsetToDrivenCoordinate
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_PUSH_GUIDELINE_Y2) == 16);
_renderData.WriteDataRecord(MILCMD.MilPushGuidelineY2,
(byte*)&record,
16 /* sizeof(MILCMD_PUSH_GUIDELINE_Y2) */);
}
_stackDepth++;
}
///
/// PushEffect -
/// Push a BitmapEffect which will apply to all drawing operations until the
/// corresponding Pop.
///
/// The BitmapEffect to push.
/// The BitmapEffectInput.
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
[Obsolete(MS.Internal.Media.VisualTreeUtils.BitmapEffectObsoleteMessage)]
public override void PushEffect(
BitmapEffect effect,
BitmapEffectInput effectInput)
{
VerifyApiNonstructuralChange();
#if DEBUG
MediaTrace.DrawingContextOp.Trace("PushEffect(const)");
#endif
unsafe
{
EnsureRenderData();
MILCMD_PUSH_EFFECT record =
new MILCMD_PUSH_EFFECT (
_renderData.AddDependentResource(effect),
_renderData.AddDependentResource(effectInput)
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
Debug.Assert(sizeof(MILCMD_PUSH_EFFECT) == 8);
_renderData.WriteDataRecord(MILCMD.MilPushEffect,
(byte*)&record,
8 /* sizeof(MILCMD_PUSH_EFFECT) */);
}
_stackDepth++;
if (_renderData.BitmapEffectStackDepth == 0)
{
_renderData.BeginTopLevelBitmapEffect(_stackDepth);
}
}
///
/// Pop
///
///
/// Critical:This code calls into unsafe code
/// TreatAsSafe: This code is ok to expose. Writing a record is a safe operation as long as the size and pointer are valid.
///
[SecurityCritical,SecurityTreatAsSafe]
public override void Pop(
)
{
VerifyApiNonstructuralChange();
if (_stackDepth <= 0)
{
throw new InvalidOperationException(SR.Get(SRID.DrawingContext_TooManyPops));
}
#if DEBUG
MediaTrace.DrawingContextOp.Trace("Pop(const)");
#endif
unsafe
{
EnsureRenderData();
MILCMD_POP record =
new MILCMD_POP (
);
// Assert that the calculated packet size is the same as the size returned by sizeof().
// Note that since sizeof(emptyStruct) returns 1, we compare against 1 for empty structs.
Debug.Assert(sizeof(MILCMD_POP) == 1);
_renderData.WriteDataRecord(MILCMD.MilPop,
(byte*)&record,
0 /* sizeof(MILCMD_POP) */);
}
_stackDepth--;
// end the top level effect, if we are popping the top
// level push effect instruction
if (_renderData.BitmapEffectStackDepth == (_stackDepth + 1))
{
_renderData.EndTopLevelBitmapEffect();
}
}
private UInt32 UseAnimations(
Double baseValue,
AnimationClock animations)
{
if (animations == null)
{
return 0;
}
else
{
return _renderData.AddDependentResource(
new DoubleAnimationClockResource(
baseValue,
animations));
}
}
private UInt32 UseAnimations(
Point baseValue,
AnimationClock animations)
{
if (animations == null)
{
return 0;
}
else
{
return _renderData.AddDependentResource(
new PointAnimationClockResource(
baseValue,
animations));
}
}
private UInt32 UseAnimations(
Size baseValue,
AnimationClock animations)
{
if (animations == null)
{
return 0;
}
else
{
return _renderData.AddDependentResource(
new SizeAnimationClockResource(
baseValue,
animations));
}
}
private UInt32 UseAnimations(
Rect baseValue,
AnimationClock animations)
{
if (animations == null)
{
return 0;
}
else
{
return _renderData.AddDependentResource(
new RectAnimationClockResource(
baseValue,
animations));
}
}
}
}
// 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
- SqlColumnizer.cs
- DrawingGroup.cs
- Crc32.cs
- SerializationIncompleteException.cs
- ImageInfo.cs
- ExecutedRoutedEventArgs.cs
- FactoryGenerator.cs
- CodeSubDirectory.cs
- SecurityUtils.cs
- AnimationClock.cs
- ImportContext.cs
- StrokeCollectionConverter.cs
- Bidi.cs
- Sorting.cs
- DataRecordInternal.cs
- HtmlListAdapter.cs
- DataGridViewHitTestInfo.cs
- wmiprovider.cs
- EqualityArray.cs
- ReferencedType.cs
- FixedNode.cs
- LazyLoadBehavior.cs
- PolyLineSegmentFigureLogic.cs
- QuadraticBezierSegment.cs
- CompilerState.cs
- MenuItem.cs
- panel.cs
- BamlLocalizableResourceKey.cs
- AggregateNode.cs
- DocumentXPathNavigator.cs
- DiscardableAttribute.cs
- TcpActivation.cs
- ApplicationDirectoryMembershipCondition.cs
- VirtualPathProvider.cs
- RegistrationServices.cs
- CommandValueSerializer.cs
- IncrementalHitTester.cs
- SystemIcmpV6Statistics.cs
- TabControlEvent.cs
- FontWeight.cs
- CollectionsUtil.cs
- Region.cs
- QueryContinueDragEventArgs.cs
- SmiEventSink_DeferedProcessing.cs
- XmlAtomicValue.cs
- DataRowChangeEvent.cs
- MeshGeometry3D.cs
- FindSimilarActivitiesVerb.cs
- _Semaphore.cs
- InlineUIContainer.cs
- XamlParser.cs
- DefaultValidator.cs
- ElementHostPropertyMap.cs
- GridViewColumnCollection.cs
- JsonWriter.cs
- ListBox.cs
- DynamicVirtualDiscoSearcher.cs
- SystemIPInterfaceStatistics.cs
- ElementsClipboardData.cs
- PeerReferralPolicy.cs
- XmlHierarchicalEnumerable.cs
- Win32PrintDialog.cs
- StopRoutingHandler.cs
- ViewStateException.cs
- FunctionImportElement.cs
- OLEDB_Util.cs
- XmlDataLoader.cs
- ImageField.cs
- DbUpdateCommandTree.cs
- SystemFonts.cs
- SqlDataSourceCache.cs
- LedgerEntry.cs
- GenericFlowSwitchHelper.cs
- NotImplementedException.cs
- XmlILIndex.cs
- SystemNetworkInterface.cs
- InProcStateClientManager.cs
- DescriptionAttribute.cs
- ReadOnlyNameValueCollection.cs
- ServiceDescriptionImporter.cs
- columnmapfactory.cs
- TextOnlyOutput.cs
- PostBackOptions.cs
- ImportContext.cs
- TemporaryBitmapFile.cs
- LinkLabel.cs
- BitmapDecoder.cs
- Transform.cs
- CapabilitiesPattern.cs
- ExcCanonicalXml.cs
- Point.cs
- OneOfConst.cs
- WmlValidationSummaryAdapter.cs
- CodeMemberProperty.cs
- GridViewColumnHeader.cs
- FlowDocumentScrollViewerAutomationPeer.cs
- DragCompletedEventArgs.cs
- FormatConvertedBitmap.cs
- SchemaNames.cs
- DrawingCollection.cs