Code:
/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Print / Reach / Packaging / XpsInterleavingPolicy.cs / 1 / XpsInterleavingPolicy.cs
/*++ Copyright (C) 2004 - 2005 Microsoft Corporation All rights reserved. Module Name: XpsInterleavingPolicy.cs Abstract: This file contains the definition and implementation for the all classes associated with the interleaving implementation. Author: [....] ([....]) 1-December-2004 Revision History: Brian Adelberg ([....]) 10/25/05 Signifigant re-write to handle updated specification --*/ using System; using System.Collections; using System.Collections.Generic; using System.IO.Packaging; using System.Windows.Xps.Serialization; namespace System.Windows.Xps.Packaging { ////// Enumerates the vairous types of interlaving provided /// by the XpsInterleavingPolicy /// public enum PackageInterleavingOrder { ////// No interleaving. Nodes are flushed when committed /// None = 0, ////// When mark up references a dependedent the depenedent has been /// streamed out out first /// Resources, pages, documents, document sequence /// ResourceFirst, ////// Knowledge of how the resource is to be used is streamed first. /// Document sequence, documents, pages resources /// ResourceLast, ////// Most depenedents are made availble first except images /// so that text can be displayed before the often larger images /// has been streamed /// ImagesLast } ////// Types of events that occur on the package /// public enum PackagingAction { ////// No action was taken /// None = 0, ////// A Document Sequence has been added /// AddingDocumentSequence = 1, ////// A Document Sequence has been completed /// DocumentSequenceCompleted = 2, ////// A Document has been added /// AddingFixedDocument = 3, ////// /// FixedDocumentCompleted = 4, ////// A Page has been added /// AddingFixedPage = 5, ////// /// FixedPageCompleted = 6, ////// A resource has been added /// ResourceAdded = 7, ////// A font has been added /// FontAdded = 8, ////// A Image has been added /// ImageAdded = 9, ////// The Xps Document has been commited /// XpsDocumentCommitted = 10 }; ////// /// public class PackagingProgressEventArgs : EventArgs { ////// /// public PackagingProgressEventArgs( PackagingAction action, int numberCompleted ) { _numberCompleted = numberCompleted; _action = action; } ////// Number of Pages Completed /// public int NumberCompleted { get { return _numberCompleted; } } ////// Number of Pages Completed /// public PackagingAction Action { get { return _action; } } private PackagingAction _action; private int _numberCompleted; }; ////// public delegate void PackagingProgressEventHandler( object sender, PackagingProgressEventArgs e ); ////// This class implements the base of the interleaving policy /// for all Xps packages written using the XpsPackage class. /// The purpose of the class is to define an order in which the /// nodes currently being written to the package will be flushed /// to the package. /// internal class XpsInterleavingPolicy { #region Constructors ////// Constructs a XpsInterleavingPolicy which is used to /// control the flushing order of all parts added to a /// package. /// public XpsInterleavingPolicy( PackageInterleavingOrder type, bool flushOnSubsetComplete ) { _flushOrderItems = new Hashtable(11); _interleavingType = type; switch( type) { case PackageInterleavingOrder.None: break; case PackageInterleavingOrder.ResourceFirst: { InitializeResourceFirst(); break; } case PackageInterleavingOrder.ResourceLast: { InitializeResourceLast(); break; } case PackageInterleavingOrder.ImagesLast: { InitializeImagesLast(); break; } default: break; } _flushOnSubsetComplete = flushOnSubsetComplete; } #endregion Constructors #region Public methods ////// This method registers a given Type with the supplied /// flush order. The higher the order, the sooner the /// Type is flushed during a commit operation. /// /// /// The flush order of the given Type. /// /// /// The class Type to register. /// public void RegisterFlushOrder( FlushOrder flushOrder, Type classType ) { _flushOrderItems.Add(classType, new FlushItem(flushOrder, classType)); } ////// /// internal event PackagingProgressEventHandler PackagingProgressEvent; #endregion Public methods #region Internal methods ////// This signals that subsetting is complete /// and if the interleaving is depenedent on subsetting /// the nodes can be flushed /// internal void SignalSubsetComplete() { if( _flushOnSubsetComplete ) { Flush(); } } ////// This method flushes all nodes in the tree using /// the supplied node to walk up and down the tree. /// The flush order is based on the registered types. /// /// /// The node used to walk up and down the tree to /// build the node flush list. /// internal void Commit( INode node ) { if ( null == node ) { throw new ArgumentNullException("node"); } // // If the current node is not part of the flush order sequence // then we just flush it alone and return // if (!_flushOrderItems.ContainsKey(node.GetType()) || _interleavingType == PackageInterleavingOrder.None) { RemoveNode(node); node.CommitInternal(); } else { MarkNodeCommited( node ); if( !_flushOnSubsetComplete ) { Flush(); } } } internal void AddItem( INode n, int number, INode parent ) { _interleavingNodes.Add( new InterleavingNode( n, number, parent ) ); PackagingAction action = GetAddType(n); if (PackagingProgressEvent != null && action != PackagingAction.None ) { PackagingProgressEvent( this, new PackagingProgressEventArgs( action, 1 ) ); } } internal PackagingAction GetAddType( INode n ) { PackagingAction action = PackagingAction.None; if( n is IXpsFixedDocumentSequenceWriter ) { action = PackagingAction.AddingDocumentSequence; } else if( n is IXpsFixedDocumentWriter ) { action = PackagingAction.AddingFixedDocument; } else if( n is IXpsFixedPageWriter ) { action = PackagingAction.AddingFixedPage; } else if( n is XpsImage) { action = PackagingAction.ImageAdded; } else if( n is XpsFont) { action = PackagingAction.FontAdded; } else if( n is XpsResource) { action = PackagingAction.ResourceAdded; } return action; } #endregion Internal methods #region Private methods private void InitializeResourceFirst() { RegisterFlushOrder(FlushOrder.FirstOrder, typeof(XpsResource)); RegisterFlushOrder(FlushOrder.FirstOrder, typeof(XpsImage)); RegisterFlushOrder(FlushOrder.FirstOrder, typeof(XpsFont)); RegisterFlushOrder(FlushOrder.FirstOrder, typeof(XpsColorContext)); RegisterFlushOrder(FlushOrder.FirstOrder, typeof(XpsResourceDictionary)); RegisterFlushOrder(FlushOrder.FirstOrder, typeof(XpsThumbnail)); RegisterFlushOrder(FlushOrder.SecondOrder, typeof(XpsFixedPageReaderWriter)); RegisterFlushOrder(FlushOrder.ThirdOrder, typeof(XpsFixedDocumentReaderWriter)); RegisterFlushOrder(FlushOrder.FourthOrder, typeof(XpsFixedDocumentSequenceReaderWriter)); RegisterFlushOrder(FlushOrder.FifthOrder, typeof(XpsDocument)); } private void InitializeResourceLast() { RegisterFlushOrder(FlushOrder.FirstOrder, typeof(XpsDocument)); RegisterFlushOrder(FlushOrder.SecondOrder, typeof(XpsFixedDocumentSequenceReaderWriter)); RegisterFlushOrder(FlushOrder.ThirdOrder, typeof(XpsFixedDocumentReaderWriter)); RegisterFlushOrder(FlushOrder.FourthOrder, typeof(XpsFixedPageReaderWriter)); RegisterFlushOrder(FlushOrder.FifthOrder, typeof(XpsResource)); RegisterFlushOrder(FlushOrder.FifthOrder, typeof(XpsImage)); RegisterFlushOrder(FlushOrder.FifthOrder, typeof(XpsFont)); RegisterFlushOrder(FlushOrder.FifthOrder, typeof(XpsColorContext)); RegisterFlushOrder(FlushOrder.FifthOrder, typeof(XpsResourceDictionary)); RegisterFlushOrder(FlushOrder.FifthOrder, typeof(XpsThumbnail)); } private void InitializeImagesLast() { RegisterFlushOrder(FlushOrder.FirstOrder, typeof(XpsResource)); RegisterFlushOrder(FlushOrder.FirstOrder, typeof(XpsFont)); RegisterFlushOrder(FlushOrder.FirstOrder, typeof(XpsColorContext)); RegisterFlushOrder(FlushOrder.FirstOrder, typeof(XpsResourceDictionary)); RegisterFlushOrder(FlushOrder.FirstOrder, typeof(XpsThumbnail)); RegisterFlushOrder(FlushOrder.SecondOrder, typeof(XpsDocument)); RegisterFlushOrder(FlushOrder.ThirdOrder, typeof(XpsFixedDocumentSequenceReaderWriter)); RegisterFlushOrder(FlushOrder.FourthOrder, typeof(XpsFixedDocumentReaderWriter)); RegisterFlushOrder(FlushOrder.FifthOrder, typeof(XpsFixedPageReaderWriter)); RegisterFlushOrder(FlushOrder.SixthOrder, typeof(XpsImage)); } private void Flush() { // // If we are not interleaving there is nothing to do here // since each node will be flushed and closeed when committed. // if (_interleavingType != PackageInterleavingOrder.None) { // //Confirm the propert resources have been committed // ConfirmCommited(); NodeComparer nodeComparer = new NodeComparer(_flushOrderItems); _interleavingNodes.Sort(nodeComparer); // // Flush the nodes in order // ListremoveList = new List (); int pageCnt = 0; int documentCnt = 0; bool docSeqCommited = false; bool xpsDocCommited = false; foreach (InterleavingNode n in _interleavingNodes) { if (n.Commited) { if( n.Node is XpsFixedPageReaderWriter ) { pageCnt++; } else if( n.Node is XpsFixedDocumentReaderWriter ) { documentCnt++; } else if( n.Node is XpsFixedDocumentSequenceReaderWriter ) { docSeqCommited = true; } else if( n.Node is XpsDocument ) { xpsDocCommited = true; } n.Node.CommitInternal(); removeList.Add(n); } else { n.Node.Flush(); } } foreach (InterleavingNode n in removeList) { _interleavingNodes.Remove(n); } if (PackagingProgressEvent != null ) { if( pageCnt != 0 ) { PackagingProgressEvent( this, new PackagingProgressEventArgs( PackagingAction.FixedPageCompleted, pageCnt ) ); } if( documentCnt != 0 ) { PackagingProgressEvent( this, new PackagingProgressEventArgs( PackagingAction.FixedDocumentCompleted, documentCnt ) ); } if( docSeqCommited ) { PackagingProgressEvent( this, new PackagingProgressEventArgs( PackagingAction.DocumentSequenceCompleted, 1 ) ); } if( xpsDocCommited ) { PackagingProgressEvent( this, new PackagingProgressEventArgs( PackagingAction.XpsDocumentCommitted, 1 ) ); } } } } private void MarkNodeCommited(INode node ) { foreach( InterleavingNode n in _interleavingNodes ) { if( Object.ReferenceEquals(node, n.Node)) { n.Commited = true; } } } private void RemoveNode(INode node) { foreach (InterleavingNode n in _interleavingNodes) { if (Object.ReferenceEquals(node, n.Node)) { _interleavingNodes.Remove(n); break; } } } // // When a flushing only the document, // the document sequence and the XpsDocument could still not // be complete // private void ConfirmCommited() { foreach( InterleavingNode n in _interleavingNodes ) { if(IsPartialFlushAllowed(n)) { continue; } if( !n.Commited ) { throw new XpsPackagingException(ReachSR.Get(ReachSRID.ReachPackaging_DependantsNotCommitted)); } } } /// /// Tests wether a part can be flushed with out being committed /// private bool IsPartialFlushAllowed( InterleavingNode n ) { bool ret = false; if( n.Node is IXpsFixedDocumentWriter || n.Node is IXpsFixedDocumentSequenceWriter || n.Node is XpsDocument ) { ret = true; } return ret; } #endregion Private methods #region Private data private Hashtable _flushOrderItems; private List_interleavingNodes = new List (); private bool _flushOnSubsetComplete; private PackageInterleavingOrder _interleavingType; #endregion Private data } class NodeComparer : IComparer { #region Constructors public NodeComparer( Hashtable flushOrderTable ) { _orderTable = flushOrderTable; } #endregion Constructors #region IComparer Members int IComparer .Compare( InterleavingNode x, InterleavingNode y ) { FlushItem xOrder = (FlushItem)_orderTable[x.Node.GetType()]; FlushItem yOrder = (FlushItem)_orderTable[y.Node.GetType()]; return xOrder.FlushOrder.CompareTo(yOrder.FlushOrder); } #endregion #region Object Members #endregion #region Private data private Hashtable _orderTable; #endregion Private data } internal interface INode { #region Public properties Uri Uri { get; } #endregion Public properties #region Public methods void Flush( ); void CommitInternal( ); PackagePart GetPart( ); #endregion Public methods } /// /// Helper class to bind flush order with a specific type /// Used by the Node Comparer in ordering Nodes by type and Flush Order /// internal class FlushItem { #region Constructors internal FlushItem( FlushOrder flushOrder, Type classType ) { _flushOrder = flushOrder; _classType = classType; } #endregion Constructors #region Public properties ////// Gets FlushOrder for this item. /// ////// A FlushOrder value. /// internal FlushOrder FlushOrder { get { return _flushOrder; } } ////// Gets the class Type of this item. /// ////// A Type value. /// public Type ClassType { get { return _classType; } } #endregion Public properties #region Private data private FlushOrder _flushOrder; private Type _classType; #endregion Private data } internal class InterleavingNode { internal InterleavingNode( INode node, int number, INode parent ) { _node = node; _number = number; _parent = parent; _commited = false; } public bool Commited { get { return _commited; } set { _commited = value; } } public INode Node { get { return _node; } } public int Number { get { return _number; } } public INode Parent { get { return _parent; } } private INode _node; private int _number; private INode _parent; private bool _commited; } ////// /// internal enum FlushOrder { ////// /// None = 0, ////// /// FirstOrder = 1, ////// /// SecondOrder = 2, ////// /// ThirdOrder = 3, ////// /// FourthOrder = 4, ////// /// FifthOrder = 5, ////// /// SixthOrder = 6 } } // 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
- BroadcastEventHelper.cs
- PropertyRecord.cs
- TextParaClient.cs
- DragEventArgs.cs
- ListBindingHelper.cs
- ElementMarkupObject.cs
- NaturalLanguageHyphenator.cs
- DataAdapter.cs
- TraceEventCache.cs
- CompensationDesigner.cs
- MemberInitExpression.cs
- HttpListenerPrefixCollection.cs
- ActivationServices.cs
- OrCondition.cs
- HtmlEncodedRawTextWriter.cs
- SkipStoryboardToFill.cs
- DiagnosticTrace.cs
- TextSchema.cs
- Ref.cs
- InterleavedZipPartStream.cs
- GridViewActionList.cs
- ConfigurationSectionCollection.cs
- ViewManager.cs
- MessageDecoder.cs
- DoubleIndependentAnimationStorage.cs
- SemanticResolver.cs
- ClientBuildManagerCallback.cs
- XhtmlTextWriter.cs
- PrintPreviewDialog.cs
- sqlcontext.cs
- TemplateComponentConnector.cs
- EncoderNLS.cs
- DataGridViewLinkColumn.cs
- AdornedElementPlaceholder.cs
- AttributeProviderAttribute.cs
- ConstructorExpr.cs
- DirectoryNotFoundException.cs
- QueryAccessibilityHelpEvent.cs
- SequenceFullException.cs
- _SpnDictionary.cs
- ListDesigner.cs
- NavigationFailedEventArgs.cs
- InputProcessorProfilesLoader.cs
- EntityModelBuildProvider.cs
- PrivacyNoticeBindingElement.cs
- QuestionEventArgs.cs
- HierarchicalDataSourceControl.cs
- AutomationEventArgs.cs
- CodeAssignStatement.cs
- Types.cs
- DataSpaceManager.cs
- PatternMatcher.cs
- DataTableClearEvent.cs
- RenderDataDrawingContext.cs
- LayoutInformation.cs
- UdpDiscoveryEndpoint.cs
- StylusShape.cs
- TransformedBitmap.cs
- HttpClientCertificate.cs
- FontStyleConverter.cs
- HyperLinkStyle.cs
- Group.cs
- XmlNodeReader.cs
- WebBrowserNavigatedEventHandler.cs
- SystemResources.cs
- IPipelineRuntime.cs
- InheritablePropertyChangeInfo.cs
- WebPartDescriptionCollection.cs
- QilLiteral.cs
- InputBinder.cs
- OutOfMemoryException.cs
- CodeNamespaceImportCollection.cs
- LassoSelectionBehavior.cs
- RuntimeArgumentHandle.cs
- ObjectDesignerDataSourceView.cs
- XmlEncoding.cs
- XomlDesignerLoader.cs
- UnorderedHashRepartitionStream.cs
- SmtpTransport.cs
- XmlStreamNodeWriter.cs
- DateTime.cs
- CodeCatchClause.cs
- PointCollection.cs
- RelationshipConverter.cs
- CodeAttributeDeclarationCollection.cs
- ComponentCommands.cs
- FormsAuthenticationModule.cs
- Activity.cs
- OleDbParameter.cs
- MediaElement.cs
- XmlSchemaInferenceException.cs
- JoinSymbol.cs
- WebPartCatalogAddVerb.cs
- SelectionProcessor.cs
- SqlFunctionAttribute.cs
- RootBrowserWindow.cs
- CommittableTransaction.cs
- ICspAsymmetricAlgorithm.cs
- NotifyIcon.cs
- HtmlInputButton.cs