void SaveXps(string filename)
{
System.IO.Packaging.Package package = System.IO.Packaging.Package.Open(filename, System.IO.FileMode.Create);
XpsDocument xpsDoc = new XpsDocument(package);
XpsDocumentWriter xpsWriter = XpsDocument.CreateXpsDocumentWriter(xpsDoc);
// zero the VisualOffset
Size s = this.diagram.RenderSize;
Transform t = this.diagram.LayoutTransform;
Point p = t.Transform(new Point(s.Width, s.Height));
diagram.Arrange(new Rect(0, 0, p.X, p.Y));
this.graphScroller.Content = null;
FixedPage fp = new FixedPage();
fp.Width = p.X;
fp.Height = p.Y;
// Must add the inherited styles before we add the diagram child!
fp.Resources.MergedDictionaries.Add(this.Resources);
fp.Children.Add(this.diagram);
xpsWriter.Write(fp);
// put the diagram back into the scroller.
fp.Children.Remove(this.diagram);
this.graphScroller.Content = diagram;
package.Close();
}
public static void ExportVisualAsPdf(Visual visual)
{
SaveFileDialog saveFileDialog = new SaveFileDialog
{
DefaultExt = ".pdf",
Filter = "PDF Documents (.pdf)|*.pdf"
};
bool?result = saveFileDialog.ShowDialog();
if (result != true)
{
return;
}
using (MemoryStream memoryStream = new MemoryStream())
{
System.IO.Packaging.Package package = System.IO.Packaging.Package.Open(memoryStream, FileMode.Create);
XpsDocument xpsDocument = new XpsDocument(package);
XpsDocumentWriter xpsDocumentWriter = XpsDocument.CreateXpsDocumentWriter(xpsDocument);
xpsDocumentWriter.Write(visual);
xpsDocument.Close();
package.Close();
var pdfXpsDoc = PdfSharp.Xps.XpsModel.XpsDocument.Open(memoryStream);
XpsConverter.Convert(pdfXpsDoc, saveFileDialog.FileName, 0);
}
}
private void OnCreateXPS(object sender, RoutedEventArgs e)
{
var c = new GregorianCalendar();
int weekNumber = c.GetWeekOfYear(menus[0].Day, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
string fileName = String.Format("menuplan{0}", weekNumber);
var dlg = new SaveFileDialog
{
FileName = fileName,
DefaultExt = "xps",
Filter = "XPS Documents|*.xps|All Files|*.*",
AddExtension = true
};
if (dlg.ShowDialog() == true)
{
var doc = new XpsDocument(dlg.FileName, FileAccess.Write, CompressionOption.Fast);
XpsDocumentWriter writer = XpsDocument.CreateXpsDocumentWriter(doc);
writer.WritingCompleted += delegate
{
doc.Close();
};
writer.WriteAsync(fixedDocument);
//writer.Write(fixedDocument);
//doc.Close();
}
}
internal static void PrintFlowDocument(PrintQueue pq, FlowDocument flowDocument)
{
if (pq == null)
{
throw new InvalidOperationException("Invalid Printer");
}
// Create a XpsDocumentWriter object, open a Windows common print dialog.
// This methods returns a ref parameter that represents information about the dimensions of the printer media.
XpsDocumentWriter docWriter = PrintQueue.CreateXpsDocumentWriter(pq);
PageImageableArea ia = pq.GetPrintCapabilities().PageImageableArea;
PrintTicket pt = pq.UserPrintTicket;
if (ia != null)
{
DocumentPaginator paginator = ((IDocumentPaginatorSource)flowDocument).DocumentPaginator;
// Change the PageSize and PagePadding for the document to match the CanvasSize for the printer device.
paginator.PageSize = new Size((double)pt.PageMediaSize.Width, (double)pt.PageMediaSize.Height);
Thickness pagePadding = flowDocument.PagePadding;
flowDocument.PagePadding = new Thickness(
Math.Max(ia.OriginWidth, pagePadding.Left),
Math.Max(ia.OriginHeight, pagePadding.Top),
Math.Max((double)pt.PageMediaSize.Width - (ia.OriginWidth + ia.ExtentWidth), pagePadding.Right),
Math.Max((double)pt.PageMediaSize.Height - (ia.OriginHeight + ia.ExtentHeight), pagePadding.Bottom));
flowDocument.ColumnWidth = double.PositiveInfinity;
flowDocument.FontFamily = new System.Windows.Media.FontFamily(LocalSettings.PrintFontFamily);
// Send DocumentPaginator to the printer.
docWriter.Write(paginator);
}
}
}// end:PrintSingleFixedContentDocument()
// ---------------- PrintMultipleFixedContentDocuments ----------------
/// <summary>
/// Prints the content of a multiple fixed document sequence.</summary>
/// <param name="pq">
/// The print queue to print to.</param>
/// <param name="async">
/// true to print asynchronously; false to print synchronously.</param>
public void PrintMultipleFixedContentDocuments(PrintQueue pq, bool async)
{
// Create a multiple document FixedDocumentSequence.
FixedDocumentSequence fds =
_wpfContent.LoadFixedDocumentSequenceFromDocument();
// Create a document writer to print to.
XpsDocumentWriter xdwPrint = GetPrintXpsDocumentWriter(pq);
// Set the event handler for creating print tickets for
// each document within the fixed document sequence.
xdwPrint.WritingPrintTicketRequired +=
new WritingPrintTicketRequiredEventHandler(
MultipleFixedContentDocuments_WritingPrintTicketRequired);
_firstDocumentPrintTicket = 0;
// Print either asynchronously or synchronously.
if (async)
{
PrintMultipleFixedContentDocumentsAsync(xdwPrint, fds);
}
else
{
PrintMultipleFixedContentDocuments(xdwPrint, fds);
}
}// end:PrintMultipleFixedContentDocuments()
/// <summary>
/// Prints this instance.
/// </summary>
public bool Print()
{
try
{
PrintDialog printDlg = new System.Windows.Controls.PrintDialog();
bool? results = printDlg.ShowDialog();
if (results == null || results == false)
{
return(false);
}
//get selected printer capabilities
System.Printing.PrintCapabilities capabilities = printDlg.PrintQueue.GetPrintCapabilities(printDlg.PrintTicket);
//get the size of the printer page
System.Windows.Size printSize = new System.Windows.Size(
capabilities.PageImageableArea.ExtentHeight, capabilities.PageImageableArea.ExtentWidth);
// Build print view
this.Height = printSize.Height;
this.Width = printSize.Width;
Measure(printSize);
Arrange(new System.Windows.Rect(printSize));
XpsDocumentWriter xpsdw = PrintQueue.CreateXpsDocumentWriter(printDlg.PrintQueue);
printDlg.PrintTicket.PageOrientation = PageOrientation.Landscape;
xpsdw.WriteAsync(this);
}
catch (Exception ex)
{
MessageBox.Show(ex.GetBaseException().Message, "Printing Error", MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
return(true);
}
private void saveAsXPS(string file)
{
// Deselect shapes while saving.
List <XElement> selectedItems = new List <XElement>(_viewModel.vm_CanvasViewModel.prop_SelectedShapes);
_viewModel.vm_CanvasViewModel.prop_SelectedShapes.Clear();
// Get a rectangle representing the page.
Rectangle page = _viewModel._commandUtility.GetDocumentRectangle();
try
{
using (Package package = Package.Open(file, FileMode.Create))
{
using (XpsDocument xpsDocument = new XpsDocument(package))
{
// Write the document.
XpsDocumentWriter xpsWriter = XpsDocument.CreateXpsDocumentWriter(xpsDocument);
xpsWriter.Write(page);
}
}
}
finally
{
// Reselect shapes.
_viewModel.vm_CanvasViewModel.SelectShapes(selectedItems);
}
}
/// <summary>
/// Command handler for ExportXPSCommand in the menu.
/// </summary>
private void ExportXps(object sender, EventArgs e)
{
CommonDialog dialog = new CommonDialog();
dialog.InitialDirectory = People.ApplicationFolderPath;
dialog.Filter.Add(new FilterEntry(Properties.Resources.XpsFiles, Properties.Resources.XpsExtension));
dialog.Filter.Add(new FilterEntry(Properties.Resources.AllFiles, Properties.Resources.AllExtension));
dialog.Title = Properties.Resources.Export;
dialog.DefaultExtension = Properties.Resources.DefaultXpsExtension;
dialog.ShowSave();
if (!string.IsNullOrEmpty(dialog.FileName))
{
// Create the XPS document from the window's main container (in this case, a grid)
Package package = Package.Open(dialog.FileName, FileMode.Create);
XpsDocument xpsDoc = new XpsDocument(package);
XpsDocumentWriter xpsWriter = XpsDocument.CreateXpsDocumentWriter(xpsDoc);
// Hide the zoom control before the diagram is saved
DiagramControl.ZoomSliderPanel.Visibility = Visibility.Hidden;
// Since DiagramBorder derives from FrameworkElement, the XpsDocument writer knows
// how to output it's contents. The border is used instead of the DiagramControl
// so that the diagram background is output as well as the digram control itself.
xpsWriter.Write(DiagramBorder);
xpsDoc.Close();
package.Close();
// Show the zoom control again
DiagramControl.ZoomSliderPanel.Visibility = Visibility.Visible;
}
}
private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
PrintDialog printDialog = new PrintDialog();
using (var stream = new MemoryStream())
{
using (var package = Package.Open(stream, FileMode.Create, FileAccess.ReadWrite))
{
using (var xpsDoc = new XpsDocument(package, CompressionOption.Maximum))
{
var rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
var paginator = ((IDocumentPaginatorSource)doc).DocumentPaginator;
rsm.SaveAsXaml(paginator);
rsm.Commit();
PrintQueue queue = printDialog.PrintQueue;
XpsDocumentWriter writer = PrintQueue.CreateXpsDocumentWriter(queue);
// using (FileStream fs = File.Open(filePath, FileMode.Open))
{
// FlowDocument flowDocument = (FlowDocument)XamlReader.Load(fs);
writer.Write(paginator);
}
}
}
stream.Position = 0;
var pdfXpsDoc = PdfSharp.Xps.XpsModel.XpsDocument.Open(stream);
PdfSharp.Xps.XpsConverter.Convert(pdfXpsDoc, "doc.pdf", 0);
}
}
public static byte[] XpsDocumentToBytes(FixedDocumentSequence fds)
{
string uriString = "pack://" + Guid.NewGuid().ToString() + ".xps";
Uri uri = new Uri(uriString);
MemoryStream stream = new MemoryStream();
Package package = Package.Open(stream, FileMode.Create);
PackageStore.AddPackage(uri, package);
XpsDocument xpsDocument = new XpsDocument(package, CompressionOption.Maximum, uriString);
XpsDocumentWriter writer = XpsDocument.CreateXpsDocumentWriter(xpsDocument);
writer.Write(fds);
xpsDocument.Close();
package.Close();
stream.Close();
PackageStore.RemovePackage(uri);
MemoryStream mainstream = new MemoryStream();
BinaryWriter br = new BinaryWriter(mainstream);
byte[] data = stream.ToArray();
br.Write(uriString);
br.Write(data.Length);
br.Write(data);
br.Flush();
mainstream.Close();
return(mainstream.ToArray());
}
CreateWriter(
String description
)
{
PrintQueue printQueue = null;
PrintTicket printTicket = null;
XpsDocumentWriter writer = null;
PickCorrectPrintingEnvironment(ref printQueue, ref printTicket);
MS.Internal.SystemDrawingHelper.NewDefaultPrintingPermission().Assert(); //BlessedAssert
try
{
if (printQueue != null)
{
printQueue.CurrentJobSettings.Description = description;
}
writer = PrintQueue.CreateXpsDocumentWriter(printQueue);
PrintDlgPrintTicketEventHandler eventHandler = new PrintDlgPrintTicketEventHandler(printTicket);
writer.WritingPrintTicketRequired +=
new WritingPrintTicketRequiredEventHandler(eventHandler.SetPrintTicket);
}
finally
{
CodeAccessPermission.RevertAssert();
}
return(writer);
}
public void LoadXps()
{
//构造一个基于内存的xps document
//MemoryStream ms = new MemoryStream();
Package package = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
Uri DocumentUri = new Uri("pack://InMemoryDocument.xps");
PackageStore.RemovePackage(DocumentUri);
PackageStore.AddPackage(DocumentUri, package);
XpsDocument xpsDocument = new XpsDocument(package, CompressionOption.Fast, DocumentUri.AbsoluteUri);
//将flow document写入基于内存的xps document中去
XpsDocumentWriter writer = XpsDocument.CreateXpsDocumentWriter(xpsDocument);
if (this.isFixedPage)
{
writer.Write((FixedPage)m_doc);
}
else
{
writer.Write(((IDocumentPaginatorSource)m_doc).DocumentPaginator);
}
//获取这个基于内存的xps document的fixed document
docViewer.Document = xpsDocument.GetFixedDocumentSequence();
//关闭基于内存的xps document
xpsDocument.Close();
}
protected override void OnPrintCommand()
{
if (Document == null || _writer != null)
{
return;
}
var dialog = new PrintDialog();
dialog.UserPageRangeEnabled = true;
if (dialog.ShowDialog() != true)
{
return;
}
if (Orientation != PageOrientation.Unknown)
{
dialog.PrintTicket.PageOrientation = Orientation;
}
_writer = PrintQueue.CreateXpsDocumentWriter(dialog.PrintQueue);
_writer.WritingPrintTicketRequired += (sender, args) => {
args.CurrentPrintTicket = dialog.PrintTicket;
};
_writer.WritingCompleted += Completed;
_writer.WritingCancelled += Cancelled;
CommandManager.InvalidateRequerySuggested();
if (PrintResult != null)
{
_writer.WriteAsync(PrintResult.GetPaginator(dialog));
}
else if (Document is FixedDocumentSequence)
{
_writer.WriteAsync(Document as FixedDocumentSequence);
}
else if (Document is FixedDocument)
{
var fixedDocument = Document as FixedDocument;
if (dialog.PageRangeSelection == PageRangeSelection.AllPages)
{
_writer.WriteAsync(fixedDocument);
}
else
{
var pages = new List <FixedPage>();
var begin = Math.Max(0, dialog.PageRange.PageFrom - 1);
var end = Math.Min(fixedDocument.Pages.Count, dialog.PageRange.PageTo);
for (var i = begin; i < end; i++)
{
pages.Add(fixedDocument.Pages[i].Child);
}
_writer.WriteAsync(new FixedDocumentPaginator(fixedDocument, pages.ToArray()));
}
}
else
{
_writer.WriteAsync(Document.DocumentPaginator);
}
}
public void Print_Document()
{
//----------------< Print_Document() >-----------------------
//----< Get_Print_Dialog_and_Printer >----
PrintDialog printDialog = new PrintDialog();
printDialog.PrintQueue = LocalPrintServer.GetDefaultPrintQueue();
printDialog.PrintTicket = printDialog.PrintQueue.DefaultPrintTicket;
//----</ Get_Print_Dialog_and_Printer >----
//*set the default page orientation based on the desired output.
printDialog.PrintTicket.PageOrientation = PageOrientation.Landscape;
printDialog.PrintTicket.PageScalingFactor = 90;
printDialog.PrintTicket.PageMediaSize = new PageMediaSize(PageMediaSizeName.ISOA4);
//printDialog.PrintableAreaHeight ; //*get
//printDialog.PrintableAreaWidth; //get
//printDialog.PrintDocument.
printDialog.PrintTicket.PageBorderless = PageBorderless.None;
if (printDialog.ShowDialog() == true)
{
//----< print >----
// set the print ticket for the document sequence and write it to the printer.
_document.PrintTicket = printDialog.PrintTicket;
//-< send_document_to_printer >-
XpsDocumentWriter writer = PrintQueue.CreateXpsDocumentWriter(printDialog.PrintQueue);
writer.WriteAsync(_document, printDialog.PrintTicket);
//-</ send_document_to_printer >-
//----</ print >----
}
//----------------</ Print_Document() >-----------------------
}
public static void PrintFixedDoc(FixedDocument doc, string fileName)
{
using (XpsDocument xps = new XpsDocument(fileName, System.IO.FileAccess.Write))
{
XpsDocumentWriter writer = XpsDocument.CreateXpsDocumentWriter(xps);
writer.Write(doc);
}
}
private void SaveXpsDocumentWithFixedDocumentSequenceTo(string outputDirectory, FixedDocumentSequence fixedDocumentSequence)
{
using (var xpsDocument = new XpsDocument(outputDirectory, FileAccess.ReadWrite))
{
XpsDocumentWriter xpsDocumentWriter = GetXpsDocumentWriterFor(xpsDocument);
xpsDocumentWriter.Write(fixedDocumentSequence);
}
}
CreateXpsDocumentWriter(
XpsDocument xpsDocument
)
{
XpsDocumentWriter writer = new XpsDocumentWriter(xpsDocument);
return(writer);
}
public static void WriteToXps(string path, FixedDocument fixedDoc)
{
XpsDocument xpsDoc = new XpsDocument(path, FileAccess.Write);
XpsDocumentWriter xWriter = XpsDocument.CreateXpsDocumentWriter(xpsDoc);
xWriter.Write(fixedDoc);
xpsDoc.Close();
}
/* Main print entry point */
private void Print(PrintParams_t pparams)
{
XpsDocumentWriter docwrite = GetDocWriter(pparams.queu);
docwrite.WritingPrintTicketRequired +=
new WritingPrintTicketRequiredEventHandler(PrintTicket);
PrintPages(docwrite, pparams.fixdoc);
}
public BradyPrinter()
{
var defaultPrintQueue = LocalPrintServer.GetDefaultPrintQueue();
DocumentWriter = PrintQueue.CreateXpsDocumentWriter(defaultPrintQueue);
PrintTicket = defaultPrintQueue.DefaultPrintTicket;
DrawingVisual = new DrawingVisual();
}
// TODO: Make this thread safe
private void Print()
{
try
{
_thisPrinter.Refresh();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.StackTrace);
}
// Get our current print Batch(if we don't already have it)
if (_thisPrintBatch.BatchFinishedPrinting())
{
_thisPrintBatch = DeQueuePrintBatch();
}
if (!_thisPrintBatch.BatchFinishedPrinting())
{
try
{
// See if our printer is in an error state
if (CheckPrinterForErrorState())
{
_inError = true;
}
else
{
FixedPage page = (_thisPrintBatch.Template.Clone() as PrintTemplate).Render();
_thisPrinter.UserPrintTicket.PageBorderless = PageBorderless.Borderless;
_thisPrinter.UserPrintTicket.PhotoPrintingIntent = PhotoPrintingIntent.PhotoBest;
_thisPrinter.UserPrintTicket.PageMediaSize = new PageMediaSize(4, 6);
_thisPrinter.Commit();
XpsDocumentWriter writer = PrintQueue.CreateXpsDocumentWriter(_thisPrinter);
writer.Write(page);
// Pretend we know that this print worked and tell our current print batch that it did.
_thisPrintBatch.RegisterSucessfullPrint();
_remainingPrintsInTray--;
// Print the next page (eventually this should run out of batches or a print error will happen...)
Print();
}
}
catch (Exception ex)
{
_printErrors = ex.Message;
_inError = true;
}
}
if (_inError)
{
InformClientOfPrintProblems(_printErrors);
}
}
//</SnippetWriteToXpsWithFixedDocumentSequence>
#endregion // Synchronous Save Methods
#region Asynchronous Save Methods
//<SnippetWriteAsyncToXpsWithVisual>
private void SaveVisualAsync(XpsDocumentWriter xpsdw, Visual v)
{
_xpsdwActive = xpsdw;
xpsdw.WritingCompleted +=
new WritingCompletedEventHandler(AsyncSaveCompleted);
xpsdw.WriteAsync(v); // Write visual to single page.
}
/* Main print entry point */
public void Print(PrintQueue queu, FixedDocumentSequence fixdoc)
{
XpsDocumentWriter docwrite = GetDocWriter(queu);
m_busy = true;
docwrite.WritingPrintTicketRequired +=
new WritingPrintTicketRequiredEventHandler(PrintTicket);
PrintPages(docwrite, fixdoc);
}
// ------------------------- PrintVisualAsync -------------------------
/// <summary>
/// Initiates asynchronous output of a given
/// visual to a specified document writer.</summary>
/// <param name="xpsdw">
/// The document writer to output to.</param>
/// <param name="v">
/// The visual to print.</param>
private void PrintVisualAsync(XpsDocumentWriter xpsdw, Visual v)
{
_xpsdwActive = xpsdw; // Save the active document writer.
xpsdw.WritingCompleted +=
new WritingCompletedEventHandler(AsyncPrintCompleted);
xpsdw.WriteAsync(v); // Write the visual to a single page.
}
//合并文档，将文档合并到xpsShow.xps里面
public void MergeDocument()
{
string newFile = Path + "xpsShow.xps";
List <string> lsFileName = new List <string>();
List <string> lstName = new List <string>();
lsFileName.AddRange(Directory.GetFiles(Path));
if (lsFileName.Count == 0)
{
IsHaveReport = false;
return;
}
lsFileName.Sort();
string[] idCardsStrings = CardID.Split(';');
foreach (string idCardNo in idCardsStrings)
{
foreach (var item in lsFileName)
{
if (!string.IsNullOrEmpty(item) && item.Contains(idCardNo))
{
lstName.Add(item);
}
}
}
FixedDocumentSequence newFds = new FixedDocumentSequence();//创建一个新的文档结构
foreach (var item in lstName)
{
if (count < 50)
{
setProcess(count);
count++;
}
if (item != "xpsShow.xps" && item.ToUpper().Contains(".XPS"))
{
DocumentReference newDocRef = AddPage(item);
newFds.References.Add(newDocRef);
}
}
File.Delete(newFile);
setProcess(46);
//xps写入新文件
XpsDocument NewXpsDocument = new XpsDocument(newFile, System.IO.FileAccess.ReadWrite);
XpsDocumentWriter xpsDocumentWriter = XpsDocument.CreateXpsDocumentWriter(NewXpsDocument);
setProcess(47);
xpsDocumentWriter.Write(newFds);
NewXpsDocument.Close();
}
/* Send it */
private void PrintPages(XpsDocumentWriter xpsdw, FixedDocumentSequence fixdoc)
{
m_docWriter = xpsdw;
xpsdw.WritingCompleted +=
new WritingCompletedEventHandler(AsyncCompleted);
xpsdw.WritingProgressChanged +=
new WritingProgressChangedEventHandler(AsyncProgress);
xpsdw.WriteAsync(fixdoc);
}
public static void PrintPreview(Window owner, object data, bool IsSinglePage = false)
{
using (MemoryStream xpsStream = new MemoryStream())
{
using (Package package = Package.Open(xpsStream, FileMode.Create, FileAccess.ReadWrite))
{
string packageUriString = "memorystream://data.xps";
Uri packageUri = new Uri(packageUriString);
if (PackageStore.GetPackage(packageUri) != null)
{
PackageStore.RemovePackage(packageUri);
}
PackageStore.AddPackage(packageUri, package);
XpsDocument xpsDocument = new XpsDocument(package, CompressionOption.NotCompressed, packageUriString);
XpsDocumentWriter writer = XpsDocument.CreateXpsDocumentWriter(xpsDocument);
// Form visual = new Form();
// PrintTicket printTicket = new PrintTicket();
// printTicket.PageMediaSize = A4PaperSize;
// var d = PrintOnMultiPage(data, true);
//((IDocumentPaginatorSource)data).DocumentPaginator
if (!IsSinglePage)
{
writer.Write(PrintOnMultiPage(data, true));
}
else
{
writer.Write(Print((Visual)data, true));
}
FixedDocumentSequence document = xpsDocument.GetFixedDocumentSequence();
xpsDocument.Close();
PrintPreviewWindow printPreviewWnd = new PrintPreviewWindow(document);
printPreviewWnd.Owner = owner;
printPreviewWnd.ShowDialog();
PackageStore.RemovePackage(packageUri);
}
}
}
//Prints a FixedDocument
public void PrintFixedDocument(PrintQueue printQueue)
{
FixedDocument fixedDocument = GetFixedDocument();
XpsDocumentWriter writer =
PrintQueue.CreateXpsDocumentWriter(printQueue);
writer.Write(fixedDocument);
}
WriteAsyncAsTaskCore(
XpsDocumentWriter @this,
CancellationToken cancellationToken
)
{
var tcs = new TaskCompletionSource <object>();
var subscription = new SingleAssignmentDisposable();
var onCompleted =
new WritingCompletedEventHandler((sender, e) =>
{
using (subscription)
{
if (e.Error != null)
{
tcs.SetException(e.Error);
}
else if (e.Cancelled)
{
tcs.SetCanceled();
}
else
{
tcs.SetResult(default(object));
}
}
});
var onCancelled =
new WritingCancelledEventHandler((sender, e) =>
{
using (subscription)
{
if (e.Error != null)
{
tcs.SetException(e.Error);
}
else
{
tcs.SetCanceled();
}
}
});
@this.WritingCompleted += onCompleted;
@this.WritingCancelled += onCancelled;
var registration = cancellationToken.Register(@this.CancelAsync);
subscription.Content =
new AnonymousDisposable(() =>
{
@this.WritingCompleted -= onCompleted;
@this.WritingCancelled -= onCancelled;
registration.Dispose();
});
return(tcs);
}
private static void PrintPages <T>(Paginator <T> paginator, Size viewerSize) where T : Page
{
string filename = Path.GetTempFileName();
try
{
File.Delete(filename);
// create multiple pages as 1 xps document
XpsDocument document;
using (document = new XpsDocument(filename, FileAccess.ReadWrite))
{
XpsDocumentWriter writer = XpsDocument.CreateXpsDocumentWriter(document);
writer.Write(paginator);
}
using (document = new XpsDocument(filename, FileAccess.Read))
{
DocumentViewer viewer = new DocumentViewer
{
Document = document.GetFixedDocumentSequence()
};
Window window = new Window();
if (!viewerSize.IsEmpty)
{
window.Width = viewerSize.Width;
window.Height = viewerSize.Height;
}
window.Content = viewer;
// actual size viewer window
//window.SizeToContent = SizeToContent.WidthAndHeight;
window.Title = Properties.Resources.appTitle;
window.ShowDialog();
window.Close();
}
}
finally
{
if (File.Exists(filename))
{
try
{
File.Delete(filename);
}
catch (Exception ex)
{
Log.WriteLine(ex.Message);
}
}
}
}
