ReleaseXmlWriter( Type writerType ) { Toolbox.EmitEvent(EventTrace.Event.WClientDRXReleaseWriterStart); signalReleaseToFontService(writerType); // // Allow the packaging policy to release the stream // if (_packagingPolicy != null) { if (writerType == typeof(FixedPage)) { _packagingPolicy.ReleaseXmlWriterForFixedPage(); } else { throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NotSupported)); } } Toolbox.EmitEvent(EventTrace.Event.WClientDRXReleaseWriterEnd); }
SerializeObject( Object serializedObject ) { DocumentPage dp = serializedObject as DocumentPage; if (dp != null) { Toolbox.EmitEvent(EventTrace.Event.WClientDRXGetVisualStart); Visual pageRootVisual = dp.Visual; Toolbox.EmitEvent(EventTrace.Event.WClientDRXGetVisualEnd); NgcSerializationManager NgcManager = SerializationManager as NgcSerializationManager; bool bManualStartDoc = NgcManager.StartPage(); ReachSerializer serializer = SerializationManager.GetSerializer(pageRootVisual); serializer.SerializeObject(pageRootVisual); NgcManager.EndPage(); if (bManualStartDoc) { NgcManager.EndDocument(); } } }
ReleaseXpsOMWriterForFixedDocument() { Toolbox.EmitEvent(EventTrace.Event.WClientDRXReleaseWriterStart); signalReleaseToFontService(typeof(FixedDocument)); _packagingPolicy?.ReleaseXpsOMWriterForFixedDocument(); Toolbox.EmitEvent(EventTrace.Event.WClientDRXReleaseWriterEnd); }
ConvertTo( ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType ) { if (context == null) { throw new ArgumentNullException("context"); } Toolbox.EmitEvent(EventTrace.Event.WClientDRXConvertFontBegin); if (!IsSupportedType(destinationType)) { throw new NotSupportedException(SR.Get(SRID.Converter_ConvertToNotSupported)); } PackageSerializationManager manager = (PackageSerializationManager)context.GetService(typeof(XpsSerializationManager)); // // Ensure that we have a valid GlyphRun instance // GlyphRun fontGlyphRun = (GlyphRun)value; if (fontGlyphRun == null) { throw new ArgumentException(SR.Get(SRID.MustBeOfType, "value", "GlyphRun")); } // // Obtain the font serialization service from the serlialization manager. // IServiceProvider resourceServiceProvider = manager.ResourcePolicy; XpsFontSerializationService fontService = (XpsFontSerializationService)resourceServiceProvider.GetService(typeof(XpsFontSerializationService)); if (fontService == null) { throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NoFontService)); } // // Retrieve the current font subsetter // XpsFontSubsetter fontSubsetter = fontService.FontSubsetter; // // Add the font subset to the font subsetter and retrieve a Uri // to the font within the Xps package. // Uri resourceUri = fontSubsetter.ComputeFontSubset(fontGlyphRun); Toolbox.EmitEvent(EventTrace.Event.WClientDRXConvertFontEnd); return(resourceUri); }
SerializeTree( Visual visual, XmlWriter resWriter, XmlWriter bodyWriter ) { Toolbox.EmitEvent(EventTrace.Event.WClientDRXSerializeTreeStart); Size fixedPageSize = ((IXpsSerializationManager)SerializationManager).FixedPageSize; VisualTreeFlattener flattener = ((IXpsSerializationManager)SerializationManager). VisualSerializationService.AcquireVisualTreeFlattener(resWriter, bodyWriter, fixedPageSize); Stack <NodeContext> contextStack = new Stack <NodeContext>(); if (flattener.StartVisual(visual)) { contextStack.Push(new NodeContext(visual)); } while (contextStack.Count > 0) { NodeContext ctx = contextStack.Peek(); Visual v = ctx.GetNextChild(); if (v != null) { if (flattener.StartVisual(v)) { contextStack.Push(new NodeContext(v)); } } else { contextStack.Pop(); flattener.EndVisual(); } } Toolbox.EmitEvent(EventTrace.Event.WClientDRXSerializeTreeEnd); }
SerializePageContent( object pageContent ) { Toolbox.EmitEvent(EventTrace.Event.WClientDRXSavePageBegin); ReachSerializer serializer = SerializationManager.GetSerializer(pageContent); if (serializer != null) { serializer.SerializeObject(pageContent); } else { throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NoSerializer)); } Toolbox.EmitEvent(EventTrace.Event.WClientDRXSavePageEnd); }
PersistObjectData( SerializableObjectContext serializableObjectContext ) { Toolbox.EmitEvent(EventTrace.Event.WClientDRXSerializationBegin); ReachTreeWalker treeWalker; bool needEndVisual = BeginPersistObjectData(serializableObjectContext, out treeWalker); if (serializableObjectContext.IsComplexValue) { SerializeObjectCore(serializableObjectContext); } else { throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_WrongPropertyTypeForFixedPage)); } EndPersistObjectData(needEndVisual, treeWalker); Toolbox.EmitEvent(EventTrace.Event.WClientDRXSerializationEnd); }
WalkVisual( Visual visual ) { bool bManulStartDoc = false; bool bManulStartpage = false; if (_startDocCnt == 0) { StartDocument(visual, true); bManulStartDoc = true; } if (!_isStartPage) { StartPage(); bManulStartpage = true; } // // Call VisualTreeFlattener to flatten the visual on IMetroDrawingContext // Toolbox.EmitEvent(EventTrace.Event.WClientDRXLoadPrimitiveBegin); VisualTreeFlattener.Walk(visual, _device, PageSize, new TreeWalkProgress()); Toolbox.EmitEvent(EventTrace.Event.WClientDRXLoadPrimitiveEnd); if (bManulStartpage) { EndPage(); } if (bManulStartDoc) { EndDocument(); } }
ReleaseXmlWriter( Type writerType ) { Toolbox.EmitEvent(EventTrace.Event.WClientDRXReleaseWriterStart); bool subsetComplete = false; int refCnt = DecrementRefCntByType(writerType); // // signal the font sub-setter that we completed a node if (_resourcePolicy != null) { XpsFontSerializationService fontService = (XpsFontSerializationService)_resourcePolicy.GetService(typeof(XpsFontSerializationService)); // // The font subsetter will determine if based on this // signal we have completed a subset // if (fontService != null && refCnt == 0) { subsetComplete = fontService.SignalCommit(writerType); } } // // Allow the packaging policy to release the stream // if (_packagingPolicy != null) { if (writerType == typeof(FixedDocumentSequence)) { _packagingPolicy.ReleaseXmlWriterForFixedDocumentSequence(); } else if (writerType == typeof(FixedDocument)) { _packagingPolicy.ReleaseXmlWriterForFixedDocument(); } else if (writerType == typeof(FixedPage)) { _packagingPolicy.ReleaseXmlWriterForFixedPage(); } else if (writerType == typeof(Visual)) { _packagingPolicy.ReleaseXmlWriterForFixedPage(); } else { throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NotSupported)); } } // // If the subsetting is complete we need to notify the interleaving policy // so it can flush. // if (subsetComplete && refCnt == 0) { XpsPackagingPolicy xpsPackagingPolicy = _packagingPolicy as XpsPackagingPolicy; if (xpsPackagingPolicy != null) { xpsPackagingPolicy.InterleavingPolicy.SignalSubsetComplete(); } } Toolbox.EmitEvent(EventTrace.Event.WClientDRXReleaseWriterEnd); }
SaveAsXaml( Object serializedObject ) { Toolbox.EmitEvent(EventTrace.Event.WClientDRXSaveXpsBegin); XmlWriter pageXmlWriter = null; if (serializedObject == null) { throw new ArgumentNullException("serializedObject"); } if (!IsSerializedObjectTypeSupported(serializedObject)) { throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NotSupported)); } if (serializedObject is DocumentPaginator) { // Prefast complains that serializedObject is not tested for null // It is tested a few lines up #pragma warning suppress 56506 if ((serializedObject as DocumentPaginator).Source is FixedDocument && serializedObject.GetType().ToString().Contains("FixedDocumentPaginator")) { serializedObject = (serializedObject as DocumentPaginator).Source; } else if ((serializedObject as DocumentPaginator).Source is FixedDocumentSequence && serializedObject.GetType().ToString().Contains("FixedDocumentSequencePaginator")) { serializedObject = (serializedObject as DocumentPaginator).Source; } } if (_simulator == null) { _simulator = new ReachHierarchySimulator(this, serializedObject); } if (!_isSimulating) { _simulator.BeginConfirmToXPSStructure(_isBatchMode); _isSimulating = true; } if (_isBatchMode) { pageXmlWriter = _simulator.SimulateBeginFixedPage(); } ReachSerializer reachSerializer = GetSerializer(serializedObject); if (reachSerializer != null) { // // Things that need to be done at this stage // 1. Setting the stack context // 2. Setting the root of the graph for future references // reachSerializer.SerializeObject(serializedObject); if (_isBatchMode) { _simulator.SimulateEndFixedPage(pageXmlWriter); } else { _simulator.EndConfirmToXPSStructure(_isBatchMode); } } else { throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NoSerializer)); } Toolbox.EmitEvent(EventTrace.Event.WClientDRXSaveXpsEnd); }
PersistObjectData( SerializableObjectContext serializableObjectContext ) { Toolbox.EmitEvent(EventTrace.Event.WClientDRXSerializationBegin); if (serializableObjectContext == null) { throw new ArgumentNullException("serializableObjectContext"); } if (SerializationManager is IXpsSerializationManager) { (SerializationManager as IXpsSerializationManager).RegisterPageStart(); } FixedPage fixedPage = serializableObjectContext.TargetObject as FixedPage; ReachTreeWalker treeWalker = new ReachTreeWalker(this); treeWalker.SerializeLinksInFixedPage((FixedPage)serializableObjectContext.TargetObject); String xmlnsForType = SerializationManager.GetXmlNSForType(serializableObjectContext.TargetObject.GetType()); if (xmlnsForType == null) { XmlWriter.WriteStartElement(serializableObjectContext.Name); } else { XmlWriter.WriteStartElement(serializableObjectContext.Name); XmlWriter.WriteAttributeString(XpsS0Markup.Xmlns, xmlnsForType); XmlWriter.WriteAttributeString(XpsS0Markup.XmlnsX, XpsS0Markup.XmlnsXSchema); XmlLanguage language = fixedPage.Language; if (language == null) { //If the language property is null, assign the language to the default language = XmlLanguage.GetLanguage(XpsS0Markup.XmlLangValue); } SerializationManager.Language = language; XmlWriter.WriteAttributeString(XpsS0Markup.XmlLang, language.ToString()); } { Size fixedPageSize = new Size(fixedPage.Width, fixedPage.Height); ((IXpsSerializationManager)SerializationManager).FixedPageSize = fixedPageSize; // // Before we serialize any properties on the FixedPage, we need to // serialize the FixedPage as a Visual // Visual fixedPageAsVisual = serializableObjectContext.TargetObject as Visual; bool needEndVisual = false; if (fixedPageAsVisual != null) { needEndVisual = SerializePageAsVisual(fixedPageAsVisual); } if (serializableObjectContext.IsComplexValue) { PrintTicket printTicket = ((IXpsSerializationManager)SerializationManager).FixedPagePrintTicket; if (printTicket != null) { PrintTicketSerializer serializer = new PrintTicketSerializer(SerializationManager); serializer.SerializeObject(printTicket); ((IXpsSerializationManager)SerializationManager).FixedPagePrintTicket = null; } SerializeObjectCore(serializableObjectContext); } else { throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_WrongPropertyTypeForFixedPage)); } if (needEndVisual) { XmlWriter pageWriter = ((XpsSerializationManager)SerializationManager). PackagingPolicy.AcquireXmlWriterForPage(); XmlWriter resWriter = ((XpsSerializationManager)SerializationManager). PackagingPolicy.AcquireXmlWriterForResourceDictionary(); VisualTreeFlattener flattener = ((IXpsSerializationManager)SerializationManager). VisualSerializationService.AcquireVisualTreeFlattener(resWriter, pageWriter, fixedPageSize); flattener.EndVisual(); } } ((XpsSerializationManager)SerializationManager).PackagingPolicy.PreCommitCurrentPage(); // // Copy hyperlinks into stream // treeWalker.CommitHyperlinks(); XmlWriter.WriteEndElement(); // //Release used resources // XmlWriter = null; // // Free the image table in use for this page // ((XpsSerializationManager)SerializationManager).ResourcePolicy.CurrentPageImageTable = null; // // Free the colorContext table in use for this page // ((XpsSerializationManager)SerializationManager).ResourcePolicy.CurrentPageColorContextTable = null; // // Free the resourceDictionary table in use for this page // ((XpsSerializationManager)SerializationManager).ResourcePolicy.CurrentPageResourceDictionaryTable = null; ((IXpsSerializationManager)SerializationManager).VisualSerializationService.ReleaseVisualTreeFlattener(); if (SerializationManager is IXpsSerializationManager) { (SerializationManager as IXpsSerializationManager).RegisterPageEnd(); } // // Signal to any registered callers that the Page has been serialized // XpsSerializationProgressChangedEventArgs progressEvent = new XpsSerializationProgressChangedEventArgs(XpsWritingProgressChangeLevel.FixedPageWritingProgress, 0, 0, null); ((IXpsSerializationManager)SerializationManager).OnXPSSerializationProgressChanged(progressEvent); Toolbox.EmitEvent(EventTrace.Event.WClientDRXSerializationEnd); }
SaveAsXaml( Object serializedObject ) { Toolbox.EmitEvent(EventTrace.Event.WClientDRXSaveXpsBegin); if (serializedObject == null) { throw new ArgumentNullException("serializedObject"); } if (!IsSerializedObjectTypeSupported(serializedObject)) { throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NotSupported)); } if (_isBatchMode && !_isSimulating) { XpsSerializationPrintTicketRequiredEventArgs printTicketEvent = new XpsSerializationPrintTicketRequiredEventArgs(PrintTicketLevel.FixedDocumentSequencePrintTicket, 0); OnNGCSerializationPrintTicketRequired(printTicketEvent); StartDocument(null, true); _isSimulating = true; } if (_isBatchMode) { StartPage(); } if (!_isBatchMode && IsDocumentSequencePrintTicketRequired(serializedObject)) { XpsSerializationPrintTicketRequiredEventArgs printTicketEvent = new XpsSerializationPrintTicketRequiredEventArgs(PrintTicketLevel.FixedDocumentSequencePrintTicket, 0); OnNGCSerializationPrintTicketRequired(printTicketEvent); } ReachSerializer reachSerializer = GetSerializer(serializedObject); if (reachSerializer != null) { // // Call top-level type serializer, it will walk through the contents and // all CLR and DP properties of the object and invoke the proper serializer // and typeconverter respectively // reachSerializer.SerializeObject(serializedObject); if (_isBatchMode) { EndPage(); } } else { throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NoSerializer)); } Toolbox.EmitEvent(EventTrace.Event.WClientDRXSaveXpsEnd); }
ConvertTo( ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType ) { Toolbox.EmitEvent(EventTrace.Event.WClientDRXConvertImageBegin); if (context == null) { throw new ArgumentNullException("context"); } if (!IsSupportedType(destinationType)) { throw new NotSupportedException(SR.Get(SRID.Converter_ConvertToNotSupported)); } // // Check that we have a valid BitmapSource instance. // BitmapSource bitmapSource = (BitmapSource)value; if (bitmapSource == null) { throw new ArgumentException(SR.Get(SRID.MustBeOfType, "value", "BitmapSource")); } // // Get the current serialization manager. // PackageSerializationManager manager = (PackageSerializationManager)context.GetService(typeof(XpsSerializationManager)); //Get the image Uri if it has already been serialized Uri imageUri = GetBitmapSourceFromImageTable(manager, bitmapSource); // // Get the current page image cache // Dictionary <int, Uri> currentPageImageTable = manager.ResourcePolicy.CurrentPageImageTable; if (imageUri != null) { int uriHashCode = imageUri.GetHashCode(); if (!currentPageImageTable.ContainsKey(uriHashCode)) { // // Also, add a relationship for the current page to this image // resource. This is needed to conform with Xps specification. // manager.AddRelationshipToCurrentPage(imageUri, XpsS0Markup.ResourceRelationshipName); currentPageImageTable.Add(uriHashCode, imageUri); } } else { // // This image as never serialized before so we will do it now. // Retrieve the image serialization service from the resource policy // IServiceProvider resourceServiceProvider = manager.ResourcePolicy; XpsImageSerializationService imageService = (XpsImageSerializationService)resourceServiceProvider.GetService(typeof(XpsImageSerializationService)); if (imageService == null) { throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NoImageService)); } // // Obtain a valid encoder for the image. // BitmapEncoder encoder = imageService.GetEncoder(bitmapSource); string imageMimeType = GetImageMimeType(encoder); bool isSupportedMimeType = imageService.IsSupportedMimeType(bitmapSource); // // Acquire a writable stream from the serialization manager and encode // and serialize the image into the stream. // XpsResourceStream resourceStream = manager.AcquireResourceStream(typeof(BitmapSource), imageMimeType); bool bCopiedStream = false; BitmapFrame bitmapFrame = bitmapSource as BitmapFrame; if (isSupportedMimeType && bitmapFrame != null && bitmapFrame.Decoder != null ) { BitmapDecoder decoder = bitmapFrame.Decoder; try { Uri sourceUri = new Uri(decoder.ToString()); Stream srcStream = MS.Internal.WpfWebRequestHelper.CreateRequestAndGetResponseStream(sourceUri); CopyImageStream(srcStream, resourceStream.Stream); srcStream.Close(); bCopiedStream = true; } catch (UriFormatException) { //the uri was not valid we will re-encode the image below } catch (WebException) { //Web Request failed we will re-encode the image below } } if (!bCopiedStream) { Stream stream = new MemoryStream(); ReEncodeImage(bitmapSource, encoder, stream); stream.Position = 0; CopyImageStream(stream, resourceStream.Stream); } // // Make sure to commit the resource stream by releasing it. // imageUri = resourceStream.Uri; manager.ReleaseResourceStream(typeof(BitmapSource)); AddBitmapSourceToImageTables(manager, imageUri); } Toolbox.EmitEvent(EventTrace.Event.WClientDRXConvertImageEnd); return(imageUri); }