ReachTreeWalker( XmlWriter writer, PackageSerializationManager serializationManager) { _serializerXmlWriter = writer; _serializationManager = serializationManager; }
VisualSerializationService( PackageSerializationManager serializationManager ) { _serializationManager = serializationManager; _visualTreeFlattener = null; }
NgcDocumentSequenceSerializerAsync( PackageSerializationManager manager ) : base(manager) { }
IsComplexValue( PackageSerializationManager manager, out bool canConvert ) { bool isComplex = true; canConvert = true; if (SerializerType != null) { isComplex = true; } else { TypeConverter converter = this.TypeConverter; canConvert = converter.CanConvertTo(null, typeof(string)) && converter.CanConvertFrom(null, typeof(string)); if (canConvert) { isComplex = false; } } return(isComplex); }
DocumentPaginatorSerializerAsync( PackageSerializationManager manager ) : base(manager) { }
FixedPageSerializer( PackageSerializationManager manager ): base(manager) { }
DocumentPageSerializer( PackageSerializationManager manager ) : base(manager) { }
GetBitmapSourceFromImageTable(PackageSerializationManager manager, BitmapSource bitmapSource) { Uri imageUri = null; //Initialize cache values _uriHashValue = 0; _crc32HashValue = 0; BitmapFrame bitmapFrame = bitmapSource as BitmapFrame; //Use the Uri hash table if we have a bitmap with a Uri if (bitmapFrame != null && bitmapFrame.Decoder != null) { String sourceUri = bitmapFrame.Decoder.ToString(); if (sourceUri != null) { _uriHashValue = sourceUri.GetHashCode(); Dictionary <int, Uri> imageUriHashTable = manager.ResourcePolicy.ImageUriHashTable; if (imageUriHashTable.ContainsKey(_uriHashValue)) { imageUri = imageUriHashTable[_uriHashValue]; } } } //Checking the UriHash for zero tells us if the uri of the bitmap was checked and if it returned a valid Uri if (_uriHashValue == 0) { // // Calculate the image Crc32 value. This is used as a key // into the image cache. // _crc32HashValue = CalculateImageCrc32(bitmapSource); // // Get the current image cache // Dictionary <UInt32, Uri> imageCrcTable = manager.ResourcePolicy.ImageCrcTable; // // The image has already been cached (and therefore serialized). // No need to serialize it again so we just return the Uri in the // package where the original was serialized. For that Uri returned // a relationship is only created if this has not been included on // the current page before. // if (imageCrcTable.ContainsKey(_crc32HashValue)) { imageUri = imageCrcTable[_crc32HashValue]; } } return(imageUri); }
XpsOMFixedPageSerializer( PackageSerializationManager manager ) : base(manager) { /// /// Fail if manager is not XpsOMSerializationManager /// _xpsOMSerializationManager = (XpsOMSerializationManager)manager; }
NgcDocumentPageSerializerAsync( PackageSerializationManager manager ) : base(manager) { if (manager == null) { throw new ArgumentNullException("manager"); } }
XpsOMDocumentSequenceSerializer( PackageSerializationManager manager ) : base(manager) { /// /// Fail if manager is not XpsOMSerializationManager /// _xpsOMSerializationManager = (XpsOMSerializationManager)manager; }
NgcFixedDocumentSerializer( PackageSerializationManager manager ) : base(manager) { if (manager == null) { throw new ArgumentNullException("manager"); } }
NgcReachVisualSerializer( PackageSerializationManager manager ) : base(manager) { if (manager == null) { throw new ArgumentNullException("manager"); } }
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); }
ReachSerializer( PackageSerializationManager manager ) { if (manager == null) { throw new ArgumentNullException("manager"); } _serializationManager = manager; _xmlWriter = null; }
IsComplexProperty( PackageSerializationManager serializationManager ) { bool isComplex = false; // // Null property value is always serialized // in simple attribute="*null" notation // if (Value != null) { // // If the property has a DesignerSerializationOptions.SerializeAsAttribute // then obviously we do not use complex notation // if (!(DesignerSerializationOptionsAttribute != null && (DesignerSerializationOptionsAttribute.DesignerSerializationOptions == DesignerSerializationOptions.SerializeAsAttribute))) { // // String space preservation is honored by System.Xml only for contents of a tag not within // an attribute value. Hence we always emit strings as content within a tag // Type valueType = Value.GetType(); if (valueType == typeof(string) && ((string)Value) != string.Empty) { isComplex = true; } else { bool canConvert; isComplex = IsComplexValue(serializationManager, out canConvert); if (!canConvert) { Expression expr = this.Value as Expression; if (expr != null) { this.Value = ((DependencyObject)this.TargetObject).GetValue((DependencyProperty)this.DependencyProperty); isComplex = this.IsComplexProperty(serializationManager); } } } } } return(isComplex); }
XpsOMFixedPageSerializerAsync( PackageSerializationManager manager ) : base(manager) { /// /// Fail if manager is not XpsOMSerializationManagerAsync /// _xpsOMSerializationManagerAsync = (XpsOMSerializationManagerAsync)manager; _syncSerializer = new XpsOMFixedPageSerializer(manager); }
XpsOMDocumentSequenceSerializerAsync( PackageSerializationManager manager ) : base(manager) { /// /// Fail if manager is not XpsOMSerializationManagerAsync /// _xpsOMSerializationManagerAsync = (XpsOMSerializationManagerAsync)manager; _syncSerializer = new XpsOMDocumentSequenceSerializer(manager); }
SerializersCacheManager( PackageSerializationManager serializationManager ) { this._serializationManager = serializationManager; // // Allocate all necessary hashtables for storing // the cache information // _typesCacheTable = new Hashtable(20); _serializersTable = new Hashtable(20); _typesDependencyPropertiesCacheTable = new Hashtable(20); }
XpsTokenContext( PackageSerializationManager serializationManager, Object targetObject, Object objectValue ) { // // Make necessary checks and throw necessary exceptions // this.serializationManager = serializationManager; this.targetObject = targetObject; this.objectValue = objectValue; this.propertyInfo = null; this.dependencyProperty = null; }
AddBitmapSourceToImageTables(PackageSerializationManager manager, Uri imageUri) { if (_uriHashValue != 0) { manager.ResourcePolicy.ImageUriHashTable.Add(_uriHashValue, imageUri); _uriHashValue = 0; } else { manager.ResourcePolicy.ImageCrcTable.Add(_crc32HashValue, imageUri); _crc32HashValue = 0; } manager.ResourcePolicy.CurrentPageImageTable.Add(imageUri.GetHashCode(), imageUri); }
XpsTokenContext( PackageSerializationManager serializationManager, SerializablePropertyContext propertyContext ) { // // Make necessary checks and throw necessary exceptions // this.serializationManager = serializationManager; this.targetObject = propertyContext.TargetObject; this.objectValue = propertyContext.Value; this.propertyInfo = propertyContext.PropertyInfo; this.dependencyProperty = (propertyContext is SerializableDependencyPropertyContext) ? (DependencyProperty)((SerializableDependencyPropertyContext)propertyContext).DependencyProperty : null; }
SerializablePropertyCollection( PackageSerializationManager manager, object targetObject ) { this._simplePropertyCollection = null; this._complexPropertyCollection = null; this._simplePropertiesIndex = -1; this._complexPropertiesIndex = -1; this._queueEnumerator = null; this._serializationManager = manager; this._target = targetObject; this._isSimpleMode = true; Initialize(manager, _target); }
NGCSerializerAsync( PackageSerializationManager manager ) { if (manager == null) { throw new ArgumentNullException("manager"); } _serializationManager = manager as NgcSerializationManagerAsync; if (_serializationManager == null) { throw new XpsSerializationException(SR.Get(SRID.ReachSerializationAsync_NoNgcType)); } }
Initialize( PackageSerializationManager serializationManager, object targetObject ) { this._serializationManager = serializationManager; this._target = targetObject; // // Collect all serializable properties on the // current object instance. Those could be // o clr properties // o dependency properties // if (_simplePropertyCollection == null) { _simplePropertyCollection = new Queue(); } if (_complexPropertyCollection == null) { _complexPropertyCollection = new Queue(); } // // Collecting information about the CLR properties // InitializeSerializableClrProperties(); // // Now that we are done with the clr serializable properties we need to // iterate through locally set dependency properties on this instance // that have not been serialized already. // Note: Dependency Properties can only be set on Dependency Objects // InitializeSerializableDependencyProperties(); // // Reset the enumerator // to begin enumerating // from the start of the // properties collection // Reset(); }
ReachSerializerAsync( PackageSerializationManager manager ) { if (manager == null) { throw new ArgumentNullException("manager"); } _serializationManager = manager as IXpsSerializationManagerAsync; if (_serializationManager == null) { throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NotXpsSerializationManagerAsync)); } _xmlWriter = null; }
ReachHierarchySimulator( PackageSerializationManager manager, Object serializedObject ) { if (manager == null) { throw new ArgumentNullException("manager"); } if (serializedObject == null) { throw new ArgumentNullException("manager"); } this._serializationManager = manager; this._serializedObject = serializedObject; this._documentSequenceXmlWriter = null; this._documentXmlWriter = null; this._pageXmlWriter = null; }
PrintTicketSerializerAsync( PackageSerializationManager manager ) : base(manager) { }
ReachDocumentReferenceCollectionSerializer( PackageSerializationManager manager ) : base(manager) { }
FixedDocumentSerializerAsync( PackageSerializationManager manager ) : base(manager) { }