XamlGridLengthSerializer.cs source code in C# .NET

                        Code:
                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / System / Windows / Markup / XamlGridLengthSerializer.cs / 1 / XamlGridLengthSerializer.cs
                        
                        
                            //---------------------------------------------------------------------------- 
//
// File: XamlGridLengthSerializer.cs
//
// Description: 
//   XamlSerializer used to persist GridLength structures in Baml
// 
// Copyright (C) 2004 by Microsoft Corporation.  All rights reserved. 
//
//--------------------------------------------------------------------------- 

using System;
using System.Collections;
using System.ComponentModel; 
using System.ComponentModel.Design;
using System.ComponentModel.Design.Serialization; 
using System.Diagnostics; 
using System.Globalization;
using System.IO; 
using System.Xml;
using System.Windows;
using MS.Utility;
using MS.Internal; 

#if PBTCOMPILER 
namespace MS.Internal.Markup 
#else
namespace System.Windows.Markup 
#endif
{
    /// 
    ///     XamlGridLengthSerializer is used to persist a GridLength structure in Baml files 
    /// 
    internal class XamlGridLengthSerializer : XamlSerializer 
    { 
#region Construction
 
        /// 
        ///     Constructor for XamlGridLengthSerializer
        /// 
        ///  
        ///     This constructor will be used under
        ///     the following two scenarios 
        ///     1. Convert a string to a custom binary representation stored in BAML 
        ///     2. Convert a custom binary representation back into a GridLength
        ///  
        private XamlGridLengthSerializer()
        {
        }
 

#endregion Construction 
 
#region Conversions
 
        ///
        /// Serializes this object using the passed writer.
        ///
        ///  
        /// This is called ONLY from the Parser and is not a general public method.
        ///  
        // 
        //  Format of serialized data:
        //  first byte   other bytes      format 
        //  0AAAAAAA     none             Amount [0 - 127] in AAAAAAA, Pixel GridUnitType
        //  100XXUUU     one byte         Amount in byte [0 - 255], GridUnitType in UUU
        //  110XXUUU     two bytes        Amount in int16 , GridUnitType in UUU
        //  101XXUUU     four bytes       Amount in int32 , GridUnitType in UUU 
        //  111XXUUU     eight bytes      Amount in double, GridUnitType in UUU
        // 
        public override bool ConvertStringToCustomBinary ( 
            BinaryWriter   writer,           // Writer into the baml stream
            string         stringValue)      // String to convert 
        {
            if (writer == null)
            {
                throw new ArgumentNullException( "writer" ); 
            }
 
            GridUnitType gridUnitType; 
            double   value;
            FromString(stringValue, XamlReaderHelper.EnglishUSCulture, 
                        out value, out gridUnitType);

            byte unitAndFlags = (byte)gridUnitType;
            int intAmount = (int)value; 

            if ((double)intAmount == value) 
            { 
                //
                //  0 - 127 and Pixel 
                //
                if (    intAmount <= 127
                    &&  intAmount >= 0
                    &&  gridUnitType == GridUnitType.Pixel  ) 
                {
                    writer.Write((byte)intAmount); 
                } 
                //
                //  unsigned byte 
                //
                else if (   intAmount <= 255
                        &&  intAmount >= 0  )
                { 
                    writer.Write((byte)(0x80 | unitAndFlags));
                    writer.Write((byte)intAmount); 
                } 
                //
                //  signed short integer 
                //
                else if (   intAmount <= 32767
                        &&  intAmount >= -32768 )
                { 
                    writer.Write((byte)(0xC0 | unitAndFlags));
                    writer.Write((Int16)intAmount); 
                } 
                //
                //  signed integer 
                //
                else
                {
                    writer.Write((byte)(0xA0 | unitAndFlags)); 
                    writer.Write(intAmount);
                } 
            } 
            //
            //  double 
            //
            else
            {
                writer.Write((byte)(0xE0 | unitAndFlags)); 
                writer.Write(value);
            } 
 
            return true;
 
        }

        /// 
        ///   Convert a compact binary representation of a GridLength into and instance 
        ///   of GridLength.  The reader must be left pointing immediately after the object
        ///   data in the underlying stream. 
        ///  
        /// 
        /// This is called ONLY from the Parser and is not a general public method. 
        /// 
        public override object ConvertCustomBinaryToObject(
            BinaryReader reader)
        { 
            if (reader == null)
            { 
                throw new ArgumentNullException( "reader" ); 
            }
 
            GridUnitType unitType;
            double unitValue;
            byte unitAndFlags = reader.ReadByte();
 
            if ((unitAndFlags & 0x80) == 0)
            { 
                unitType = GridUnitType.Pixel; 
                unitValue = (double)unitAndFlags;
            } 
            else
            {
                unitType = (GridUnitType)(unitAndFlags & 0x1F);
                byte flags = (byte)(unitAndFlags & 0xE0); 

                if (flags == 0x80) 
                { 
                    unitValue = (double)reader.ReadByte();
                } 
                else if (flags == 0xC0)
                {
                    unitValue = (double)reader.ReadInt16();
                } 
                else if (flags == 0xA0)
                { 
                    unitValue = (double)reader.ReadInt32(); 
                }
                else 
                {
                    unitValue = (double)reader.ReadDouble();
                }
            } 
            return new GridLength(unitValue, unitType);
        } 
 

 
        // Parse a GridLength from a string given the CultureInfo.
        static internal void FromString(
                string       s,
                CultureInfo  cultureInfo, 
            out double       value,
            out GridUnitType unit) 
        { 
            string goodString = s.Trim().ToLowerInvariant();
 
            value = 0.0;
            unit = GridUnitType.Pixel;

            int i; 
            int strLen = goodString.Length;
            int strLenUnit = 0; 
            double unitFactor = 1.0; 

            //  this is where we would handle trailing whitespace on the input string. 
            //  peel [unit] off the end of the string
            i = 0;

            if (goodString == UnitStrings[i]) 
            {
                strLenUnit = UnitStrings[i].Length; 
                unit = (GridUnitType)i; 
            }
            else 
            {
                for (i = 1; i < UnitStrings.Length; ++i)
                {
                    //  Note: this is NOT a culture specific comparison. 
                    //  this is by design: we want the same unit string table to work across all cultures.
                    if (goodString.EndsWith(UnitStrings[i], StringComparison.Ordinal)) 
                    { 
                        strLenUnit = UnitStrings[i].Length;
                        unit = (GridUnitType)i; 
                        break;
                    }
                }
            } 

            //  we couldn't match a real unit from GridUnitTypes. 
            //  try again with a converter-only unit (a pixel equivalent). 
            if (i >= UnitStrings.Length)
            { 
                for (i = 0; i < PixelUnitStrings.Length; ++i)
                {
                    //  Note: this is NOT a culture specific comparison.
                    //  this is by design: we want the same unit string table to work across all cultures. 
                    if (goodString.EndsWith(PixelUnitStrings[i], StringComparison.Ordinal))
                    { 
                        strLenUnit = PixelUnitStrings[i].Length; 
                        unitFactor = PixelUnitFactors[i];
                        break; 
                    }
                }
            }
 
            //  this is where we would handle leading whitespace on the input string.
            //  this is also where we would handle whitespace between [value] and [unit]. 
            //  check if we don't have a [value].  This is acceptable for certain UnitTypes. 
            if (    strLen == strLenUnit
                &&  (   unit == GridUnitType.Auto 
                    ||  unit == GridUnitType.Star   )   )
            {
                value = 1;
            } 
            //  we have a value to parse.
            else 
            { 
                Debug.Assert(   unit == GridUnitType.Pixel
                            ||  DoubleUtil.AreClose(unitFactor, 1.0)    ); 

                string valueString = goodString.Substring(0, strLen - strLenUnit);
                value = Convert.ToDouble(valueString, cultureInfo) * unitFactor;
            } 
        }
 
 
#endregion Conversions
 
#region Fields

        //  Note: keep this array in sync with the GridUnitType enum
        static private string[] UnitStrings = { "auto", "px", "*" }; 

        //  this array contains strings for unit types that are not present in the GridUnitType enum 
        static private string[] PixelUnitStrings = { "in", "cm", "pt" }; 
        static private double[] PixelUnitFactors =
        { 
            96.0,             // Pixels per Inch
            96.0 / 2.54,      // Pixels per Centimeter
            96.0 / 72.0,      // Pixels per Point
        }; 

#endregion Fields 
 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
XamlGridLengthSerializer.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
