AsyncOperation(
ReachSerializerContext context
)
{
if (context == null)
{
}
switch (context.Action)
{
case SerializerAction.serializeNextTreeNode:
{
ReachVisualSerializerContext thisContext = context as ReachVisualSerializerContext;
if (thisContext != null)
{
SerializeNextTreeNode(thisContext);
}
break;
}
default:
{
base.AsyncOperation(context);
break;
}
}
}
SerializeProperties(
SerializableObjectContext serializableObjectContext
)
{
if (serializableObjectContext == null)
{
throw new ArgumentNullException("serializableObjectContext");
}
SerializablePropertyCollection propertyCollection = serializableObjectContext.PropertiesCollection;
if (propertyCollection != null)
{
//for(propertyCollection.Reset();
// propertyCollection.MoveNext();)
//{
// SerializablePropertyContext serializablePropertyContext =
// (SerializablePropertyContext)propertyCollection.Current;
//
// if(serializablePropertyContext!=null)
// {
// SerializeProperty(serializablePropertyContext);
// }
//}
propertyCollection.Reset();
ReachSerializerContext context = new ReachSerializerContext(this,
serializableObjectContext,
SerializerAction.serializeNextProperty);
_serializationManager.OperationStack.Push(context);
}
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
if (serializableObjectContext == null)
{
throw new ArgumentNullException("serializableObjectContext");
}
if (SerializationManager is XpsSerializationManager)
{
(SerializationManager as XpsSerializationManager).RegisterDocumentStart();
}
String xmlnsForType = SerializationManager.GetXmlNSForType(typeof(FixedDocument));
if (xmlnsForType == null)
{
XmlWriter.WriteStartElement(serializableObjectContext.Name);
}
else
{
XmlWriter.WriteStartElement(serializableObjectContext.Name,
xmlnsForType);
}
{
if (serializableObjectContext.IsComplexValue)
{
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);
}
}
SerializeObjectCore(serializableObjectContext);
}
else
{
throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_WrongPropertyTypeForFixedDocument));
}
}
}
AsyncOperation(
ReachSerializerContext context
)
{
switch (context.Action)
{
case SerializerAction.endPersistObjectData:
{
EndPersistObjectData();
break;
}
case SerializerAction.endSerializeDocumentPage:
{
ReachFixedPageSerializerContext thisContext = context as ReachFixedPageSerializerContext;
_syncSerializer.EndSerializeDocumentPage(thisContext.TreeWalker);
break;
}
default:
{
base.AsyncOperation(context);
break;
}
}
}
AsyncOperation(
ReachSerializerContext context
)
{
switch (context.Action)
{
case SerializerAction.endPersistObjectData:
{
EndPersistObjectData();
break;
}
case SerializerAction.serializeNextDocumentReference:
{
DocumentReferenceCollectionSerializerContext thisContext =
context as DocumentReferenceCollectionSerializerContext;
if (thisContext != null)
{
SerializeNextDocumentReference(thisContext.Enumerator,
thisContext.ObjectContext);
}
break;
}
default:
{
base.AsyncOperation(context);
break;
}
}
}
AsyncOperation(
ReachSerializerContext context
)
{
if (context != null)
{
switch (context.Action)
{
case SerializerAction.endPersistObjectData:
{
EndPersistObjectData();
break;
}
case SerializerAction.endSerializeReachFixedPage:
{
ReachFixedPageSerializerContext thisContext = context as ReachFixedPageSerializerContext;
if (thisContext == null)
{
}
EndSerializeReachFixedPage(thisContext);
break;
}
default:
{
base.AsyncOperation(context);
break;
}
}
}
}
SerializeNextDocumentPage(
ReachSerializerContext context
)
{
DocumentPaginatorSerializerContext paginatorContext = context as DocumentPaginatorSerializerContext;
if (paginatorContext != null)
{
DocumentPaginator paginator = paginatorContext.Paginator;
int index = paginatorContext.Index;
if (!paginator.IsPageCountValid ||
(index < paginator.PageCount))
{
index++;
DocumentPaginatorSerializerContext
collectionContext = new DocumentPaginatorSerializerContext(this,
paginatorContext.ObjectContext,
paginator,
index,
SerializerAction.serializeNextDocumentPage);
_xpsOMSerializationManagerAsync.OperationStack.Push(collectionContext);
DocumentPage page = Toolbox.GetPage(paginator, index - 1);
ReachSerializer serializer = SerializationManager.GetSerializer(page);
if (serializer != null)
{
serializer.SerializeObject(page);
}
}
}
}
AsyncOperation(
ReachSerializerContext context
)
{
if (context == null)
{
}
switch (context.Action)
{
case SerializerAction.endPersistObjectData:
{
EndPersistObjectData();
break;
}
case SerializerAction.serializeNextDocumentPage:
{
SerializeNextDocumentPage(context);
break;
}
default:
{
base.AsyncOperation(context);
break;
}
}
}
InvokeSaveAsXamlWorkItem(
Object arg
)
{
try
{
if (!_serializationOperationCanceled)
{
if (_operationStack.Count > 0)
{
Object objectOnStack = _operationStack.Pop();
if (objectOnStack.GetType() ==
typeof(System.Windows.Xps.Serialization.SerializationManagerOperationContextStack))
{
SerializationManagerOperationContextStack context =
(SerializationManagerOperationContextStack)objectOnStack;
context.ReachSerializer.SerializeObject(context.SerializedObject);
}
else if (typeof(System.Windows.Xps.Serialization.ReachSerializerContext).IsAssignableFrom(objectOnStack.GetType()))
{
ReachSerializerContext context = (ReachSerializerContext)objectOnStack;
context.Serializer.AsyncOperation(context);
}
PostSerializationTask(new DispatcherOperationCallback(InvokeSaveAsXamlWorkItem));
}
else
{
Simulator.EndConfirmToXPSStructure(IsBatchMode);
XPSSerializationCompletionMethod();
}
}
}
catch (Exception e) when(!CriticalExceptions.IsCriticalException(e))
{
//
// Indicate that an error happened
//
bool canceled = false;
XpsSerializationCompletedEventArgs args = new XpsSerializationCompletedEventArgs(canceled,
null,
e);
_serializationOperationCanceled = true;
PostSerializationTask(new DispatcherOperationCallback(OnXPSSerializationCompleted), args);
}
return(null);
}
AsyncOperation(
ReachSerializerContext context
)
{
if (context.Action == SerializerAction.endPersistObjectData)
{
EndPersistObjectData();
}
else
{
base.AsyncOperation(context);
}
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
_syncSerializer.BeginPersistObjectData(serializableObjectContext);
ReachSerializerContext context = new ReachSerializerContext(this,
SerializerAction.endPersistObjectData);
_xpsOMSerializationManagerAsync.OperationStack.Push(context);
if (serializableObjectContext.IsComplexValue)
{
SerializeObjectCore(serializableObjectContext);
}
}
PersistObjectData(
SerializableObjectContext serializableObjectContext
)
{
if (serializableObjectContext.IsComplexValue)
{
ReachSerializerContext context = new ReachSerializerContext(this,
serializableObjectContext,
SerializerAction.serializePage);
((IXpsSerializationManagerAsync)SerializationManager).OperationStack.Push(context);
}
else
{
throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_WrongPropertyTypeForPageContent));
}
}
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?
}
}
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;
((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
)
{
_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));
}
}
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);
}
}
}
AsyncOperation(
ReachSerializerContext context
)
{
if (context == null)
{
}
switch (context.Action)
{
case SerializerAction.endSerializeObject:
{
EndSerializeObject(context.ObjectContext);
break;
}
case SerializerAction.serializeNextProperty:
{
SerializeNextProperty(context.ObjectContext);
break;
}
}
}
AsyncOperation(
ReachSerializerContext context
)
{
if (context == null)
{
}
switch (context.Action)
{
case SerializerAction.serializePage:
{
SerializePage(context.ObjectContext);
break;
}
default:
{
base.AsyncOperation(context);
break;
}
}
}
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);
}
AsyncOperation(
ReachSerializerContext context
)
{
if (context == null)
{
}
switch (context.Action)
{
case SerializerAction.endPersistObjectData:
{
EndPersistObjectData();
break;
}
case SerializerAction.serializeNextPageContent:
{
PageContentCollectionSerializerContext thisContext =
context as PageContentCollectionSerializerContext;
if (thisContext != null)
{
SerializeNextPageContent(thisContext.Enumerator,
thisContext.ObjectContext);
}
break;
}
default:
{
base.AsyncOperation(context);
break;
}
}
}
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);
}
}
InvokeSaveAsXamlBatchWorkItem(
Object arg
)
{
try
{
// This logic must be mirrored in IsAsyncWorkPending see remarks.
if (!_serializationOperationCanceled)
{
if (!_isBatchWorkItemInProgress && _batchOperationQueue.Count > 0)
{
BatchOperationWorkItem batchOperationWorkItem = (BatchOperationWorkItem)_batchOperationQueue.Dequeue();
if (batchOperationWorkItem.OperationType == BatchOperationType.batchWrite)
{
_currentPageXmlWriter = Simulator.SimulateBeginFixedPage();
ReachSerializer reachSerializer = GetSerializer(batchOperationWorkItem.SerializedObject);
if (reachSerializer != null)
{
//
// Prepare the context that is going to be pushed on the stack
//
SerializationManagerOperationContextStack
contextStack = new SerializationManagerOperationContextStack(reachSerializer,
batchOperationWorkItem.SerializedObject);
//
// At this stage, start calling another method which would peak at the stack
//
_operationStack.Push(contextStack);
PostSerializationTask(new DispatcherOperationCallback(InvokeSaveAsXamlBatchWorkItem));
}
else
{
throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NoSerializer));
}
_isBatchWorkItemInProgress = true;
}
else if (batchOperationWorkItem.OperationType == BatchOperationType.batchCommit)
{
Simulator.EndConfirmToXPSStructure(IsBatchMode);
XPSSerializationCompletionMethod();
}
}
else
{
if (_operationStack.Count > 0)
{
Object objectOnStack = _operationStack.Pop();
if (objectOnStack.GetType() ==
typeof(System.Windows.Xps.Serialization.SerializationManagerOperationContextStack))
{
SerializationManagerOperationContextStack context =
(SerializationManagerOperationContextStack)objectOnStack;
context.ReachSerializer.SerializeObject(context.SerializedObject);
}
else if (typeof(System.Windows.Xps.Serialization.ReachSerializerContext).IsAssignableFrom(objectOnStack.GetType()))
{
ReachSerializerContext context = (ReachSerializerContext)objectOnStack;
context.Serializer.AsyncOperation(context);
}
PostSerializationTask(new DispatcherOperationCallback(InvokeSaveAsXamlBatchWorkItem));
}
else
{
Simulator.SimulateEndFixedPage(_currentPageXmlWriter);
_isBatchWorkItemInProgress = false;
_currentPageXmlWriter = null;
}
}
}
}
catch (Exception e) when(!CriticalExceptions.IsCriticalException(e))
{
XpsSerializationCompletedEventArgs args = new XpsSerializationCompletedEventArgs(false, // Indicate that an error happened
null,
e);
_serializationOperationCanceled = true;
PostSerializationTask(new DispatcherOperationCallback(OnXPSSerializationCompleted), args);
}
return(null);
}
InvokeSaveAsXamlWorkItem(
Object arg
)
{
//
// PreSharp uses message numbers that the C# compiler doesn't know about.
// Disable the C# complaints, per the PreSharp documentation.
#pragma warning disable 1634, 1691
//
// PreSharp complains about catching NullReference (and other) exceptions.
// This is an async model and we need to catch all exception ourselves and then
// send them to the completion delegate
#pragma warning disable 56500
try
{
if (!_serializationOperationCanceled)
{
if (_operationStack.Count > 0)
{
Object objectOnStack = _operationStack.Pop();
if (objectOnStack.GetType() ==
typeof(System.Windows.Xps.Serialization.SerializationManagerOperationContextStack))
{
SerializationManagerOperationContextStack context =
(SerializationManagerOperationContextStack)objectOnStack;
context.ReachSerializer.SerializeObject(context.SerializedObject);
}
else if (typeof(System.Windows.Xps.Serialization.ReachSerializerContext).IsAssignableFrom(objectOnStack.GetType()))
{
ReachSerializerContext context = (ReachSerializerContext)objectOnStack;
context.Serializer.AsyncOperation(context);
}
PostSerializationTask(new DispatcherOperationCallback(InvokeSaveAsXamlWorkItem));
}
else
{
Simulator.EndConfirmToXPSStructure(IsBatchMode);
XPSSerializationCompletionMethod();
}
}
}
catch (Exception e)
{
if (CriticalExceptions.IsCriticalException(e))
{
throw;
}
//
// Indicate that an error happened
//
bool canceled = false;
XpsSerializationCompletedEventArgs args = new XpsSerializationCompletedEventArgs(canceled,
null,
e);
_serializationOperationCanceled = true;
PostSerializationTask(new DispatcherOperationCallback(OnXPSSerializationCompleted), args);
return(null);
}
#pragma warning restore 56500
#pragma warning restore 1634, 1691
return(null);
}
InvokeSaveAsXamlBatchWorkItem(
Object arg
)
{
//
// PreSharp uses message numbers that the C# compiler doesn't know about.
// Disable the C# complaints, per the PreSharp documentation.
#pragma warning disable 1634, 1691
//
// PreSharp complains about catching NullReference (and other) exceptions.
// This is an async model and we need to catch all exception ourselves and then
// send them to the completion delegate
#pragma warning disable 56500
try
{
// This logic must be mirrored in IsAsyncWorkPending see remarks.
if (!_serializationOperationCanceled)
{
if (!_isBatchWorkItemInProgress && _batchOperationQueue.Count > 0)
{
BatchOperationWorkItem batchOperationWorkItem = (BatchOperationWorkItem)_batchOperationQueue.Dequeue();
if (batchOperationWorkItem.OperationType == BatchOperationType.batchWrite)
{
_currentPageXmlWriter = Simulator.SimulateBeginFixedPage();
ReachSerializer reachSerializer = GetSerializer(batchOperationWorkItem.SerializedObject);
if (reachSerializer != null)
{
//
// Prepare the context that is going to be pushed on the stack
//
SerializationManagerOperationContextStack
contextStack = new SerializationManagerOperationContextStack(reachSerializer,
batchOperationWorkItem.SerializedObject);
//
// At this stage, start calling another method which would peak at the stack
//
_operationStack.Push(contextStack);
PostSerializationTask(new DispatcherOperationCallback(InvokeSaveAsXamlBatchWorkItem));
}
else
{
throw new XpsSerializationException(SR.Get(SRID.ReachSerialization_NoSerializer));
}
_isBatchWorkItemInProgress = true;
}
else if (batchOperationWorkItem.OperationType == BatchOperationType.batchCommit)
{
Simulator.EndConfirmToXPSStructure(IsBatchMode);
XPSSerializationCompletionMethod();
}
}
else
{
if (_operationStack.Count > 0)
{
Object objectOnStack = _operationStack.Pop();
if (objectOnStack.GetType() ==
typeof(System.Windows.Xps.Serialization.SerializationManagerOperationContextStack))
{
SerializationManagerOperationContextStack context =
(SerializationManagerOperationContextStack)objectOnStack;
context.ReachSerializer.SerializeObject(context.SerializedObject);
}
else if (typeof(System.Windows.Xps.Serialization.ReachSerializerContext).IsAssignableFrom(objectOnStack.GetType()))
{
ReachSerializerContext context = (ReachSerializerContext)objectOnStack;
context.Serializer.AsyncOperation(context);
}
PostSerializationTask(new DispatcherOperationCallback(InvokeSaveAsXamlBatchWorkItem));
}
else
{
Simulator.SimulateEndFixedPage(_currentPageXmlWriter);
_isBatchWorkItemInProgress = false;
_currentPageXmlWriter = null;
}
}
}
}
catch (Exception e)
{
if (CriticalExceptions.IsCriticalException(e))
{
throw;
}
//
// Indicate that an error happened
//
bool canceled = false;
XpsSerializationCompletedEventArgs args = new XpsSerializationCompletedEventArgs(canceled,
null,
e);
_serializationOperationCanceled = true;
PostSerializationTask(new DispatcherOperationCallback(OnXPSSerializationCompleted), args);
return(null);
}
#pragma warning restore 56500
#pragma warning restore 1634, 1691
return(null);
}
