Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / Core / CSharp / MS / Internal / Media / XamlSerializationHelper.cs / 2 / XamlSerializationHelper.cs
//----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
//
// Description: Utilities for converting types to custom Binary format
//
// History:
// 11/09/05 : marka - Created
//
//---------------------------------------------------------------------------
using System;
using System.IO;
using System.Collections;
using System.Globalization; // CultureInfo
#if PRESENTATION_CORE
using MS.Internal.PresentationCore; // FriendAccessAllowed
#elif PRESENTATIONFRAMEWORK
using MS.Internal.PresentationFramework;
#endif
#if PBTCOMPILER
using System.Collections.Generic;
using TypeConverterHelper = MS.Internal.Markup.TypeConverterHelper;
namespace MS.Internal.Markup
#else
using System.Windows;
using System.Windows.Media ;
using System.Windows.Media.Media3D;
using TypeConverterHelper = System.Windows.Markup.TypeConverterHelper;
namespace MS.Internal.Media
#endif
{
#if PBTCOMPILER
//
// Internal class used during serialization of Point3D, or Vectors.
//
// We define this struct so that we can create a collection of types during serialization.
// If we used defined avalon types, like Point & Vector, we'd have to bring these into PBT
// with a compiler change everytime these types are changed.
//
// The type is called "ThreeDoubles" to make clear what it is and what it's for.
//
// If either Vector3D or Point3D changes - we will need to change this code.
//
internal class ThreeDoublesMarkup
{
internal ThreeDoublesMarkup( double X, double Y, double Z)
{
_x = X;
_y = Y;
_z = Z;
}
internal double X
{
get
{
return _x;
}
}
internal double Y
{
get
{
return _y;
}
}
internal double Z
{
get
{
return _z;
}
}
double _x ;
double _y ;
double _z ;
}
internal struct Point
{
internal Point(double x, double y)
{
_x = x;
_y = y;
}
internal double X
{
set
{
_x = value;
}
get
{
return _x;
}
}
internal double Y
{
set
{
_y = value;
}
get
{
return _y;
}
}
private double _x;
private double _y;
}
internal struct Size
{
internal Size(double width, double height)
{
_width = width;
_height = height;
}
internal double Width
{
set
{
_width = value;
}
get
{
return _width;
}
}
internal double Height
{
set
{
_height = value;
}
get
{
return _height;
}
}
private double _width;
private double _height;
}
#endif
internal static class XamlSerializationHelper
{
// =====================================================
//
// All PBT specific types and methods go here.
//
// =====================================================
internal enum SerializationFloatType : byte
{
Unknown = 0,
Zero = 1,
One = 2,
MinusOne = 3,
ScaledInteger = 4,
Double = 5,
Other
}
///
/// Serialize this object using the passed writer in compact BAML binary format.
///
///
/// This is called ONLY from the Parser and is not a general public method.
///
#if !PBTCOMPILER
[FriendAccessAllowed] // Built into Core, also used by Framework.
#endif
internal static bool SerializePoint3D(BinaryWriter writer, string stringValues)
{
#if PBTCOMPILER
List point3Ds = ParseThreeDoublesCollection( stringValues, TypeConverterHelper.EnglishUSCulture ) ;
ThreeDoublesMarkup curPoint;
#else
Point3DCollection point3Ds = Point3DCollection.Parse( stringValues ) ;
Point3D curPoint ;
#endif
// Write out the size.
writer.Write( ( uint ) point3Ds.Count ) ;
// Write out the doubles.
for ( int i = 0; i < point3Ds.Count ; i ++ )
{
curPoint = point3Ds[i] ;
WriteDouble( writer, curPoint.X);
WriteDouble( writer, curPoint.Y);
WriteDouble( writer, curPoint.Z);
}
return true ;
}
///
/// Serialize this object using the passed writer in compact BAML binary format.
///
///
/// This is called ONLY from the Parser and is not a general public method.
///
#if !PBTCOMPILER
[FriendAccessAllowed] // Built into Core, also used by Framework.
#endif
internal static bool SerializeVector3D(BinaryWriter writer, string stringValues)
{
#if PBTCOMPILER
List points = ParseThreeDoublesCollection( stringValues, TypeConverterHelper.EnglishUSCulture ) ;
ThreeDoublesMarkup curPoint;
#else
Vector3DCollection points = Vector3DCollection.Parse( stringValues ) ;
Vector3D curPoint ;
#endif
// Write out the size.
writer.Write( ( uint ) points.Count ) ;
// Write out the doubles.
for ( int i = 0; i < points.Count ; i ++ )
{
curPoint = points[ i ] ;
WriteDouble( writer, curPoint.X);
WriteDouble( writer, curPoint.Y);
WriteDouble( writer, curPoint.Z);
}
return true ;
}
///
/// Serialize this object using the passed writer in compact BAML binary format.
///
///
/// This is called ONLY from the Parser and is not a general public method.
///
#if !PBTCOMPILER
[FriendAccessAllowed] // Built into Core, also used by Framework.
#endif
internal static bool SerializePoint(BinaryWriter writer, string stringValue)
{
#if PBTCOMPILER
List points = ParsePointCollection( stringValue, TypeConverterHelper.EnglishUSCulture ) ;
Point curPoint;
#else
PointCollection points = PointCollection.Parse( stringValue ) ;
Point curPoint ;
#endif
// Write out the size.
writer.Write( ( uint ) points.Count ) ;
// Write out the doubles.
for ( int i = 0; i < points.Count ; i ++ )
{
curPoint = points[ i ] ;
WriteDouble( writer, curPoint.X);
WriteDouble( writer, curPoint.Y);
}
return true ;
}
private const double scaleFactor = 1000000 ; // approx == 2^20
private const double inverseScaleFactor = 0.000001 ; // approx = 1 / 2^20
//
// Write a double into our internal binary format
//
//
// The format is :
// ( <4 bytes for scaledinteger> | < 8 bytes for double> )
//
internal static void WriteDouble( BinaryWriter writer, Double value )
{
if ( value == 0.0 )
{
writer.Write( (byte) SerializationFloatType.Zero ) ;
}
else if ( value == 1.0 )
{
writer.Write( (byte) SerializationFloatType.One ) ;
}
else if ( value == -1.0 )
{
writer.Write( (byte) SerializationFloatType.MinusOne ) ;
}
else
{
int intValue = 0 ;
if ( CanConvertToInteger( value, ref intValue ) )
{
writer.Write( (byte) SerializationFloatType.ScaledInteger ) ;
writer.Write( intValue ) ;
}
else
{
writer.Write( (byte) SerializationFloatType.Double ) ;
writer.Write( value ) ;
}
}
}
#if !PBTCOMPILER
//
// Read a double from our internal binary format.
// We assume that the binary reader is at the start of a byte.
//
internal static double ReadDouble( BinaryReader reader )
{
SerializationFloatType type = ( SerializationFloatType ) reader.ReadByte();
switch( type )
{
case SerializationFloatType.Zero :
return 0.0 ;
case SerializationFloatType.One :
return 1.0 ;
case SerializationFloatType.MinusOne :
return -1.0 ;
case SerializationFloatType.ScaledInteger :
return ReadScaledInteger( reader );
case SerializationFloatType.Double :
return reader.ReadDouble();
default:
throw new ArgumentException(SR.Get(SRID.FloatUnknownBamlType));
}
}
internal static double ReadScaledInteger(BinaryReader reader )
{
double value = (double) reader.ReadInt32();
value = value * inverseScaleFactor ;
return value ;
}
#endif
#if PBTCOMPILER
///
/// Parse - returns an instance converted from the provided string.
/// string with Point3DCollection data
/// IFormatprovider for processing string
///
private static List ParseThreeDoublesCollection(string source, IFormatProvider formatProvider)
{
TokenizerHelper th = new TokenizerHelper(source, formatProvider);
List resource = new List( source.Length/ 8 ) ; // SWAG the length of the collection.
ThreeDoublesMarkup value;
while (th.NextToken())
{
value = new ThreeDoublesMarkup(
Convert.ToDouble(th.GetCurrentToken(), formatProvider),
Convert.ToDouble(th.NextTokenRequired(), formatProvider),
Convert.ToDouble(th.NextTokenRequired(), formatProvider));
resource.Add(value);
}
return resource;
}
///
/// Parse - returns an instance converted from the provided string.
/// string with Point3DCollection data
/// IFormatprovider for processing string
///
private static List ParsePointCollection(string source, IFormatProvider formatProvider)
{
TokenizerHelper th = new TokenizerHelper(source, formatProvider);
List resource = new List(source.Length/ 8 ); // SWAG the length of the collection.
Point value;
while (th.NextToken())
{
value = new Point(
Convert.ToDouble(th.GetCurrentToken(), formatProvider),
Convert.ToDouble(th.NextTokenRequired(), formatProvider) );
resource.Add(value);
}
return resource;
}
#endif
//
// Can we convert this double to a "scaled integer"
//
// We multiply by approx 2^20 - see if the result is either
// - greater than maxInt
// - if there is a non-numeric integer remaining
//
// as a result this routine will convert doubles with six-digits precision between +/- 2048
//
internal static bool CanConvertToInteger( Double doubleValue , ref int intValue )
{
double scaledValue ;
double scaledInteger ;
scaledValue = doubleValue * scaleFactor ;
scaledInteger = Math.Floor( scaledValue ) ;
if ( !( scaledInteger <= Int32.MaxValue ) // equivalent to scaledInteger > MaxValue, but take care of NaN.
||
!( scaledInteger >= Int32.MinValue ) ) // equivalent to scaledInteger < Minvalue but take care of NaN.
{
return false ;
}
else if ( ( scaledValue - scaledInteger ) > Double.Epsilon )
{
return false ;
}
else
{
intValue = (int) scaledValue ;
return true ;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
//
// Description: Utilities for converting types to custom Binary format
//
// History:
// 11/09/05 : marka - Created
//
//---------------------------------------------------------------------------
using System;
using System.IO;
using System.Collections;
using System.Globalization; // CultureInfo
#if PRESENTATION_CORE
using MS.Internal.PresentationCore; // FriendAccessAllowed
#elif PRESENTATIONFRAMEWORK
using MS.Internal.PresentationFramework;
#endif
#if PBTCOMPILER
using System.Collections.Generic;
using TypeConverterHelper = MS.Internal.Markup.TypeConverterHelper;
namespace MS.Internal.Markup
#else
using System.Windows;
using System.Windows.Media ;
using System.Windows.Media.Media3D;
using TypeConverterHelper = System.Windows.Markup.TypeConverterHelper;
namespace MS.Internal.Media
#endif
{
#if PBTCOMPILER
//
// Internal class used during serialization of Point3D, or Vectors.
//
// We define this struct so that we can create a collection of types during serialization.
// If we used defined avalon types, like Point & Vector, we'd have to bring these into PBT
// with a compiler change everytime these types are changed.
//
// The type is called "ThreeDoubles" to make clear what it is and what it's for.
//
// If either Vector3D or Point3D changes - we will need to change this code.
//
internal class ThreeDoublesMarkup
{
internal ThreeDoublesMarkup( double X, double Y, double Z)
{
_x = X;
_y = Y;
_z = Z;
}
internal double X
{
get
{
return _x;
}
}
internal double Y
{
get
{
return _y;
}
}
internal double Z
{
get
{
return _z;
}
}
double _x ;
double _y ;
double _z ;
}
internal struct Point
{
internal Point(double x, double y)
{
_x = x;
_y = y;
}
internal double X
{
set
{
_x = value;
}
get
{
return _x;
}
}
internal double Y
{
set
{
_y = value;
}
get
{
return _y;
}
}
private double _x;
private double _y;
}
internal struct Size
{
internal Size(double width, double height)
{
_width = width;
_height = height;
}
internal double Width
{
set
{
_width = value;
}
get
{
return _width;
}
}
internal double Height
{
set
{
_height = value;
}
get
{
return _height;
}
}
private double _width;
private double _height;
}
#endif
internal static class XamlSerializationHelper
{
// =====================================================
//
// All PBT specific types and methods go here.
//
// =====================================================
internal enum SerializationFloatType : byte
{
Unknown = 0,
Zero = 1,
One = 2,
MinusOne = 3,
ScaledInteger = 4,
Double = 5,
Other
}
///
/// Serialize this object using the passed writer in compact BAML binary format.
///
///
/// This is called ONLY from the Parser and is not a general public method.
///
#if !PBTCOMPILER
[FriendAccessAllowed] // Built into Core, also used by Framework.
#endif
internal static bool SerializePoint3D(BinaryWriter writer, string stringValues)
{
#if PBTCOMPILER
List point3Ds = ParseThreeDoublesCollection( stringValues, TypeConverterHelper.EnglishUSCulture ) ;
ThreeDoublesMarkup curPoint;
#else
Point3DCollection point3Ds = Point3DCollection.Parse( stringValues ) ;
Point3D curPoint ;
#endif
// Write out the size.
writer.Write( ( uint ) point3Ds.Count ) ;
// Write out the doubles.
for ( int i = 0; i < point3Ds.Count ; i ++ )
{
curPoint = point3Ds[i] ;
WriteDouble( writer, curPoint.X);
WriteDouble( writer, curPoint.Y);
WriteDouble( writer, curPoint.Z);
}
return true ;
}
///
/// Serialize this object using the passed writer in compact BAML binary format.
///
///
/// This is called ONLY from the Parser and is not a general public method.
///
#if !PBTCOMPILER
[FriendAccessAllowed] // Built into Core, also used by Framework.
#endif
internal static bool SerializeVector3D(BinaryWriter writer, string stringValues)
{
#if PBTCOMPILER
List points = ParseThreeDoublesCollection( stringValues, TypeConverterHelper.EnglishUSCulture ) ;
ThreeDoublesMarkup curPoint;
#else
Vector3DCollection points = Vector3DCollection.Parse( stringValues ) ;
Vector3D curPoint ;
#endif
// Write out the size.
writer.Write( ( uint ) points.Count ) ;
// Write out the doubles.
for ( int i = 0; i < points.Count ; i ++ )
{
curPoint = points[ i ] ;
WriteDouble( writer, curPoint.X);
WriteDouble( writer, curPoint.Y);
WriteDouble( writer, curPoint.Z);
}
return true ;
}
///
/// Serialize this object using the passed writer in compact BAML binary format.
///
///
/// This is called ONLY from the Parser and is not a general public method.
///
#if !PBTCOMPILER
[FriendAccessAllowed] // Built into Core, also used by Framework.
#endif
internal static bool SerializePoint(BinaryWriter writer, string stringValue)
{
#if PBTCOMPILER
List points = ParsePointCollection( stringValue, TypeConverterHelper.EnglishUSCulture ) ;
Point curPoint;
#else
PointCollection points = PointCollection.Parse( stringValue ) ;
Point curPoint ;
#endif
// Write out the size.
writer.Write( ( uint ) points.Count ) ;
// Write out the doubles.
for ( int i = 0; i < points.Count ; i ++ )
{
curPoint = points[ i ] ;
WriteDouble( writer, curPoint.X);
WriteDouble( writer, curPoint.Y);
}
return true ;
}
private const double scaleFactor = 1000000 ; // approx == 2^20
private const double inverseScaleFactor = 0.000001 ; // approx = 1 / 2^20
//
// Write a double into our internal binary format
//
//
// The format is :
// ( <4 bytes for scaledinteger> | < 8 bytes for double> )
//
internal static void WriteDouble( BinaryWriter writer, Double value )
{
if ( value == 0.0 )
{
writer.Write( (byte) SerializationFloatType.Zero ) ;
}
else if ( value == 1.0 )
{
writer.Write( (byte) SerializationFloatType.One ) ;
}
else if ( value == -1.0 )
{
writer.Write( (byte) SerializationFloatType.MinusOne ) ;
}
else
{
int intValue = 0 ;
if ( CanConvertToInteger( value, ref intValue ) )
{
writer.Write( (byte) SerializationFloatType.ScaledInteger ) ;
writer.Write( intValue ) ;
}
else
{
writer.Write( (byte) SerializationFloatType.Double ) ;
writer.Write( value ) ;
}
}
}
#if !PBTCOMPILER
//
// Read a double from our internal binary format.
// We assume that the binary reader is at the start of a byte.
//
internal static double ReadDouble( BinaryReader reader )
{
SerializationFloatType type = ( SerializationFloatType ) reader.ReadByte();
switch( type )
{
case SerializationFloatType.Zero :
return 0.0 ;
case SerializationFloatType.One :
return 1.0 ;
case SerializationFloatType.MinusOne :
return -1.0 ;
case SerializationFloatType.ScaledInteger :
return ReadScaledInteger( reader );
case SerializationFloatType.Double :
return reader.ReadDouble();
default:
throw new ArgumentException(SR.Get(SRID.FloatUnknownBamlType));
}
}
internal static double ReadScaledInteger(BinaryReader reader )
{
double value = (double) reader.ReadInt32();
value = value * inverseScaleFactor ;
return value ;
}
#endif
#if PBTCOMPILER
///
/// Parse - returns an instance converted from the provided string.
/// string with Point3DCollection data
/// IFormatprovider for processing string
///
private static List ParseThreeDoublesCollection(string source, IFormatProvider formatProvider)
{
TokenizerHelper th = new TokenizerHelper(source, formatProvider);
List resource = new List( source.Length/ 8 ) ; // SWAG the length of the collection.
ThreeDoublesMarkup value;
while (th.NextToken())
{
value = new ThreeDoublesMarkup(
Convert.ToDouble(th.GetCurrentToken(), formatProvider),
Convert.ToDouble(th.NextTokenRequired(), formatProvider),
Convert.ToDouble(th.NextTokenRequired(), formatProvider));
resource.Add(value);
}
return resource;
}
///
/// Parse - returns an instance converted from the provided string.
/// string with Point3DCollection data
/// IFormatprovider for processing string
///
private static List ParsePointCollection(string source, IFormatProvider formatProvider)
{
TokenizerHelper th = new TokenizerHelper(source, formatProvider);
List resource = new List(source.Length/ 8 ); // SWAG the length of the collection.
Point value;
while (th.NextToken())
{
value = new Point(
Convert.ToDouble(th.GetCurrentToken(), formatProvider),
Convert.ToDouble(th.NextTokenRequired(), formatProvider) );
resource.Add(value);
}
return resource;
}
#endif
//
// Can we convert this double to a "scaled integer"
//
// We multiply by approx 2^20 - see if the result is either
// - greater than maxInt
// - if there is a non-numeric integer remaining
//
// as a result this routine will convert doubles with six-digits precision between +/- 2048
//
internal static bool CanConvertToInteger( Double doubleValue , ref int intValue )
{
double scaledValue ;
double scaledInteger ;
scaledValue = doubleValue * scaleFactor ;
scaledInteger = Math.Floor( scaledValue ) ;
if ( !( scaledInteger <= Int32.MaxValue ) // equivalent to scaledInteger > MaxValue, but take care of NaN.
||
!( scaledInteger >= Int32.MinValue ) ) // equivalent to scaledInteger < Minvalue but take care of NaN.
{
return false ;
}
else if ( ( scaledValue - scaledInteger ) > Double.Epsilon )
{
return false ;
}
else
{
intValue = (int) scaledValue ;
return true ;
}
}
}
}
// 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
- _ReceiveMessageOverlappedAsyncResult.cs
- PrintingPermission.cs
- DocumentPage.cs
- XmlEventCache.cs
- ChangePassword.cs
- XmlHierarchicalDataSourceView.cs
- PackagePartCollection.cs
- StringValidatorAttribute.cs
- TextInfo.cs
- ListBoxChrome.cs
- InputDevice.cs
- ByteAnimation.cs
- WindowHideOrCloseTracker.cs
- Trace.cs
- ApplicationServiceManager.cs
- UDPClient.cs
- BaseCollection.cs
- ScopelessEnumAttribute.cs
- CodeVariableReferenceExpression.cs
- RequestResizeEvent.cs
- HtmlContainerControl.cs
- GenericFlowSwitchHelper.cs
- EncodingInfo.cs
- Sql8ConformanceChecker.cs
- SqlIdentifier.cs
- CodeArrayIndexerExpression.cs
- ZipIOEndOfCentralDirectoryBlock.cs
- WarningException.cs
- MulticastIPAddressInformationCollection.cs
- ShaperBuffers.cs
- RemoteWebConfigurationHost.cs
- ScrollChrome.cs
- DataTableReaderListener.cs
- Application.cs
- EncryptedData.cs
- EncodingNLS.cs
- XPathDocumentBuilder.cs
- TimelineGroup.cs
- DnsEndPoint.cs
- PerformanceCounter.cs
- EndpointAddress.cs
- ProfileSettingsCollection.cs
- TextServicesCompartment.cs
- RotateTransform.cs
- DesignOnlyAttribute.cs
- PageAsyncTaskManager.cs
- CodeTryCatchFinallyStatement.cs
- TimeSpanOrInfiniteConverter.cs
- ModelUtilities.cs
- XmlHelper.cs
- RelationshipConverter.cs
- GeometryValueSerializer.cs
- LineBreakRecord.cs
- HttpChannelBindingToken.cs
- RotateTransform3D.cs
- RecognitionResult.cs
- TrustLevel.cs
- SpoolingTaskBase.cs
- WebPartVerb.cs
- ApplicationGesture.cs
- NotCondition.cs
- ThreadInterruptedException.cs
- RegularExpressionValidator.cs
- WebPartAuthorizationEventArgs.cs
- ValidatorCompatibilityHelper.cs
- Roles.cs
- OLEDB_Util.cs
- SynchronizationLockException.cs
- regiisutil.cs
- Assembly.cs
- XmlILStorageConverter.cs
- EntityContainer.cs
- WebBrowserContainer.cs
- EventHandlersStore.cs
- SqlStream.cs
- ProjectionCamera.cs
- IxmlLineInfo.cs
- Activation.cs
- Debugger.cs
- Action.cs
- TransformPattern.cs
- WebPartTracker.cs
- DrawingAttributesDefaultValueFactory.cs
- Events.cs
- NativeWrapper.cs
- ConfigurationException.cs
- ObjectStateFormatter.cs
- ApplicationException.cs
- Rectangle.cs
- DispatchChannelSink.cs
- HtmlTextArea.cs
- OracleDateTime.cs
- DataBindingHandlerAttribute.cs
- DBCSCodePageEncoding.cs
- DataGridAutomationPeer.cs
- ListQueryResults.cs
- WebPartManagerInternals.cs
- FileLoadException.cs
- BaseUriHelper.cs
- DataGridViewRowPrePaintEventArgs.cs