SerializeObject(
Object serializedObject
)
{
if (serializedObject == null)
{
throw new ArgumentNullException("serializedObject");
}
if (SerializationManager == null)
{
throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_MustHaveSerializationManager));
}
//
// At this stage discover the graph of properties of the object that
// need to be serialized
//
SerializableObjectContext serializableObjectContext = DiscoverObjectData(serializedObject,
null);
if (serializableObjectContext != null)
{
//
// Push the object at hand on the context stack
//
SerializationManager.GraphContextStack.Push(serializableObjectContext);
//
// At this stage we should start streaming the markup representing the
// object graph to the corresponding destination
//
PersistObjectData(serializableObjectContext);
//
// Pop the object from the context stack
//
SerializationManager.GraphContextStack.Pop();
//
// Recycle the used SerializableObjectContext
//
SerializableObjectContext.RecycleContext(serializableObjectContext);
}
}
SerializePageContents(
SerializableObjectContext serializableObjectContext
)
{
//
// Serialize each PageContent in PageContentColleciton
//
IEnumerator enumerator = ((IEnumerable)serializableObjectContext.TargetObject).GetEnumerator();
enumerator.Reset();
PageContentCollectionSerializerContext
context = new PageContentCollectionSerializerContext(this,
serializableObjectContext,
enumerator,
SerializerAction.serializeNextPageContent);
((IXpsSerializationManagerAsync)SerializationManager).OperationStack.Push(context);
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
if (serializableObjectContext == null)
{
throw new ArgumentNullException("serializableObjectContext");
}
// get DocumentReferenceCollection
System.Collections.Generic.IEnumerable <DocumentReference> enumerableObject = serializableObjectContext.TargetObject as System.Collections.Generic.IEnumerable <DocumentReference>;
if (enumerableObject == null)
{
throw new XpsSerializationException(SR.Get(SRID.MustBeOfType, "serializableObjectContext.TargetObject", typeof(System.Collections.Generic.IEnumerable <DocumentReference>)));
}
SerializeDocumentReferences(serializableObjectContext);
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
if (serializableObjectContext.IsComplexValue)
{
ReachSerializerContext context = new ReachSerializerContext(this,
serializableObjectContext,
SerializerAction.serializeDocument);
((IXpsSerializationManagerAsync)SerializationManager).OperationStack.Push(context);
SerializeObjectCore(serializableObjectContext);
}
else
{
// What about this case? Is IsComplexValue something we really want to check for this?
}
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
_syncSerializer.BeginPersistObjectData(serializableObjectContext);
if (serializableObjectContext.IsComplexValue)
{
ReachSerializerContext context = new ReachSerializerContext(this,
SerializerAction.endPersistObjectData);
_xpsOMSerializationManagerAsync.OperationStack.Push(context);
SerializeObjectCore(serializableObjectContext);
}
else
{
throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_WrongPropertyTypeForFixedDocument));
}
}
SerializeNextUIElement(
IEnumerator enumerator,
SerializableObjectContext serializableObjectContext
)
{
if (enumerator.MoveNext())
{
NgcUIElementCollectionSerializerContext context = new NgcUIElementCollectionSerializerContext(this,
serializableObjectContext,
enumerator,
SerializerAction.serializeNextUIElement);
((NgcSerializationManagerAsync)SerializationManager).OperationStack.Push(context);
object uiElement = enumerator.Current;
SerializeUIElement(uiElement);
}
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
DocumentPaginator paginator = BeginPersistObjectData(serializableObjectContext);
for (int i = 0; !paginator.IsPageCountValid || (i < paginator.PageCount); i++)
{
DocumentPage page = Toolbox.GetPage(paginator, i);
ReachSerializer serializer = SerializationManager.GetSerializer(page);
if (serializer != null)
{
serializer.SerializeObject(page);
}
}
EndPersistObjectData();
}
SerializeObjectInternal(
Object serializedObject
)
{
//
// Create the ImageTable required by the Type Converters
// The Image table at this time is shared / document
//
_xpsOMSerializationManager.ResourcePolicy.ImageCrcTable = new Dictionary <UInt32, Uri>();
_xpsOMSerializationManager.ResourcePolicy.ImageUriHashTable = new Dictionary <int, Uri>();
//
// Create the ColorContextTable required by the Type Converters
// The ColorContext table at this time is shared / document
//
_xpsOMSerializationManager.ResourcePolicy.ColorContextTable = new Dictionary <int, Uri>();
SerializableObjectContext serializableObjectContext = new SerializableObjectContext(serializedObject, null);
return(serializableObjectContext);
}
SerializeObject(
Object serializedObject
)
{
//
// Create the ImageTable required by the Type Converters
// The Image table at this time is shared / document
//
((XpsSerializationManager)SerializationManager).ResourcePolicy.ImageCrcTable = new Dictionary <UInt32, Uri>();
((XpsSerializationManager)SerializationManager).ResourcePolicy.ImageUriHashTable = new Dictionary <int, Uri>();
//
// Create the ColorContextTable required by the Type Converters
// The ColorContext table at this time is shared / document
//
((XpsSerializationManager)SerializationManager).ResourcePolicy.ColorContextTable = new Dictionary <int, Uri>();
SerializableObjectContext serializableObjectContext = new SerializableObjectContext(serializedObject, null);
PersistObjectData(serializableObjectContext);
}
SerializeNextDocumentReference(
IEnumerator enumerator,
SerializableObjectContext serializableObjectContext
)
{
if (enumerator.MoveNext())
{
NgcDocumentReferenceCollectionSerializerContext
context = new NgcDocumentReferenceCollectionSerializerContext(this,
serializableObjectContext,
enumerator,
SerializerAction.serializeNextDocumentReference);
NgcSerializationManager.OperationStack.Push(context);
object documentReference = enumerator.Current;
SerializeDocumentReference(documentReference);
}
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
if (serializableObjectContext == null)
{
throw new ArgumentNullException("serializableObjectContext");
}
IEnumerable enumerableObject = serializableObjectContext.TargetObject as IEnumerable;
if (enumerableObject == null)
{
throw new XpsSerializationException(SR.Get(SRID.MustBeOfType, "serializableObjectContext.TargetObject", typeof(IEnumerable)));
}
//
// Serialize the PageContent Items contained within the collection
//
SerializePageContents(serializableObjectContext);
}
SerializeNextPageContent(
IEnumerator enumerator,
SerializableObjectContext serializableObjectContext
)
{
if (enumerator.MoveNext())
{
PageContentCollectionSerializerContext
context = new PageContentCollectionSerializerContext(this,
serializableObjectContext,
enumerator,
SerializerAction.serializeNextPageContent);
((IXpsSerializationManagerAsync)SerializationManager).OperationStack.Push(context);
object pageContent = enumerator.Current;
SerializePageContent(pageContent);
}
}
BeginSerializeObject(
SerializablePropertyContext serializedProperty
)
{
if (serializedProperty == null)
{
throw new ArgumentNullException("serializedProperty");
}
if (SerializationManager == null)
{
throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_MustHaveSerializationManager));
}
//
// At this stage discover the graph of properties of the object that
// need to be serialized
//
SerializableObjectContext serializableObjectContext = DiscoverObjectData(serializedProperty.Value,
serializedProperty);
if (serializableObjectContext != null)
{
//
// Push the object at hand on the context stack
//
SerializationManager.GraphContextStack.Push(serializableObjectContext);
ReachSerializerContext context = new ReachSerializerContext(this,
serializableObjectContext,
SerializerAction.endSerializeObject);
_serializationManager.OperationStack.Push(context);
//
// At this stage we should start streaming the markup representing the
// object graph to the corresponding destination
//
PersistObjectData(serializableObjectContext);
}
}
SerializeNextProperty(
SerializableObjectContext serializableObjectContext
)
{
SerializablePropertyCollection propertyCollection = serializableObjectContext.PropertiesCollection;
if (propertyCollection.MoveNext())
{
SerializablePropertyContext serializablePropertyContext =
(SerializablePropertyContext)propertyCollection.Current;
if (serializablePropertyContext != null)
{
ReachSerializerContext context = new ReachSerializerContext(this,
serializableObjectContext,
SerializerAction.serializeNextProperty);
_serializationManager.OperationStack.Push(context);
SerializeProperty(serializablePropertyContext);
}
}
}
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);
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
if (serializableObjectContext.IsComplexValue)
{
SerializeObjectCore(serializableObjectContext);
// Loads the document
FixedDocument document = ((DocumentReference)serializableObjectContext.TargetObject).GetDocument(false);
if (document.IsInitialized == false)
{
// Give a parser item a kick
document.Dispatcher.Invoke(DispatcherPriority.ApplicationIdle,
new DispatcherOperationCallback(Idle), null);
}
if (document != null)
{
ReachSerializer serializer = SerializationManager.GetSerializer(document);
if (serializer != null)
{
serializer.SerializeObject(document);
}
else
{
// This shouldn't ever happen.
throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NoSerializer));
}
}
}
else
{
// What about this case? Is IsComplexValue something we really want to check for this?
}
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
DocumentPaginator paginator = _syncSerializer.BeginPersistObjectData(serializableObjectContext);
ReachSerializerContext context = new ReachSerializerContext(this,
SerializerAction.endPersistObjectData);
_xpsOMSerializationManagerAsync.OperationStack.Push(context);
int index = 0;
DocumentPaginatorSerializerContext
collectionContext = new DocumentPaginatorSerializerContext(this,
serializableObjectContext,
paginator,
index,
SerializerAction.serializeNextDocumentPage);
_xpsOMSerializationManagerAsync.OperationStack.Push(collectionContext);
}
BeginSerializeObject(
Object serializedObject
)
{
IEnumerator enumerator =
((System.Collections.Generic.IEnumerable <DocumentReference>)serializedObject).
GetEnumerator();
enumerator.Reset();
SerializableObjectContext serializableObjectContext =
SerializableObjectContext.CreateContext(SerializationManager,
serializedObject,
null,
null);
NgcDocumentReferenceCollectionSerializerContext
context = new NgcDocumentReferenceCollectionSerializerContext(this,
serializableObjectContext,
enumerator,
SerializerAction.serializeNextDocumentReference);
NgcSerializationManager.OperationStack.Push(context);
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
ReachTreeWalker treeWalker;
bool needEndVisual = _syncSerializer.BeginPersistObjectData(serializableObjectContext, out treeWalker);
if (serializableObjectContext.IsComplexValue)
{
ReachSerializerContext context = new ReachFixedPageSerializerContext(this,
serializableObjectContext,
SerializerAction.endSerializeReachFixedPage,
needEndVisual,
treeWalker);
_xpsOMSerializationManagerAsync.OperationStack.Push(context);
SerializeObjectCore(serializableObjectContext);
}
else
{
throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_WrongPropertyTypeForFixedPage));
}
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
String xmlnsForType = SerializationManager.GetXmlNSForType(typeof(FixedDocumentSequence));
if (SerializationManager is XpsSerializationManager)
{
(SerializationManager as XpsSerializationManager).RegisterDocumentSequenceStart();
}
if (xmlnsForType == null)
{
XmlWriter.WriteStartElement(serializableObjectContext.Name);
}
else
{
XmlWriter.WriteStartElement(serializableObjectContext.Name,
xmlnsForType);
}
{
if (serializableObjectContext.IsComplexValue)
{
//
// Pick the data for the PrintTicket if it existed
//
XpsSerializationPrintTicketRequiredEventArgs e =
new XpsSerializationPrintTicketRequiredEventArgs(PrintTicketLevel.FixedDocumentSequencePrintTicket,
0);
((IXpsSerializationManager)SerializationManager).OnXPSSerializationPrintTicketRequired(e);
//
// Serialize the data for the PrintTicket
//
if (e.Modified)
{
if (e.PrintTicket != null)
{
PrintTicketSerializer serializer = new PrintTicketSerializer(SerializationManager);
serializer.SerializeObject(e.PrintTicket);
}
}
SerializeObjectCore(serializableObjectContext);
}
else
{
}
}
XmlWriter.WriteEndElement();
XmlWriter = null;
//
// Signal to any registered callers that the Sequence has been serialized
//
XpsSerializationProgressChangedEventArgs progressEvent =
new XpsSerializationProgressChangedEventArgs(XpsWritingProgressChangeLevel.FixedDocumentSequenceWritingProgress,
0,
0,
null);
if (SerializationManager is XpsSerializationManager)
{
(SerializationManager as XpsSerializationManager).RegisterDocumentSequenceEnd();
}
((IXpsSerializationManager)SerializationManager).OnXPSSerializationProgressChanged(progressEvent);
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
String xmlnsForType = SerializationManager.GetXmlNSForType(typeof(FixedDocument));
String nameForType = XpsS0Markup.FixedDocument;
if (SerializationManager is XpsSerializationManager)
{
(SerializationManager as XpsSerializationManager).RegisterDocumentStart();
}
if (xmlnsForType == null)
{
XmlWriter.WriteStartElement(nameForType);
}
else
{
XmlWriter.WriteStartElement(nameForType,
xmlnsForType);
}
{
XpsSerializationPrintTicketRequiredEventArgs e =
new XpsSerializationPrintTicketRequiredEventArgs(PrintTicketLevel.FixedDocumentPrintTicket,
0);
((IXpsSerializationManager)SerializationManager).OnXPSSerializationPrintTicketRequired(e);
//
// Serialize the data for the PrintTicket
//
if (e.Modified)
{
if (e.PrintTicket != null)
{
PrintTicketSerializer serializer = new PrintTicketSerializer(SerializationManager);
serializer.SerializeObject(e.PrintTicket);
}
}
DocumentPaginator paginator = (DocumentPaginator)serializableObjectContext.TargetObject;
XmlLanguage language = null;
DependencyObject dependencyObject = paginator.Source as DependencyObject;
if (dependencyObject != null)
{
language = (XmlLanguage)dependencyObject.GetValue(FrameworkContentElement.LanguageProperty);
}
if (language == null)
{
//If the language property is null, assign the language to the default
language = XmlLanguage.GetLanguage(XpsS0Markup.XmlLangValue);
}
SerializationManager.Language = language;
for (int i = 0; !paginator.IsPageCountValid || (i < paginator.PageCount); i++)
{
DocumentPage page = Toolbox.GetPage(paginator, i);
ReachSerializer serializer = SerializationManager.GetSerializer(page);
if (serializer != null)
{
serializer.SerializeObject(page);
}
}
}
XmlWriter.WriteEndElement();
XmlWriter = null;
//
// Clear off the table from the resource policy
//
((XpsSerializationManager)SerializationManager).ResourcePolicy.ImageCrcTable = null;
((XpsSerializationManager)SerializationManager).ResourcePolicy.ImageUriHashTable = null;
//
// Clear off the table from the resource policy
//
((XpsSerializationManager)SerializationManager).ResourcePolicy.ColorContextTable = null;
//
// Signal to any registered callers that the Document has been serialized
//
XpsSerializationProgressChangedEventArgs progressEvent =
new XpsSerializationProgressChangedEventArgs(XpsWritingProgressChangeLevel.FixedDocumentWritingProgress,
0,
0,
null);
if (SerializationManager is XpsSerializationManager)
{
(SerializationManager as XpsSerializationManager).RegisterDocumentEnd();
}
((IXpsSerializationManager)SerializationManager).OnXPSSerializationProgressChanged(progressEvent);
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
if (SerializationManager is IXpsSerializationManager)
{
(SerializationManager as IXpsSerializationManager).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);
((IXpsSerializationManager)SerializationManager).OnXPSSerializationPrintTicketRequired(e);
PrintTicket printTicket = null;
if(e.Modified)
{
printTicket = e.PrintTicket;
}
Size size = Toolbox.ValidateDocumentSize(dp.Size, printTicket);
((IXpsSerializationManager)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);
((IXpsSerializationManagerAsync)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);
}
BeginSerializeDocumentPage(
SerializableObjectContext serializableObjectContext
)
{
PrintTicket printTicket = null;
_xpsOMSerializationManager.RegisterPageStart();
XpsSerializationPrintTicketRequiredEventArgs e =
new XpsSerializationPrintTicketRequiredEventArgs(PrintTicketLevel.FixedPagePrintTicket,
0);
_xpsOMSerializationManager.OnXPSSerializationPrintTicketRequired(e);
if (e.Modified)
{
printTicket = e.PrintTicket;
}
//
// Serialize the data for the PrintTicket
//
if (printTicket != null)
{
PrintTicketSerializer serializer = new PrintTicketSerializer(SerializationManager);
serializer.SerializeObject(printTicket);
}
//
// 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);
}
}
Size size = Toolbox.ValidateDocumentSize(dp.Size, printTicket);
_xpsOMSerializationManager.FixedPageSize = size;
//
//write length and width elements
//
WriteAttribute(XmlWriter, XpsS0Markup.PageWidth, size.Width);
WriteAttribute(XmlWriter, XpsS0Markup.PageHeight, size.Height);
return(treeWalker);
}
CreateContext(
PackageSerializationManager serializationManager,
object serializableObject,
SerializableObjectContext serializableObjectParentContext,
SerializablePropertyContext serializablePropertyContext
)
{
//
// Check for element pre-existance to avoid infinite loops
// in the process of serialization
//
int stackIndex = 0;
object currentObject = null;
for (currentObject = serializationManager.GraphContextStack[stackIndex];
currentObject != null;
currentObject = serializationManager.GraphContextStack[++stackIndex])
{
SerializableObjectContext currentObjectContext = currentObject as SerializableObjectContext;
if (currentObjectContext != null &&
currentObjectContext.TargetObject == serializableObject)
{
throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_CycleDetectedInSerialization));
}
}
SerializableObjectContext serializableObjectContext;
lock (_stackLock)
{
serializableObjectContext =
_recycableSerializableObjectContexts.Count == 0 ?
null :
(SerializableObjectContext)_recycableSerializableObjectContexts.Pop();
}
if (serializableObjectContext == null)
{
serializableObjectContext = new SerializableObjectContext(serializableObject,
serializablePropertyContext);
}
else
{
serializableObjectContext.Initialize(serializableObject,
serializablePropertyContext);
}
{
//
// Namespace related creation within the context
//
MetroSerializationNamespaceTable parentNamespaceTable =
serializableObjectParentContext != null ? serializableObjectParentContext.NamespaceTable : null;
if (serializableObjectContext.NamespaceTable == null)
{
serializableObjectContext.NamespaceTable = new MetroSerializationNamespaceTable(parentNamespaceTable);
}
}
{
//
// Properties related creation within the context
//
if (serializableObjectContext.PropertiesCollection == null)
{
serializableObjectContext.PropertiesCollection = new SerializablePropertyCollection(serializationManager,
serializableObject);
}
else
{
serializableObjectContext.PropertiesCollection.Initialize(serializationManager,
serializableObject);
}
}
serializableObjectContext.Name = serializableObjectContext.TargetObject.GetType().Name;
return(serializableObjectContext);
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
if (SerializationManager is XpsSerializationManager)
{
(SerializationManager as XpsSerializationManager).RegisterDocumentStart();
}
String xmlnsForType = SerializationManager.GetXmlNSForType(typeof(FixedDocument));
String nameForType = XpsS0Markup.FixedDocument;
if (xmlnsForType == null)
{
XmlWriter.WriteStartElement(nameForType);
}
else
{
XmlWriter.WriteStartElement(nameForType,
xmlnsForType);
}
{
ReachSerializerContext context = new ReachSerializerContext(this,
SerializerAction.endPersistObjectData);
((IXpsSerializationManagerAsync)SerializationManager).OperationStack.Push(context);
XpsSerializationPrintTicketRequiredEventArgs e =
new XpsSerializationPrintTicketRequiredEventArgs(PrintTicketLevel.FixedDocumentPrintTicket,
0);
((IXpsSerializationManager)SerializationManager).OnXPSSerializationPrintTicketRequired(e);
//
// Serialize the data for the PrintTicket
//
if (e.Modified)
{
if (e.PrintTicket != null)
{
PrintTicketSerializerAsync serializer = new PrintTicketSerializerAsync(SerializationManager);
serializer.SerializeObject(e.PrintTicket);
}
}
DocumentPaginator paginator = (DocumentPaginator)serializableObjectContext.TargetObject;
XmlLanguage language = null;
DependencyObject dependencyObject = paginator.Source as DependencyObject;
if (dependencyObject != null)
{
language = (XmlLanguage)dependencyObject.GetValue(FrameworkContentElement.LanguageProperty);
}
if (language == null)
{
//If the language property is null, assign the language to the default
language = XmlLanguage.GetLanguage(XpsS0Markup.XmlLangValue);
}
SerializationManager.Language = language;
int index = 0;
DocumentPaginatorSerializerContext
collectionContext = new DocumentPaginatorSerializerContext(this,
serializableObjectContext,
paginator,
index,
SerializerAction.serializeNextDocumentPage);
((IXpsSerializationManagerAsync)SerializationManager).OperationStack.Push(collectionContext);
}
}
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);
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
if (serializableObjectContext == null)
{
throw new ArgumentNullException("serializableObjectContext");
}
FixedPage fixedPage = serializableObjectContext.TargetObject as FixedPage;
if (SerializationManager is IXpsSerializationManager)
{
(SerializationManager as IXpsSerializationManager).RegisterPageStart();
}
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)
{
ReachSerializerContext context = new ReachFixedPageSerializerContext(this,
serializableObjectContext,
SerializerAction.endSerializeReachFixedPage,
needEndVisual,
treeWalker);
((IXpsSerializationManagerAsync)SerializationManager).OperationStack.Push(context);
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));
}
}
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
if (serializableObjectContext == null)
{
throw new ArgumentNullException("serializableObjectContext");
}
String xmlnsForType = SerializationManager.GetXmlNSForType(typeof(FixedDocument));
if (SerializationManager is XpsSerializationManager)
{
(SerializationManager as XpsSerializationManager).RegisterDocumentStart();
}
if (xmlnsForType == null)
{
XmlWriter.WriteStartElement(serializableObjectContext.Name);
}
else
{
XmlWriter.WriteStartElement(serializableObjectContext.Name,
xmlnsForType);
}
{
if (serializableObjectContext.IsComplexValue)
{
XpsSerializationPrintTicketRequiredEventArgs e =
new XpsSerializationPrintTicketRequiredEventArgs(PrintTicketLevel.FixedDocumentPrintTicket,
0);
((IXpsSerializationManager)SerializationManager).OnXPSSerializationPrintTicketRequired(e);
//
// Serialize the data for the PrintTicket
//
if (e.Modified)
{
if (e.PrintTicket != null)
{
PrintTicketSerializer serializer = new PrintTicketSerializer(SerializationManager);
serializer.SerializeObject(e.PrintTicket);
}
}
SerializeObjectCore(serializableObjectContext);
}
else
{
throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_WrongPropertyTypeForFixedDocument));
}
}
//
// Clear off the table from the packaging policy
//
((XpsSerializationManager)SerializationManager).ResourcePolicy.ImageCrcTable = null;
((XpsSerializationManager)SerializationManager).ResourcePolicy.ImageUriHashTable = null;
XmlWriter.WriteEndElement();
XmlWriter = null;
//
// Signal to any registered callers that the Document has been serialized
//
XpsSerializationProgressChangedEventArgs progressEvent =
new XpsSerializationProgressChangedEventArgs(XpsWritingProgressChangeLevel.FixedDocumentWritingProgress,
0,
0,
null);
((IXpsSerializationManager)SerializationManager).OnXPSSerializationProgressChanged(progressEvent);
if (SerializationManager is XpsSerializationManager)
{
(SerializationManager as XpsSerializationManager).RegisterDocumentEnd();
}
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
if (SerializationManager is IXpsSerializationManager)
{
(SerializationManager as IXpsSerializationManager).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);
((IXpsSerializationManager)SerializationManager).OnXPSSerializationPrintTicketRequired(e);
PrintTicket printTicket = null;
if (e.Modified)
{
printTicket = e.PrintTicket;
}
Size size = Toolbox.ValidateDocumentSize(dp.Size, printTicket);
((IXpsSerializationManager)SerializationManager).FixedPageSize = size;
//
//write length and width elements
//
WriteAttribute(XmlWriter, XpsS0Markup.PageWidth, size.Width);
WriteAttribute(XmlWriter, XpsS0Markup.PageHeight, size.Height);
//
// Serialize the data for the PrintTicket
//
if (printTicket != null)
{
PrintTicketSerializer serializer = new PrintTicketSerializer(SerializationManager);
serializer.SerializeObject(printTicket);
}
SerializeChild(dp.Visual, serializableObjectContext);
((XpsSerializationManager)SerializationManager).PackagingPolicy.PreCommitCurrentPage();
//copy hyperlinks into stream
treeWalker.CommitHyperlinks();
XmlWriter.WriteEndElement();
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;
((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);
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
);
