|
//---------------------------------------------------------------------------
//
// <copyright file="ParserStreamGeometryContext.cs" company="Microsoft">
// Copyright (C) Microsoft Corporation. All rights reserved.
// </copyright>
//
// This class is used to compress a Path to BAML.
//
// At compile-time this api is called into to "flatten" graphics calls to a BinaryWriter
// At run-time this api is called into to rehydrate the flattened graphics calls
// via invoking methods on a supplied StreamGeometryContext.
//
// Via this compression - we reduce the time spent parsing at startup, we create smaller baml,
// and we reduce creation of temporary strings.
//
//---------------------------------------------------------------------------
using MS.Internal;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Security;
using System.Security.Permissions;
using System.IO;
using MS.Utility;
#if PBTCOMPILER
using MS.Internal.Markup;
namespace MS.Internal.Markup
#else
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Media3D;
using MS.Internal.PresentationCore;
namespace MS.Internal.Media
#endif
{
/// <summary>
/// ParserStreamGeometryContext
/// </summary>
internal class ParserStreamGeometryContext : StreamGeometryContext
{
enum ParserGeometryContextOpCodes : byte
{
BeginFigure = 0,
LineTo = 1,
QuadraticBezierTo = 2,
BezierTo = 3,
PolyLineTo = 4,
PolyQuadraticBezierTo = 5,
PolyBezierTo = 6,
ArcTo = 7,
Closed = 8,
FillRule = 9,
}
private const byte HighNibble = 0xF0;
private const byte LowNibble = 0x0F;
private const byte SetBool1 = 0x10; // 00010000
private const byte SetBool2 = 0x20; // 00100000
private const byte SetBool3 = 0x40; // 01000000
private const byte SetBool4 = 0x80; // 10000000
#region Constructors
/// <summary>
/// This constructor exists to prevent external derivation
/// </summary>
internal ParserStreamGeometryContext(BinaryWriter bw)
{
_bw = bw;
}
#endregion Constructors
#region internal Methods
#if PRESENTATION_CORE
internal void SetFillRule(FillRule fillRule)
#else
internal void SetFillRule(bool boolFillRule)
#endif
{
#if PRESENTATION_CORE
bool boolFillRule = FillRuleToBool(fillRule);
#endif
byte packedByte = PackByte(ParserGeometryContextOpCodes.FillRule, boolFillRule, false);
_bw.Write(packedByte);
}
/// <summary>
/// BeginFigure - Start a new figure.
/// </summary>
/// <remarks>
/// Stored as [PointAndTwoBools] (see SerializepointAndTwoBools method).
/// </remarks>
public override void BeginFigure(Point startPoint, bool isFilled, bool isClosed)
{
//
// We need to update the BeginFigure block of the last figure (if
// there was one).
//
FinishFigure();
_startPoint = startPoint;
_isFilled = isFilled;
_isClosed = isClosed;
_figureStreamPosition = CurrentStreamPosition;
//
// This will be overwritten later when we start the next figure (i.e. when we're sure isClosed isn't
// going to change). We write it out now to ensure that we reserve exactly the right amount of space.
// Note that the number of bytes written is dependant on the particular value of startPoint, since
// we can compress doubles when they are in fact integral.
//
SerializePointAndTwoBools(ParserGeometryContextOpCodes.BeginFigure, startPoint, isFilled, isClosed);
}
/// <summary>
/// LineTo - append a LineTo to the current figure.
/// </summary>
/// <remarks>
/// Stored as [PointAndTwoBools] (see SerializepointAndTwoBools method).
/// </remarks>
public override void LineTo(Point point, bool isStroked, bool isSmoothJoin)
{
SerializePointAndTwoBools(ParserGeometryContextOpCodes.LineTo, point, isStroked, isSmoothJoin);
}
/// <summary>
/// QuadraticBezierTo - append a QuadraticBezierTo to the current figure.
/// </summary>
/// <remarks>
/// Stored as [PointAndTwoBools] [Number] [Number]
/// </remarks>
public override void QuadraticBezierTo(Point point1, Point point2, bool isStroked, bool isSmoothJoin)
{
SerializePointAndTwoBools(ParserGeometryContextOpCodes.QuadraticBezierTo, point1, isStroked, isSmoothJoin);
XamlSerializationHelper.WriteDouble(_bw, point2.X);
XamlSerializationHelper.WriteDouble(_bw, point2.Y);
}
/// <summary>
/// BezierTo - apply a BezierTo to the current figure.
/// </summary>
/// <remarks>
/// Stored as [PointAndTwoBools] [Number] [Number] [Number] [Number]
/// </remarks>
public override void BezierTo(Point point1, Point point2, Point point3, bool isStroked, bool isSmoothJoin)
{
SerializePointAndTwoBools(ParserGeometryContextOpCodes.BezierTo, point1, isStroked, isSmoothJoin);
XamlSerializationHelper.WriteDouble(_bw, point2.X);
XamlSerializationHelper.WriteDouble(_bw, point2.Y);
XamlSerializationHelper.WriteDouble(_bw, point3.X);
XamlSerializationHelper.WriteDouble(_bw, point3.Y);
}
/// <summary>
/// PolyLineTo - append a PolyLineTo to the current figure.
/// </summary>
/// <remarks>
/// Stored as [ListOfPointAndTwoBools] (see SerializeListOfPointsAndTwoBools method).
/// </remarks>
public override void PolyLineTo(IList<Point> points, bool isStroked, bool isSmoothJoin)
{
SerializeListOfPointsAndTwoBools(ParserGeometryContextOpCodes.PolyLineTo, points, isStroked, isSmoothJoin);
}
/// <summary>
/// PolyQuadraticBezierTo - append a PolyQuadraticBezierTo to the current figure.
/// </summary>
/// <remarks>
/// Stored as [ListOfPointAndTwoBools] (see SerializeListOfPointsAndTwoBools method).
/// </remarks>
public override void PolyQuadraticBezierTo(IList<Point> points, bool isStroked, bool isSmoothJoin)
{
SerializeListOfPointsAndTwoBools(ParserGeometryContextOpCodes.PolyQuadraticBezierTo, points, isStroked, isSmoothJoin);
}
/// <summary>
/// PolyBezierTo - append a PolyBezierTo to the current figure.
/// </summary>
/// <remarks>
/// Stored as [ListOfPointAndTwoBools] (see SerializeListOfPointsAndTwoBools method).
/// </remarks>
public override void PolyBezierTo(IList<Point> points, bool isStroked, bool isSmoothJoin)
{
SerializeListOfPointsAndTwoBools(ParserGeometryContextOpCodes.PolyBezierTo, points, isStroked, isSmoothJoin);
}
/// <summary>
/// ArcTo - append an ArcTo to the current figure.
/// </summary>
/// <remarks>
/// Stored as [PointAndTwoBools] [Packed byte for isLargeArc and sweepDirection] [Pair of Numbers for Size] [Pair of Numbers for rotation Angle]
///
/// Also note that we've special cased this method signature to avoid moving the enum for SweepDirection into PBT (will require codegen changes).
/// </remarks>
#if PBTCOMPILER
public override void ArcTo(Point point, Size size, double rotationAngle, bool isLargeArc, bool sweepDirection, bool isStroked, bool isSmoothJoin)
#else
public override void ArcTo(Point point, Size size, double rotationAngle, bool isLargeArc, SweepDirection sweepDirection, bool isStroked, bool isSmoothJoin)
#endif
{
SerializePointAndTwoBools(ParserGeometryContextOpCodes.ArcTo, point, isStroked, isSmoothJoin);
//
// Pack isLargeArc & sweepDirection into a single byte.
//
byte packMe = 0;
if (isLargeArc)
{
packMe = LowNibble;
}
#if PBTCOMPILER
if (sweepDirection)
#else
if (SweepToBool(sweepDirection))
#endif
{
packMe |= HighNibble;
}
_bw.Write(packMe);
//
// Write out Size & Rotation Angle.
//
XamlSerializationHelper.WriteDouble(_bw, size.Width);
XamlSerializationHelper.WriteDouble(_bw, size.Height);
XamlSerializationHelper.WriteDouble(_bw, rotationAngle);
}
internal bool FigurePending
{
get
{
return (_figureStreamPosition > -1);
}
}
internal int CurrentStreamPosition
{
get
{
return checked((int)_bw.Seek(0, SeekOrigin.Current));
}
}
internal void FinishFigure()
{
if (FigurePending)
{
int currentOffset = CurrentStreamPosition;
//
// Go back and overwrite our existing begin figure block. See comment in BeginFigure.
//
_bw.Seek(_figureStreamPosition, SeekOrigin.Begin);
SerializePointAndTwoBools(ParserGeometryContextOpCodes.BeginFigure, _startPoint, _isFilled, _isClosed);
_bw.Seek(currentOffset, SeekOrigin.Begin);
}
}
/// <summary>
/// This is the same as the Close call:
/// Closes the Context and flushes the content.
/// Afterwards the Context can not be used anymore.
/// This call does not require all Push calls to have been Popped.
/// </summary>
internal override void DisposeCore()
{
}
/// <summary>
/// SetClosedState - Sets the current closed state of the figure.
/// </summary>
internal override void SetClosedState(bool closed)
{
_isClosed = closed;
}
/// <summary>
/// Mark that the stream is Done.
/// </summary>
internal void MarkEOF()
{
//
// We need to update the BeginFigure block of the last figure (if
// there was one).
//
FinishFigure();
_bw.Write((byte) ParserGeometryContextOpCodes.Closed);
}
#if PRESENTATION_CORE
internal static void Deserialize(BinaryReader br, StreamGeometryContext sc, StreamGeometry geometry)
{
bool closed = false;
Byte currentByte;
while (!closed)
{
currentByte = br.ReadByte();
ParserGeometryContextOpCodes opCode = UnPackOpCode(currentByte);
switch(opCode)
{
case ParserGeometryContextOpCodes.FillRule :
DeserializeFillRule(br, currentByte, geometry);
break;
case ParserGeometryContextOpCodes.BeginFigure :
DeserializeBeginFigure(br, currentByte, sc);
break;
case ParserGeometryContextOpCodes.LineTo :
DeserializeLineTo(br, currentByte, sc);
break;
case ParserGeometryContextOpCodes.QuadraticBezierTo :
DeserializeQuadraticBezierTo(br, currentByte, sc);
break;
case ParserGeometryContextOpCodes.BezierTo :
DeserializeBezierTo(br, currentByte, sc);
break;
case ParserGeometryContextOpCodes.PolyLineTo :
DeserializePolyLineTo(br, currentByte, sc);
break;
case ParserGeometryContextOpCodes.PolyQuadraticBezierTo :
DeserializePolyQuadraticBezierTo(br, currentByte, sc);
break;
case ParserGeometryContextOpCodes.PolyBezierTo :
DeserializePolyBezierTo(br, currentByte, sc);
break;
case ParserGeometryContextOpCodes.ArcTo :
DeserializeArcTo(br, currentByte, sc);
break;
case ParserGeometryContextOpCodes.Closed :
closed = true;
break;
}
}
}
#endif
#endregion internal Methods
#region private Methods
//
// Deserialization Methods.
//
// These are only required at "runtime" - therefore only in PRESENTATION_CORE
//
#if PRESENTATION_CORE
private static void DeserializeFillRule(BinaryReader br, Byte firstByte, StreamGeometry geometry)
{
bool boolFillRule;
bool unused;
FillRule fillRule;
UnPackBools(firstByte, out boolFillRule, out unused);
fillRule = BoolToFillRule(boolFillRule);
geometry.FillRule = fillRule;
}
private static void DeserializeBeginFigure(BinaryReader br, Byte firstByte, StreamGeometryContext sc)
{
Point point;
bool isFilled;
bool isClosed;
DeserializePointAndTwoBools(br, firstByte, out point, out isFilled, out isClosed);
sc.BeginFigure(point, isFilled, isClosed);
}
private static void DeserializeLineTo(BinaryReader br, Byte firstByte, StreamGeometryContext sc)
{
Point point;
bool isStroked;
bool isSmoothJoin;
DeserializePointAndTwoBools(br, firstByte, out point, out isStroked, out isSmoothJoin);
sc.LineTo(point, isStroked, isSmoothJoin);
}
private static void DeserializeQuadraticBezierTo(BinaryReader br, byte firstByte, StreamGeometryContext sc)
{
Point point1;
Point point2 = new Point();
bool isStroked;
bool isSmoothJoin;
DeserializePointAndTwoBools(br, firstByte, out point1, out isStroked, out isSmoothJoin);
point2.X = XamlSerializationHelper.ReadDouble(br);
point2.Y = XamlSerializationHelper.ReadDouble(br);
sc.QuadraticBezierTo(point1, point2, isStroked, isSmoothJoin);
}
private static void DeserializeBezierTo(BinaryReader br, byte firstByte, StreamGeometryContext sc)
{
Point point1;
Point point2 = new Point();
Point point3 = new Point();
bool isStroked;
bool isSmoothJoin;
DeserializePointAndTwoBools(br, firstByte, out point1, out isStroked, out isSmoothJoin);
point2.X = XamlSerializationHelper.ReadDouble(br);
point2.Y = XamlSerializationHelper.ReadDouble(br);
point3.X = XamlSerializationHelper.ReadDouble(br);
point3.Y = XamlSerializationHelper.ReadDouble(br);
sc.BezierTo(point1, point2, point3, isStroked, isSmoothJoin);
}
private static void DeserializePolyLineTo(BinaryReader br, Byte firstByte, StreamGeometryContext sc)
{
bool isStroked;
bool isSmoothJoin;
IList<Point> points;
points = DeserializeListOfPointsAndTwoBools(br, firstByte, out isStroked, out isSmoothJoin);
sc.PolyLineTo(points, isStroked, isSmoothJoin);
}
private static void DeserializePolyQuadraticBezierTo(BinaryReader br, Byte firstByte, StreamGeometryContext sc)
{
bool isStroked;
bool isSmoothJoin;
IList<Point> points;
points = DeserializeListOfPointsAndTwoBools(br, firstByte, out isStroked, out isSmoothJoin);
sc.PolyQuadraticBezierTo(points, isStroked, isSmoothJoin);
}
private static void DeserializePolyBezierTo(BinaryReader br, Byte firstByte, StreamGeometryContext sc)
{
bool isStroked;
bool isSmoothJoin;
IList<Point> points;
points = DeserializeListOfPointsAndTwoBools(br, firstByte, out isStroked, out isSmoothJoin);
sc.PolyBezierTo(points, isStroked, isSmoothJoin);
}
private static void DeserializeArcTo(BinaryReader br, byte firstByte, StreamGeometryContext sc)
{
Point point;
Size size = new Size();
double rotationAngle;
bool isStroked;
bool isSmoothJoin;
bool isLargeArc;
SweepDirection sweepDirection;
DeserializePointAndTwoBools(br, firstByte, out point, out isStroked, out isSmoothJoin);
// Read the packed byte for isLargeArd & sweepDirection.
//
// Pack isLargeArc & sweepDirection into a signle byte.
//
byte packedByte = br.ReadByte();
isLargeArc = ((packedByte & LowNibble) != 0);
sweepDirection = BoolToSweep(((packedByte & HighNibble) != 0));
size.Width = XamlSerializationHelper.ReadDouble(br);
size.Height = XamlSerializationHelper.ReadDouble(br);
rotationAngle = XamlSerializationHelper.ReadDouble(br);
sc.ArcTo(point, size, rotationAngle, isLargeArc, sweepDirection, isStroked, isSmoothJoin);
}
//
// Private Deserialization helpers.
//
private static void UnPackBools(byte packedByte, out bool bool1, out bool bool2)
{
bool1 = (packedByte & SetBool1) != 0;
bool2 = (packedByte & SetBool2) != 0;
}
private static void UnPackBools(byte packedByte, out bool bool1, out bool bool2, out bool bool3, out bool bool4)
{
bool1 = (packedByte & SetBool1) != 0;
bool2 = (packedByte & SetBool2) != 0;
bool3 = (packedByte & SetBool3) != 0;
bool4 = (packedByte & SetBool4) != 0;
}
private static ParserGeometryContextOpCodes UnPackOpCode(byte packedByte)
{
return ((ParserGeometryContextOpCodes) (packedByte & 0x0F));
}
private static IList<Point> DeserializeListOfPointsAndTwoBools(BinaryReader br, Byte firstByte, out bool bool1, out bool bool2)
{
int count;
IList<Point> points;
Point point;
// Pack the two bools into one byte
UnPackBools(firstByte, out bool1, out bool2);
count = br.ReadInt32();
points = new List<Point>(count);
for(int i = 0; i < count; i++)
{
point = new Point(XamlSerializationHelper.ReadDouble(br),
XamlSerializationHelper.ReadDouble(br));
points.Add(point);
}
return points;
}
private static void DeserializePointAndTwoBools(BinaryReader br, Byte firstByte, out Point point, out bool bool1, out bool bool2)
{
bool isScaledIntegerX = false;
bool isScaledIntegerY = false;
UnPackBools(firstByte, out bool1, out bool2, out isScaledIntegerX, out isScaledIntegerY);
point = new Point(DeserializeDouble(br, isScaledIntegerX),
DeserializeDouble(br, isScaledIntegerY));
}
private static Double DeserializeDouble(BinaryReader br, bool isScaledInt)
{
if (isScaledInt)
{
return XamlSerializationHelper.ReadScaledInteger(br);
}
else
{
return XamlSerializationHelper.ReadDouble(br);
}
}
//
// Private serialization helpers
//
private static SweepDirection BoolToSweep(bool value)
{
if(!value)
return SweepDirection.Counterclockwise;
else
return SweepDirection.Clockwise;
}
private static bool SweepToBool(SweepDirection sweep)
{
if (sweep == SweepDirection.Counterclockwise)
return false;
else
return true;
}
private static FillRule BoolToFillRule(bool value)
{
if(!value)
return FillRule.EvenOdd;
else
return FillRule.Nonzero;
}
private static bool FillRuleToBool(FillRule fill)
{
if (fill == FillRule.EvenOdd)
return false;
else
return true;
}
#endif
//
// SerializePointAndTwoBools
//
// Binary format is :
//
// <Byte+OpCode> <Number1> <Number2>
//
// Where :
// <Byte+OpCode> := OpCode + bool1 + bool2 + isScaledIntegerX + isScaledIntegerY
// <NumberN> := <ScaledInteger> | <SerializationFloatTypeForSpecialNumbers> | <SerializationFloatType.Double+Double>
// <SerializationFloatTypeForSpecialNumbers> := <SerializationFloatType.Zero> | <SerializationFloatType.One> | <SerializationFloatType.MinusOne>
// <SerializationFloatType.Double+Double> := <SerializationFloatType.Double> <Double>
//
// By packing the flags for isScaledInteger into the first byte - we save 2 extra bytes per number for the common case.
//
// As a result - most LineTo's (and other operations) will be stored in 9 bytes.
// Some LineTo's will be 6 (or even sometimes 3)
// Max LineTo will be 19 (two doubles).
private void SerializePointAndTwoBools(ParserGeometryContextOpCodes opCode,
Point point,
bool bool1,
bool bool2)
{
int intValueX = 0;
int intValueY = 0;
bool isScaledIntegerX, isScaledIntegerY;
isScaledIntegerX = XamlSerializationHelper.CanConvertToInteger(point.X, ref intValueX);
isScaledIntegerY = XamlSerializationHelper.CanConvertToInteger(point.Y, ref intValueY);
_bw.Write(PackByte(opCode, bool1, bool2, isScaledIntegerX, isScaledIntegerY));
SerializeDouble(point.X, isScaledIntegerX, intValueX);
SerializeDouble(point.Y, isScaledIntegerY, intValueY);
}
// SerializeListOfPointsAndTwoBools
//
// Binary format is :
//
// <Byte+OpCode> <Count> <Number1> ... <NumberN>
//
// <Byte+OpCode> := OpCode + bool1 + bool2
// <Count> := int32
// <NumberN> := <SerializationFloatType.ScaledInteger+Integer> | <SerializationFloatTypeForSpecialNumbers> | <SerializationFloatType.Double+Double>
private void SerializeListOfPointsAndTwoBools(ParserGeometryContextOpCodes opCode, IList<Point> points, bool bool1, bool bool2)
{
// Pack the two bools into one byte
Byte packedByte = PackByte(opCode, bool1, bool2);
_bw.Write(packedByte);
// Write the count.
_bw.Write(points.Count);
// Write out all the Points
for(int i = 0; i < points.Count; i++)
{
XamlSerializationHelper.WriteDouble(_bw, points[i].X);
XamlSerializationHelper.WriteDouble(_bw, points[i].Y);
}
}
private void SerializeDouble(double value, bool isScaledInt, int scaledIntValue)
{
if (isScaledInt)
{
_bw.Write(scaledIntValue);
}
else
{
XamlSerializationHelper.WriteDouble(_bw, value);
}
}
private static byte PackByte(ParserGeometryContextOpCodes opCode, bool bool1, bool bool2)
{
return PackByte(opCode, bool1, bool2, false, false);
}
// PackByte
// Packs an op-code, and up to 4 booleans into a single byte.
//
// Binary format is :
// First 4 bits map directly to the op-code.
// Next 4 bits map to booleans 1 - 4.
//
// Like this:
//
// 7| 6 | 5 | 4 | 3 | 2 | 1 | 0 |
// <B4>|<B3>|<B2>|<B1><- Op Code ->
//
private static byte PackByte(ParserGeometryContextOpCodes opCode, bool bool1, bool bool2, bool bool3, bool bool4)
{
byte packedByte = (byte) opCode;
if (packedByte >= 16)
{
throw new ArgumentException(SR.Get(SRID.UnknownPathOperationType));
}
if (bool1)
{
packedByte |= SetBool1;
}
if (bool2)
{
packedByte |= SetBool2;
}
if (bool3)
{
packedByte |= SetBool3;
}
if (bool4)
{
packedByte |= SetBool4;
}
return packedByte;
}
#endregion private Methods
private BinaryWriter _bw;
Point _startPoint;
bool _isClosed;
bool _isFilled;
int _figureStreamPosition = -1;
}
}
|