Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Core / CSharp / MS / Internal / Media / XamlSerializationHelper.cs / 1305600 / 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;
namespace MS.Internal.Markup
#else
using System.Windows;
using System.Windows.Media ;
using System.Windows.Media.Media3D;
using TypeConverterHelper = System.Windows.Markup;
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.InvariantEnglishUS);
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.InvariantEnglishUS);
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.InvariantEnglishUS);
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;
namespace MS.Internal.Markup
#else
using System.Windows;
using System.Windows.Media ;
using System.Windows.Media.Media3D;
using TypeConverterHelper = System.Windows.Markup;
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.InvariantEnglishUS);
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.InvariantEnglishUS);
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.InvariantEnglishUS);
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
- ButtonBase.cs
- SmtpAuthenticationManager.cs
- ButtonChrome.cs
- BridgeDataRecord.cs
- StringStorage.cs
- TextBoxDesigner.cs
- QilInvoke.cs
- _NativeSSPI.cs
- IDQuery.cs
- DataGridViewRowPrePaintEventArgs.cs
- XmlSchemaObjectCollection.cs
- UInt32Converter.cs
- InkCanvasFeedbackAdorner.cs
- SqlBuilder.cs
- URI.cs
- StackOverflowException.cs
- ColumnMapTranslator.cs
- CustomLineCap.cs
- DataGridColumn.cs
- XmlUTF8TextReader.cs
- DataReceivedEventArgs.cs
- HighContrastHelper.cs
- FileUtil.cs
- Rectangle.cs
- KnownTypesProvider.cs
- wgx_sdk_version.cs
- COM2EnumConverter.cs
- FormsIdentity.cs
- ToolStripPanelRenderEventArgs.cs
- HMACSHA1.cs
- AuthenticationConfig.cs
- ContentPropertyAttribute.cs
- BitmapImage.cs
- WebEventTraceProvider.cs
- Attribute.cs
- IntSecurity.cs
- WebBrowserHelper.cs
- DBNull.cs
- ActiveDocumentEvent.cs
- PropertyDescriptor.cs
- WebBrowser.cs
- InheritanceContextChangedEventManager.cs
- DateTimeConstantAttribute.cs
- HttpRuntime.cs
- XmlnsCompatibleWithAttribute.cs
- TextDecoration.cs
- PermissionSetTriple.cs
- SizeAnimation.cs
- Operand.cs
- FixedSOMLineCollection.cs
- WindowAutomationPeer.cs
- Crypto.cs
- WebConfigurationHost.cs
- Terminate.cs
- SourceElementsCollection.cs
- Calendar.cs
- DefaultPropertyAttribute.cs
- TableCell.cs
- BindableTemplateBuilder.cs
- ConfigurationPropertyCollection.cs
- MetadataCache.cs
- SqlConnectionManager.cs
- InputMethodStateTypeInfo.cs
- DuplicateMessageDetector.cs
- WebPartCloseVerb.cs
- FloaterParagraph.cs
- templategroup.cs
- Journaling.cs
- DelegateTypeInfo.cs
- MsmqHostedTransportConfiguration.cs
- CommandHelper.cs
- DesignerCategoryAttribute.cs
- DataBinding.cs
- MouseDevice.cs
- XPathDocumentIterator.cs
- DataColumnPropertyDescriptor.cs
- HtmlElementCollection.cs
- SelectionRangeConverter.cs
- UnauthorizedWebPart.cs
- ImplicitInputBrush.cs
- ObjectFactoryCodeDomTreeGenerator.cs
- Win32.cs
- SmtpReplyReaderFactory.cs
- DataServiceConfiguration.cs
- URLAttribute.cs
- BufferedReadStream.cs
- TemplateParser.cs
- GridItemCollection.cs
- Int64.cs
- odbcmetadatacollectionnames.cs
- Soap12FormatExtensions.cs
- SupportsEventValidationAttribute.cs
- Common.cs
- AssemblyEvidenceFactory.cs
- CallInfo.cs
- RepeatBehavior.cs
- Cell.cs
- LocalizabilityAttribute.cs
- WebPartCloseVerb.cs
- CustomCredentialPolicy.cs