ReachDocumentPageSerializerAsync.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Print / Reach / Serialization / manager / ReachDocumentPageSerializerAsync.cs / 1 / ReachDocumentPageSerializerAsync.cs

                            /*++ 

    Copyright (C) 2004- 2005 Microsoft Corporation
    All rights reserved.
 
    Module Name:
        ReachDocumentPageSerializerAsync.cs 
 
    Abstract:
 
    Author:
        [....] ([....]) 10-June-2005

    Revision History: 
--*/
 
using System; 
using System.Collections;
using System.Collections.Generic; 
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Reflection; 
using System.Xml;
using System.IO; 
using System.Printing; 
using System.Security;
using System.Security.Permissions; 
using System.ComponentModel.Design.Serialization;
using System.Windows.Xps.Packaging;
using System.Windows.Documents;
using System.Windows.Media; 
using System.Windows.Markup;
using System.Windows.Shapes; 
 
namespace System.Windows.Xps.Serialization
{ 
    /// 
    ///
    /// 
    internal class DocumentPageSerializerAsync : 
                   ReachSerializerAsync
    { 
        #region Constructors 

        ///  
        ///
        /// 
        public
        DocumentPageSerializerAsync( 
            PackageSerializationManager manager
            ) 
            : 
        base(manager)
        { 

        }

        #endregion Constructors 

 
        #region Public Methods 

        public 
        override
        void
        SerializeObject(
            Object serializedObject 
            )
        { 
            // 
            // Create the ImageTable required by the Type Converters
            // The Image table at this time is shared / currentPage 
            //
            ((XpsSerializationManager)SerializationManager).ResourcePolicy.CurrentPageImageTable = new Dictionary();

            base.SerializeObject(serializedObject); 
        }
 
        public 
        override
        void 
        AsyncOperation(
            ReachSerializerContext context
            )
        { 
            if(context == null)
            { 
 
            }
 
            switch (context.Action)
            {
                case SerializerAction.endPersistObjectData:
                { 
                    EndPersistObjectData();
                    break; 
                } 

                case SerializerAction.endSerializeDocumentPage: 
                {
                    ReachFixedPageSerializerContext thisContext = context as ReachFixedPageSerializerContext;
                    if(thisContext == null)
                    { 

                    } 
                    EndSerializeDocumentPage(thisContext); 
                    break;
                } 

                default:
                {
                    base.AsyncOperation(context); 
                    break;
                } 
            } 
        }
 

        /// 
        ///
        ///  
        public
        override 
        XmlWriter 
        XmlWriter
        { 
            get
            {
                if (base.XmlWriter == null)
                { 
                    base.XmlWriter = SerializationManager.AcquireXmlWriter(typeof(FixedPage));
                } 
 
                return base.XmlWriter;
            } 

            set
            {
                base.XmlWriter = null; 
                SerializationManager.ReleaseXmlWriter(typeof(FixedPage));
            } 
        } 

        #endregion Public Methods 

        /// 
        ///
        ///  
        internal
        override 
        void 
        SerializeObject(
            SerializablePropertyContext serializedProperty 
            )
        {
            //
            // Create the ImageTable required by the Type Converters 
            // The Image table at this time is shared / currentPage
            // 
            ((XpsSerializationManager)SerializationManager).ResourcePolicy.CurrentPageImageTable = new Dictionary(); 

            base.SerializeObject(serializedProperty); 
        }


        ///  
        ///
        ///  
        internal 
        override
        void 
        PersistObjectData(
            SerializableObjectContext serializableObjectContext
            )
        { 
            if (SerializationManager is XpsSerializationManager)
            { 
               (SerializationManager as XpsSerializationManager).RegisterPageStart(); 
            }
 
            //
            // A DocumentPage is persisted as a FixedPage
            //
            DocumentPage dp = (DocumentPage)serializableObjectContext.TargetObject; 

            ReachTreeWalker treeWalker = new ReachTreeWalker(this); 
            treeWalker.SerializeLinksInDocumentPage(dp); 

            XmlWriter.WriteStartElement(XpsS0Markup.FixedPage); 

            String xmlnsForType = SerializationManager.GetXmlNSForType(typeof(FixedPage));
            if (xmlnsForType != null)
            { 
                XmlWriter.WriteAttributeString(XpsS0Markup.Xmlns, xmlnsForType);
                XmlWriter.WriteAttributeString(XpsS0Markup.XmlnsX, XpsS0Markup.XmlnsXSchema); 
 
                if (SerializationManager.Language != null)
                { 
                    XmlWriter.WriteAttributeString(XpsS0Markup.XmlLang, SerializationManager.Language.ToString());
                }
                else
                { 
                    XmlWriter.WriteAttributeString(XpsS0Markup.XmlLang, XpsS0Markup.XmlLangValue);
                } 
            } 

            XpsSerializationPrintTicketRequiredEventArgs e = 
            new XpsSerializationPrintTicketRequiredEventArgs(PrintTicketLevel.FixedPagePrintTicket,
                                                                                     0);

            ((XpsSerializationManager)SerializationManager).OnXPSSerializationPrintTicketRequired(e); 

            PrintTicket printTicket = null; 
            if(e.Modified) 
            {
                printTicket = e.PrintTicket; 
            }

            Size size = Toolbox.ValidateDocumentSize(dp.Size, printTicket);
            ((XpsSerializationManager)SerializationManager).FixedPageSize = size; 

            // 
            //write length and width elements 
            //
            WriteAttribute(XmlWriter, XpsS0Markup.PageWidth, size.Width); 
            WriteAttribute(XmlWriter, XpsS0Markup.PageHeight, size.Height);

            ReachSerializerContext context = new ReachFixedPageSerializerContext(this,
                                                                                 serializableObjectContext, 
                                                                                 SerializerAction.endSerializeDocumentPage,
                                                                                 false, 
                                                                                 treeWalker); 

            ((XpsSerializationManagerAsync)SerializationManager).OperationStack.Push(context); 

            //
            // Serialize the data for the PrintTicket
            // 
            if (printTicket != null)
            { 
                PrintTicketSerializerAsync serializer = new PrintTicketSerializerAsync(SerializationManager); 
                serializer.SerializeObject(printTicket);
            } 

            SerializeChild(dp.Visual, serializableObjectContext);

        } 

        private void SerializeChild(Visual child, SerializableObjectContext parentContext) 
        { 
            ReachSerializer serializer = SerializationManager.GetSerializer(child);
 
            if (serializer != null)
            {
                serializer.SerializeObject(child);
            } 
        }
 
        private 
        void
        EndSerializeDocumentPage( 
            ReachSerializerContext context
            )
        {
            ReachFixedPageSerializerContext thisContext = context as ReachFixedPageSerializerContext; 

            if(thisContext != null) 
            { 
                ((XpsSerializationManager)SerializationManager).PackagingPolicy.PreCommitCurrentPage();
 
                //copy hyperlinks into stream
                thisContext.TreeWalker.CommitHyperlinks();

                XmlWriter.WriteEndElement(); 
                XmlWriter = null;
                // 
                // Free the image table in use for this page 
                //
                ((XpsSerializationManagerAsync)SerializationManager).ResourcePolicy.CurrentPageImageTable = null; 
                //
                // Free the colorContext table in use for this page
                //
                ((XpsSerializationManager)SerializationManager).ResourcePolicy.CurrentPageColorContextTable = null; 

                ((XpsSerializationManagerAsync)SerializationManager).VisualSerializationService.ReleaseVisualTreeFlattener(); 
 
                if( SerializationManager is XpsSerializationManager)
                { 
                   (SerializationManager as XpsSerializationManager).RegisterPageEnd();
                }
                //
                // Signal to any registered callers that the Page has been serialized 
                //
                XpsSerializationProgressChangedEventArgs progressEvent = 
                new XpsSerializationProgressChangedEventArgs(XpsWritingProgressChangeLevel.FixedPageWritingProgress, 
                                                             0,
                                                             0, 
                                                             null);

                ((XpsSerializationManager)SerializationManager).OnXPSSerializationProgressChanged(progressEvent);
            } 

        } 
 
        private void WriteAttribute(XmlWriter writer, string name, object value)
        { 
            writer.WriteAttributeString(name, TypeDescriptor.GetConverter(value).ConvertToInvariantString(value));
        }
    };
} 

// 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