private void ShowPrintPreview()
{
// We have to clone the FlowDocument before we use different pagination settings for the export.
RichTextDocument document = (RichTextDocument)fileService.ActiveDocument;
FlowDocument clone = document.CloneContent();
clone.ColumnWidth = double.PositiveInfinity;
// Create a package for the XPS document
MemoryStream packageStream = new MemoryStream();
package = Package.Open(packageStream, FileMode.Create, FileAccess.ReadWrite);
// Create a XPS document with the path "pack://temp.xps"
PackageStore.AddPackage(new Uri(PackagePath), package);
xpsDocument = new XpsDocument(package, CompressionOption.SuperFast, PackagePath);
// Serialize the XPS document
XpsSerializationManager serializer = new XpsSerializationManager(new XpsPackagingPolicy(xpsDocument), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)clone).DocumentPaginator;
serializer.SaveAsXaml(paginator);
// Get the fixed document sequence
FixedDocumentSequence documentSequence = xpsDocument.GetFixedDocumentSequence();
// Create and show the print preview view
PrintPreviewViewModel printPreviewViewModel = printPreviewViewModelFactory.CreateExport().Value;
printPreviewViewModel.Document = documentSequence;
previousView = shellViewModel.ContentView;
shellViewModel.ContentView = printPreviewViewModel.View;
shellViewModel.IsPrintPreviewVisible = true;
printPreviewCommand.RaiseCanExecuteChanged();
}
private void SaveToFile()
{
if (Directory.Exists(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) + "\\renderedData") == false)
{ Directory.CreateDirectory(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) + "\\renderedData"); }
string destination = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) + "\\renderedData\\" + DateTime.Now.Year + DateTime.Now.Month + DateTime.Now.Day + " " +
DateTime.Now.Hour + "-" + DateTime.Now.Minute + "-" + DateTime.Now.Second + " " + Environment.UserName + " 2dView";
using (var stream = new FileStream(destination+".xps", FileMode.Create))
{
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)FlowDocViewer.Document).DocumentPaginator;
rsm.SaveAsXaml(paginator);
rsm.Commit();
}
}
stream.Position = 0;
var pdfXpsDoc = PdfSharp.Xps.XpsModel.XpsDocument.Open(stream);
XpsConverter.Convert(pdfXpsDoc, destination + ".pdf", 0);
}
}
public static XpsDocument GetXpsDocument(FlowDocument document)
{
//Uri DocumentUri = new Uri("pack://currentTicket_" + new Random().Next(1000).ToString() + ".xps");
Uri docUri = new Uri("pack://tempTicket.xps");
var ms = new MemoryStream();
{
Package package = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
PackageStore.RemovePackage(docUri);
PackageStore.AddPackage(docUri, package);
XpsDocument xpsDocument = new XpsDocument(package, CompressionOption.SuperFast, docUri.AbsoluteUri);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDocument), false);
DocumentPaginator docPage = ((IDocumentPaginatorSource)document).DocumentPaginator;
//docPage.PageSize = new System.Windows.Size(PageWidth, PageHeight);
//docPage.PageSize = new System.Windows.Size(document.PageWidth, document.PageHeight);
rsm.SaveAsXaml(docPage);
return(xpsDocument);
}
}
static void Main(string[] args)
{
// Write WPF Content - A FixedDocumentSequence with 'n'
// FixedDocuments; each FixedDocument containing 2 FixedPages.
Console.WriteLine("\nStarting creation of XPS flat-file document.");
int numberOfDocument = 5; // number of documents in the sequence.
FixedDocumentSequence fixedDocSeq =
WpfContent.CreateFixedDocumentSequence(numberOfDocument);
// Set the output directory
String path = Directory.GetCurrentDirectory() + @"\Output";
FlatPackagingPolicy packagingPolicy = new FlatPackagingPolicy(path);
XpsSerializationManager xpsManager =
new XpsSerializationManager(packagingPolicy, false);
xpsManager.SaveAsXaml(fixedDocSeq);
Console.WriteLine("\nCompleted output of XPS flat-file document to folder:");
Console.WriteLine(path);
// Normal Completion, show where the XPS document flat file was written.
string msg = "Completed output of XPS flat-file document to folder:\n\n" + path;
MessageBox.Show(msg, "Normal Completion",
MessageBoxButtons.OK, MessageBoxIcon.Information);
} // end:Main
/// <summary>
/// Helper method to create page header or footer from flow document template
/// </summary>
/// <param name="data">enumerable report data</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">data</exception>
public XpsDocument CreateXpsDocument(IEnumerable <ReportData> data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
int count = 0; ReportData firstData = null;
foreach (ReportData rd in data)
{
if (firstData == null)
{
firstData = rd;
}
count++;
}
if (count == 1)
{
return(CreateXpsDocument(firstData)); // we have only one ReportData object -> use the normal ReportPaginator instead
}
MemoryStream ms = new MemoryStream();
Package pkg = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://report.xps";
PackageStore.RemovePackage(new Uri(pack));
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument doc = new XpsDocument(pkg, CompressionOption.NotCompressed, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)CreateFlowDocument()).DocumentPaginator;
MultipleReportPaginator rp = new MultipleReportPaginator(this, data);
rsm.SaveAsXaml(rp);
return(doc);
}
public void CreateContentFromFlowDocument(ManagedFlowDocument managedFlowDocument)
{
XpsSerializationManager xpsSerializationManager = GetXpsSerializationManager();
PimpedPaginator documentPaginator = GetDocumentPaginatorFrom(managedFlowDocument);
xpsSerializationManager.SaveAsXaml(documentPaginator);
}
private static XpsDocument convertVisualToXps(FrameworkElement visual)
{
visual.Measure(new Size(Int32.MaxValue, Int32.MaxValue));
Size visualSize = visual.DesiredSize;
visual.Arrange(new Rect(new Point(0, 0), visualSize));
MemoryStream stream = new MemoryStream();
string pack = "pack://temp.xps";
Uri uri = new Uri(pack);
DocumentPaginator paginator;
XpsDocument xpsDoc;
using (Package container = Package.Open(stream, FileMode.Create))
{
PackageStore.AddPackage(uri, container);
using (xpsDoc = new XpsDocument(container, CompressionOption.Fast, pack))
{
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
rsm.SaveAsXaml(visual);
paginator = ((IDocumentPaginatorSource)xpsDoc.GetFixedDocumentSequence()).DocumentPaginator;
paginator.PageSize = visualSize;
}
PackageStore.RemovePackage(uri);
}
return(xpsDoc);
}
/// <summary>
/// Helper method to create page header or footer from flow document template
/// </summary>
/// <param name="data">enumerable report data</param>
/// <param name="fileName">file to save XPS to</param>
/// <returns></returns>
public XpsDocument CreateXpsDocument(IEnumerable <ReportData> data, string fileName)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
int count = 0; ReportData firstData = null;
foreach (ReportData rd in data)
{
if (firstData == null)
{
firstData = rd;
}
count++;
}
if (count == 1)
{
return(CreateXpsDocument(firstData)); // we have only one ReportData object -> use the normal ReportPaginator instead
}
Package pkg = Package.Open(fileName, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://report.xps";
PackageStore.RemovePackage(new Uri(pack));
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument doc = new XpsDocument(pkg, _xpsCompressionOption, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
MultipleReportPaginator rp = new MultipleReportPaginator(this, data);
rsm.SaveAsXaml(rp);
rsm.Commit();
pkg.Close();
return(new XpsDocument(fileName, FileAccess.Read));
}
public static void SaveToPdf(this FlowDocument flowDoc, string filename)
{
MemoryStream xamlStream = new MemoryStream();
XamlWriter.Save(flowDoc, xamlStream);
File.WriteAllBytes("d:\\file.xaml", xamlStream.ToArray());
IDocumentPaginatorSource text = flowDoc as IDocumentPaginatorSource;
xamlStream.Close();
MemoryStream memoryStream = new MemoryStream();
Package pkg = Package.Open(memoryStream, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://temp.xps";
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument doc = new XpsDocument(pkg, CompressionOption.SuperFast, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
DocumentPaginator pgn = text.DocumentPaginator;
rsm.SaveAsXaml(pgn);
MemoryStream xpsStream = new MemoryStream();
var writer = new XpsSerializerFactory().CreateSerializerWriter(xpsStream);
writer.Write(doc.GetFixedDocumentSequence());
MemoryStream outStream = new MemoryStream();
NiXPS.Converter.XpsToPdf(xpsStream, outStream);
File.WriteAllBytes("file.pdf", outStream.ToArray());
}
public static void SaveToPdf(this FlowDocument flowDoc, string filename)
{
MemoryStream xamlStream = new MemoryStream();
XamlWriter.Save(flowDoc, xamlStream);
File.WriteAllBytes("d:\\file.xaml", xamlStream.ToArray());
IDocumentPaginatorSource text = flowDoc as IDocumentPaginatorSource;
xamlStream.Close();
MemoryStream memoryStream = new MemoryStream();
Package pkg = Package.Open(memoryStream, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://temp.xps";
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument doc = new XpsDocument(pkg, CompressionOption.SuperFast, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
DocumentPaginator pgn = text.DocumentPaginator;
rsm.SaveAsXaml(pgn);
MemoryStream xpsStream = new MemoryStream();
var writer = new XpsSerializerFactory().CreateSerializerWriter(xpsStream);
writer.Write(doc.GetFixedDocumentSequence());
MemoryStream outStream = new MemoryStream();
NiXPS.Converter.XpsToPdf(xpsStream, outStream);
File.WriteAllBytes("file.pdf", outStream.ToArray());
}
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);
}
}
/// <summary>
/// Attaches a FixedDocumentSequence to an XpsDocument.
/// </summary>
/// <param name="fds">The document sequence to attach.</param>
/// <param name="rp">The Xps package that will contain the document sequence.</param>
private static void AttachSequenceToPackage(FixedDocumentSequence fds, XpsDocument rp)
{
XpsSerializationManager rsm = new XpsSerializationManager(
new XpsPackagingPolicy(rp), false);
rsm.SaveAsXaml(fds);
}
public void CreatePdf(string filename)
{
using (var stream = new MemoryStream())
{
using (var package = Package.Open(stream, FileMode.Create, FileAccess.ReadWrite))
{
using (var xpsDoc = new XpsDocument(package, CompressionOption.Maximum))
{
using (XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false))
{
var flowDoc = new FlowDocument {
ColumnWidth = 1189
};
var paginator = ((IDocumentPaginatorSource)flowDoc).DocumentPaginator;
paginator.PageSize = new Size(842, 595);
while (panel.Children.Count != 0)
{
var page = panel.Children[0] as FrameworkElement;
if (page is PageQuest)
{
paginator.PageSize = new Size(615, 862);
page.Height = 862;
page.Width = 615;
}
else
{
page.Height = 605;
page.Width = 852;
}
double scale = Math.Min((paginator.PageSize.Width - 50) / page.ActualWidth, (paginator.PageSize.Height - 20) / page.ActualHeight);
page.LayoutTransform = new ScaleTransform(scale, scale);
var wp = VisualTreeHelper.GetParent(page);
if (wp != null)
{
(wp as WrapPanel).Children.Remove(page);
}
var para = new Paragraph();
para.Inlines.Add((FrameworkElement)page);
flowDoc.Blocks.Add(para);
}
rsm.SaveAsXaml(paginator);
rsm.Commit();
}
}
}
stream.Position = 0;
var pdfXpsDoc = PdfSharp.Xps.XpsModel.XpsDocument.Open(stream);
PdfSharp.Xps.XpsConverter.Convert(pdfXpsDoc, filename, 0);
}
}
public static void CreateXPSDocument(DocumentPaginator paginator)
{
using (Package container = Package.Open("test" + ".xps", FileMode.Create))
{
using (XpsDocument xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
XpsSerializationManager xpsSM = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
xpsSM.SaveAsXaml(paginator);
}
}
}
public void ExportXps(string filename)
{
using var package = System.IO.Packaging.Package.Open(filename, FileMode.Create);
using var xpsDocument = new XpsDocument(package);
using var manager = new XpsSerializationManager(new XpsPackagingPolicy(xpsDocument), false);
var paginator = ((IDocumentPaginatorSource)_document).DocumentPaginator;
manager.SaveAsXaml(paginator);
manager.Commit();
}
public static void Create(IDocumentPaginatorSource paginator)
{
using (var container = Package.Open(@"C:\temp\" + GetFileName(), FileMode.Create))
{
using (var xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
var xpsSM = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
xpsSM.SaveAsXaml(paginator);
}
}
}
public static int SaveAsXps(IDocumentPaginatorSource docref)
{
object doc;
doc = docref;
//FileInfo fileInfo = new FileInfo(fileName);
//using (FileStream file = fileInfo.OpenRead())
//{
// System.Windows.Markup.ParserContext context = new System.Windows.Markup.ParserContext();
// context.BaseUri = new Uri(fileInfo.FullName, UriKind.Absolute);
// doc = System.Windows.Markup.XamlReader.Load(file, context);
//}
string fileName = @"c:\a.xps";
if (!(doc is IDocumentPaginatorSource))
{
Console.WriteLine("DocumentPaginatorSource expected");
return -1;
}
using (Package container = Package.Open(fileName + ".xps", FileMode.Create))
{
using (XpsDocument xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)doc).DocumentPaginator;
// 8 inch x 6 inch, with half inch margin
paginator = new DocumentPaginatorWrapper(paginator, new Size(768, 676), new Size(24, 24));
rsm.SaveAsXaml(paginator);
}
}
Console.WriteLine("{0} generated.", fileName + ".xps");
return 0;
}
private void Save(string outputPath, IDocumentPaginatorSource paginator)
{
using (var container = Package.Open(outputPath, FileMode.Create))
{
using (var xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
var sm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
sm.SaveAsXaml(paginator);
}
}
}
/// <summary>
/// Saves a <see cref="FlowDocument"/> to an XPS file.
/// </summary>
/// <param name="path">The file path to save to.</param>
/// <param name="document">The document to save.</param>
public static void SaveAsXps(string path, FlowDocument document)
{
using (Package package = Package.Open(path, FileMode.Create))
{
using (var xpsDoc = new XpsDocument(package, CompressionOption.Maximum))
{
var xpsSm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
var dp = ((IDocumentPaginatorSource)document).DocumentPaginator;
xpsSm.SaveAsXaml(dp);
}
}
}
/// <summary>
/// Actually print an Xps Document with previously setup params
/// </summary>
/// <param name="paginator">Document to print</param>
/// <param name="description">Description</param>
public void PrintDocument(DocumentPaginator paginator, string description)
{
if (paginator == null)
{
throw new ArgumentNullException("paginator", "No DocumentPaginator to print");
}
VerifyPrintSettings();
//Handle XPS ourself, as their document writer hates our thread
if (mPrintQueue.FullName.Contains("XPS"))
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "Xps Document (*.xps) | *.xps";
if (sfd.ShowDialog() == true)
{
XpsDocument document = new XpsDocument(sfd.FileName, System.IO.FileAccess.Write);
XpsPackagingPolicy packagePolicy = new XpsPackagingPolicy(document);
XpsSerializationManager serializationMgr = new XpsSerializationManager(packagePolicy, false);
serializationMgr.SaveAsXaml(paginator);
document.Close();
}
return;
}
XpsDocumentWriter writer = null;
new PrintingPermission(PrintingPermissionLevel.DefaultPrinting).Assert();
try
{
mPrintQueue.CurrentJobSettings.Description = description;
writer = PrintQueue.CreateXpsDocumentWriter(mPrintQueue);
TicketEventHandler handler = new TicketEventHandler(mPrintTicket);
writer.WritingPrintTicketRequired += new WritingPrintTicketRequiredEventHandler(handler.SetPrintTicket);
}
finally
{
CodeAccessPermission.RevertAssert();
}
writer.Write(paginator);
//Reset
mPrintableWidth = 0.0;
mPrintableHeight = 0.0;
mWidthUpdated = false;
mHeightUpdated = false;
}
public void Convert(System.Windows.Documents.FlowDocument document, Stream documentStream)
{
using (var package = Package.Open(documentStream, FileMode.Create, FileAccess.ReadWrite))
{
using (var xpsDocument = new XpsDocument(package, CompressionOption.Maximum))
{
var serializer = new XpsSerializationManager(new XpsPackagingPolicy(xpsDocument), false);
var paginator = ((IDocumentPaginatorSource)document).DocumentPaginator;
serializer.SaveAsXaml(paginator);
serializer.Commit();
}
}
}
/// <summary>
/// Saves a flow document as an XPS file
/// </summary>
/// <param name="document">The document to be sabed.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="pageWidth">Width of the page.</param>
/// <param name="pageHeight">Height of the page.</param>
public static void SaveAsXps(this FlowDocument document, string fileName, double pageWidth = 816, double pageHeight = 1056)
{
if (!fileName.ToLower().EndsWith(".xps"))
fileName += ".xps";
using (var container = Package.Open(fileName, FileMode.Create))
using (var xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
var rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
var paginator = new DocumentPaginatorEx(document, new Size(pageWidth, pageHeight), new PageRange());
rsm.SaveAsXaml(paginator);
}
}
private static void SaveFile(string tempFile, FixedDocument fixedDocument)
{
using (var memoryStream = new MemoryStream())
using (Package container = Package.Open(tempFile, FileMode.Create))
{
using (XpsDocument xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
rsm.SaveAsXaml(fixedDocument);
}
memoryStream.Position = 0;
}
}
public static void SaveFlowAsXpsInFile(FlowDocument flowDocument)
{
using (Package container = Package.Open("journal.xps", FileMode.Create))
{
using (XpsDocument xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)flowDocument).DocumentPaginator;
paginator = new DocumentPaginatorWrapper(paginator, new Size(768, 676), new Size(48, 48));
rsm.SaveAsXaml(paginator);
}
}
}
/// <summary>
/// Saves a flow document as an XPS file
/// </summary>
/// <param name="document">The document to be sabed.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="pageWidth">Width of the page.</param>
/// <param name="pageHeight">Height of the page.</param>
public static void SaveAsXps(this FlowDocument document, string fileName, double pageWidth = 816, double pageHeight = 1056)
{
if (!fileName.ToLower().EndsWith(".xps"))
{
fileName += ".xps";
}
using var container = Package.Open(fileName, FileMode.Create);
using var xpsDoc = new XpsDocument(container, CompressionOption.Maximum);
var rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
var paginator = new DocumentPaginatorEx(document, new Size(pageWidth, pageHeight), new PageRange());
rsm.SaveAsXaml(paginator);
}
public static void SaveAsXps(string path, FlowDocument document)
{
using (var package = Package.Open(path, FileMode.Create))
{
using (var xpsDoc = new XpsDocument(
package, CompressionOption.Maximum))
{
var xpsSm = new XpsSerializationManager(
new XpsPackagingPolicy(xpsDoc), false);
var dp = ((IDocumentPaginatorSource)document).DocumentPaginator;
xpsSm.SaveAsXaml(dp);
}
}
}
protected override void SaveCore(IDocument document, string fileName)
{
// We have to clone the FlowDocument before we use different pagination settings for the export.
RichTextDocument richTextDocument = document as RichTextDocument;
FlowDocument clone = richTextDocument.CloneContent();
using (Package package = Package.Open(fileName, FileMode.Create))
using (XpsDocument xpsDocument = new XpsDocument(package, CompressionOption.Maximum))
{
XpsSerializationManager serializer = new XpsSerializationManager(new XpsPackagingPolicy(xpsDocument), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)clone).DocumentPaginator;
serializer.SaveAsXaml(paginator);
}
}
private void SaveAsXps(TextEditor textEditor, string fileName, string title)
{
using (Package package = Package.Open(fileName, FileMode.Create))
{
using (XpsDocument xpsDoc = new XpsDocument(package, CompressionOption.Fast))
{
XpsSerializationManager xpsSerializationManager = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
DocumentPaginatorWrapper paginator = Printing.CreateDocumentPaginatorToPrint(textEditor);
paginator.Title = title;
xpsSerializationManager.SaveAsXaml(paginator);
}
}
}
protected override void SaveCore(IDocument document, string fileName)
{
// We have to clone the FlowDocument before we use different pagination settings for the export.
var richTextDocument = (RichTextDocument)document;
var clone = richTextDocument.CloneContent();
clone.ColumnWidth = double.PositiveInfinity;
using var package = Package.Open(fileName, FileMode.Create);
using var xpsDocument = new XpsDocument(package, CompressionOption.Maximum);
var serializer = new XpsSerializationManager(new XpsPackagingPolicy(xpsDocument), false);
var paginator = ((IDocumentPaginatorSource)clone).DocumentPaginator;
serializer.SaveAsXaml(paginator);
}
/// <summary>
/// Helper method to create page header or footer from flow document template
/// </summary>
/// <param name="data">report data</param>
/// <returns></returns>
public XpsDocument CreateXpsDocument(ReportData data)
{
MemoryStream ms = new MemoryStream();
Package pkg = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://report.xps";
PackageStore.RemovePackage(new Uri(pack));
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument doc = new XpsDocument(pkg, CompressionOption.NotCompressed, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
ReportPaginator rp = new ReportPaginator(this, data);
rsm.SaveAsXaml(rp);
return(doc);
}
/// <summary>
/// Converting the current report's content to a ByteArray.
/// It's suitable for storing the XPS content of the rpt in a database.
/// </summary>
/// <param name="doc">Retrieve it from xps.GetFixedDocumentSequence() or documentViewer.Document</param>
/// <returns></returns>
public static byte[] Export(this FixedDocumentSequence doc)
{
using (var ms = new MemoryStream())
{
using (var package = Package.Open(ms, FileMode.CreateNew))
{
using (var xpsd = new XpsDocument(package, CompressionOption.Maximum))
{
var xpsSm = new XpsSerializationManager(new XpsPackagingPolicy(xpsd), false);
xpsSm.SaveAsXaml(doc.DocumentPaginator);
xpsSm.Commit();
return(ms.ToArray());
}
}
}
}
/// <summary>
/// Converting the current report's content to a ByteArray.
/// It's suitable for storing the XPS content of the rpt in a database.
/// </summary>
/// <param name="doc">Retrieve it from xps.GetFixedDocumentSequence() or documentViewer.Document</param>
/// <returns></returns>
public static byte[] Export(this FixedDocumentSequence doc)
{
using (var ms = new MemoryStream())
{
using (var package = Package.Open(ms, FileMode.CreateNew))
{
using (var xpsd = new XpsDocument(package, CompressionOption.Maximum))
{
var xpsSm = new XpsSerializationManager(new XpsPackagingPolicy(xpsd), false);
xpsSm.SaveAsXaml(doc.DocumentPaginator);
xpsSm.Commit();
return ms.ToArray();
}
}
}
}
public static XpsDocument CreateXpsDocumentFromString(string xamlFlowDoc)
{
object doc;
doc = XamlReader.Parse(xamlFlowDoc);
MemoryStream ms = new MemoryStream();
Package pkg = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://report.xps";
PackageStore.RemovePackage(new Uri(pack));
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument xpsDoc = new XpsDocument(pkg, CompressionOption.NotCompressed, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)doc).DocumentPaginator;
//paginator = new PimpedPaginator(paginator,);
paginator = new DocumentPaginatorWrapper(paginator, new Size(768, 676), new Size(48, 48));
rsm.SaveAsXaml(paginator);
return xpsDoc;
}
/// <summary>
/// Helper method to create page header or footer from flow document template
/// </summary>
/// <param name="data">report data</param>
/// <param name="fileName">file to save XPS to</param>
/// <returns></returns>
public XpsDocument CreateXpsDocument(ReportData data, string fileName)
{
Package pkg = Package.Open(fileName, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://report.xps";
PackageStore.RemovePackage(new Uri(pack));
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument doc = new XpsDocument(pkg, _xpsCompressionOption, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
ReportPaginator rp = new ReportPaginator(this, data);
rsm.SaveAsXaml(rp);
rsm.Commit();
pkg.Close();
return(new XpsDocument(fileName, FileAccess.Read));
}
public void SaveAsXps(string fileName, FlowDocument document)
{
using (System.IO.Packaging.Package container = System.IO.Packaging.Package.Open(fileName, FileMode.Create))
{
using (XpsDocument xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)document).DocumentPaginator;
//16.5=6.4960=623.616
//11=4.3307=415.74
paginator = new DocumentPaginatorWrapper(paginator, new Size(416, 624), new Size(15, 15));
rsm.SaveAsXaml(paginator);
}
}
}
public static void SaveAsXps2(string xamlFlowDoc, string xpsDocumentName)
{
object doc;
doc = XamlReader.Parse(xamlFlowDoc);
using (Package container = Package.Open(xpsDocumentName, FileMode.Create))
{
using (XpsDocument xpsDoc = new XpsDocument(container, CompressionOption.NotCompressed))
{
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
//var paginator = new PimpedPaginator((FlowDocument)doc, new PimpedPaginator.Definition());
DocumentPaginator paginator = ((IDocumentPaginatorSource)doc).DocumentPaginator;
paginator = new ReportPaginator(paginator);
//paginator = new DocumentPaginatorWrapper(paginator, new Size(768, 676), new Size(48, 48));
rsm.SaveAsXaml(paginator);
}
}
}
public static MemoryStream FlowDocumentToXPS(FlowDocument flowDocument, int width, int height)
{
MemoryStream stream = new MemoryStream();
using (Package package = Package.Open(stream, FileMode.Create, FileAccess.ReadWrite))
{
using (XpsDocument xpsDoc = new XpsDocument(package, CompressionOption.Maximum))
{
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)flowDocument).DocumentPaginator;
paginator.PageSize = new System.Windows.Size(width, height);
rsm.SaveAsXaml(paginator);
rsm.Commit();
}
}
stream.Position = 0;
return(stream);
}
private void SaveDocument([NotNull] IDocumentPaginatorSource document)
{
using (var package = Package.Open(_output, FileMode.Create, FileAccess.ReadWrite))
using (var xps = new XpsDocument(package, CompressionOption.Maximum))
using (var policy = new XpsPackagingPolicy(xps))
using (var serializer = new XpsSerializationManager(policy, false)) {
//document.DocumentPaginator.PageSize = new System.Windows.Size(100, 100);
serializer.SaveAsXaml(document.DocumentPaginator);
serializer.Commit();
}
if (_leaveOpen)
{
_output.Flush();
}
else
{
_output.Dispose();
}
}
private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
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)DocViewer.Document).DocumentPaginator;
rsm.SaveAsXaml(paginator);
rsm.Commit();
}
}
stream.Position = 0;
var pdfXpsDoc = PdfSharp.Xps.XpsModel.XpsDocument.Open(stream);
PdfSharp.Xps.XpsConverter.Convert(pdfXpsDoc, "doc.pdf", 0);
}
}
private void LoadedHandler(object sender, RoutedEventArgs e)
{
// We have to clone the FlowDocument before we use different pagination settings for the export.
FlowDocument clone = ViewModel.Document.CloneContent();
clone.ColumnWidth = double.PositiveInfinity;
var packageStream = new MemoryStream();
package = Package.Open(packageStream, FileMode.Create, FileAccess.ReadWrite);
PackageStore.AddPackage(new Uri(PackagePath), package);
xpsDocument = new XpsDocument(package, CompressionOption.SuperFast, PackagePath);
using (var serializer = new XpsSerializationManager(new XpsPackagingPolicy(xpsDocument), false))
{
DocumentPaginator paginator = ((IDocumentPaginatorSource)clone).DocumentPaginator;
serializer.SaveAsXaml(paginator);
}
documentViewer.Document = xpsDocument.GetFixedDocumentSequence();
documentViewer.Focus();
}
/// <summary> Saves the created xps document to a file. </summary>
/// <param name="filename"> The name of the file to save the XPS document as. </param>
public void SaveToFile(string filename)
{
var fixedDocument = new FixedDocument();
foreach (var page in CreatePages())
{
fixedDocument.Pages.Add(page);
}
using (var memoryStream = new MemoryStream())
using (Package container = Package.Open(filename, FileMode.Create))
{
using (XpsDocument xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
rsm.SaveAsXaml(fixedDocument);
}
memoryStream.Position = 0;
}
}
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
if(!(values.Length > 1 && values[0] is FlowDocument))
{
throw new InvalidOperationException("Seule les valeurs de type FlowDocument peuvent êtres converties (FlowDocumentToXpsConverter). Cette erreur est critique.");
}
if(!(values.Length > 1 && values[1] is SumUpViewModel) && !(values[1] == null))
{
throw new InvalidOperationException("Une valeur (position 2) de type SumUpViewModel doit être fournie (FlowDocumentToXpsConverter. Cette erreur est critique");
}
if (values[1] != null)
{
FlowDocument flowDoc = ((FlowDocument)values[0]);
flowDoc.DataContext = values[1];
string xpsDir = ConfigurationManager.AppSettings["XpsOutDir"];
if (!Directory.Exists(xpsDir))
{
Directory.CreateDirectory(xpsDir);
}
using (FileStream fs = File.Open($"{xpsDir}flowDocument.xps", FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
{
using (Package package = Package.Open(fs, FileMode.Create, FileAccess.ReadWrite))
{
XpsDocument xpsDoc = new XpsDocument(package, CompressionOption.Maximum);
XpsSerializationManager xpsSerializationManager = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)flowDoc).DocumentPaginator;
xpsSerializationManager.SaveAsXaml(paginator);
xpsSerializationManager.Commit();
return xpsDoc;
}
}
}
else
{
return null;
}
}
private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
{
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)DocViewer.Document).DocumentPaginator;
rsm.SaveAsXaml(paginator);
rsm.Commit();
}
}
stream.Position = 0;
var pdfXpsDoc = PdfSharp.Xps.XpsModel.XpsDocument.Open(stream);
PdfSharp.Xps.XpsConverter.Convert(pdfXpsDoc, "doc.pdf", 0);
}
}
public static int SaveAsXps(FlowDocument doc, string fileName, Size printableArea)
{
doc.ColumnWidth = printableArea.Width;
using (Package container = Package.Open(fileName, FileMode.Create))
{
using (XpsDocument xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)doc).DocumentPaginator;
paginator.ComputePageCount();
DocumentPaginator newPaginator = new DocumentPaginatorWrapper(
paginator,
printableArea, new Size(8, 8));
rsm.SaveAsXaml(paginator);
}
}
return 0;
}
private void ShowPrintPreview()
{
// We have to clone the FlowDocument before we use different pagination settings for the export.
RichTextDocument document = fileService.ActiveDocument as RichTextDocument;
FlowDocument clone = document.CloneContent();
clone.ColumnWidth = double.PositiveInfinity;
// Create a package for the XPS document
MemoryStream packageStream = new MemoryStream();
package = Package.Open(packageStream, FileMode.Create, FileAccess.ReadWrite);
// Create a XPS document with the path "pack://temp.xps"
PackageStore.AddPackage(new Uri(PackagePath), package);
xpsDocument = new XpsDocument(package, CompressionOption.SuperFast, PackagePath);
// Serialize the XPS document
XpsSerializationManager serializer = new XpsSerializationManager(new XpsPackagingPolicy(xpsDocument), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)clone).DocumentPaginator;
serializer.SaveAsXaml(paginator);
// Get the fixed document sequence
FixedDocumentSequence documentSequence = xpsDocument.GetFixedDocumentSequence();
// Create and show the print preview view
PrintPreviewViewModel printPreviewViewModel = printPreviewViewModelFactory.CreateExport().Value;
printPreviewViewModel.Document = documentSequence;
previousView = shellViewModel.ContentView;
shellViewModel.ContentView = printPreviewViewModel.View;
shellViewModel.IsPrintPreviewVisible = true;
printPreviewCommand.RaiseCanExecuteChanged();
}
public static XpsDocument SaveFlowAsXpsInMemory(FlowDocument flowDocument)
{
MemoryStream ms = new MemoryStream();
Package container = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
Uri documentUri = new Uri("pack://InMemoryDocument.xps");
PackageStore.AddPackage(documentUri, container);
XpsDocument xpsDoc = new XpsDocument(container, CompressionOption.Fast, documentUri.AbsoluteUri);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)flowDocument).DocumentPaginator;
paginator = new DocumentPaginatorWrapper(paginator, new Size(768, 676), new Size(48, 48));
rsm.SaveAsXaml(paginator);
xpsDoc.Close();
container.Close();
return xpsDoc;
}
public override int SaveAsXps(string fileName)
{
object doc;
if (Draft == null)
return -1;
FileInfo fileInfo = new FileInfo(fileName);
List<FlowDocument> Docs = new List<FlowDocument>();
for (int x = 0; x < Chapters.Count; x++)
Docs.Add(((Chapter)Chapters[x]).getFlow());
doc = SavableDocument.CombineDocs(Docs);
if (!(doc is IDocumentPaginatorSource))
{
Console.WriteLine("DocumentPaginatorSource expected");
return -1;
}
File.Delete(fileName);
using (Package container = Package.Open(fileName, FileMode.Create))
{
using (XpsDocument xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)doc).DocumentPaginator;
// 8 inch x 6 inch, with half inch margin
paginator = new DocumentPaginatorWrapper(paginator, new Size(595 * 1.33, 842 * 1.3), new Size(48, 48));
rsm.SaveAsXaml(paginator);
}
}
return 0;
}
private void Save(string outputPath, IDocumentPaginatorSource paginator)
{
using (var container = Package.Open(outputPath, FileMode.Create))
{
using (var xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
var sm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
sm.SaveAsXaml(paginator);
}
}
}
public void FlowDocumentToXps(DocumentPaginator paginator, string filename, string reportName, bool overWrite)
{
XpsDocument document;
if (overWrite)
document = new XpsDocument(filename, FileAccess.Write);
else
document = new XpsDocument(filename, FileAccess.ReadWrite);
XpsPackagingPolicy packagePolicy = new XpsPackagingPolicy(document);
XpsSerializationManager serializationMgr = new XpsSerializationManager(packagePolicy, true);
serializationMgr.Commit();
serializationMgr.SaveAsXaml(paginator);
document.Close();
}
/// <summary>
/// Actually print an Xps Document with previously setup params
/// </summary>
/// <param name="paginator">Document to print</param>
/// <param name="description">Description</param>
public void PrintDocument(DocumentPaginator paginator, string description)
{
if (paginator == null)
throw new ArgumentNullException("paginator", "No DocumentPaginator to print");
VerifyPrintSettings();
//Handle XPS ourself, as their document writer hates our thread
if (mPrintQueue.FullName.Contains("XPS"))
{
SaveFileDialog sfd = new SaveFileDialog();
sfd.Filter = "Xps Document (*.xps) | *.xps";
if (sfd.ShowDialog() == true)
{
XpsDocument document = new XpsDocument(sfd.FileName, System.IO.FileAccess.Write);
XpsPackagingPolicy packagePolicy = new XpsPackagingPolicy(document);
XpsSerializationManager serializationMgr = new XpsSerializationManager(packagePolicy, false);
serializationMgr.SaveAsXaml(paginator);
document.Close();
}
return;
}
XpsDocumentWriter writer = null;
new PrintingPermission(PrintingPermissionLevel.DefaultPrinting).Assert();
try
{
mPrintQueue.CurrentJobSettings.Description = description;
writer = PrintQueue.CreateXpsDocumentWriter(mPrintQueue);
TicketEventHandler handler = new TicketEventHandler(mPrintTicket);
writer.WritingPrintTicketRequired += new WritingPrintTicketRequiredEventHandler(handler.SetPrintTicket);
}
finally
{
CodeAccessPermission.RevertAssert();
}
writer.Write(paginator);
//Reset
mPrintableWidth = 0.0;
mPrintableHeight = 0.0;
mWidthUpdated = false;
mHeightUpdated = false;
}
public IDocumentPaginatorSource LoadPrint(System.Collections.Generic.List<FixedPage> pages, Size vsize)
{
FixedDocument fd = new FixedDocument();
fd.DocumentPaginator.PageSize = vsize;
foreach (var item in pages)
{
PageContent pc = new PageContent();
((IAddChild)pc).AddChild(item);
pc.Height = vsize.Height;
pc.Width = vsize.Width;
fd.Pages.Add(pc);
}
MemoryStream ms = new MemoryStream();
Package pkg = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://report.xps";
PackageStore.RemovePackage(new Uri(pack));
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument doc = new XpsDocument(pkg, CompressionOption.NotCompressed, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
rsm.SaveAsXaml(fd);
return doc.GetFixedDocumentSequence() as IDocumentPaginatorSource;
}
/// <summary>
/// Helper method to create page header or footer from flow document template
/// </summary>
/// <param name="data">enumerable report data</param>
/// <param name="fileName">file to save XPS to</param>
/// <returns></returns>
public XpsDocument CreateXpsDocument(IEnumerable<ReportData> data, string fileName)
{
if (data == null) throw new ArgumentNullException("data");
int count = 0; ReportData firstData = null;
foreach (ReportData rd in data) { if (firstData == null) firstData = rd; count++; }
if (count == 1) return CreateXpsDocument(firstData); // we have only one ReportData object -> use the normal ReportPaginator instead
Package pkg = Package.Open(fileName, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://report.xps";
PackageStore.RemovePackage(new Uri(pack));
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument doc = new XpsDocument(pkg, _xpsCompressionOption, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)CreateFlowDocument()).DocumentPaginator;
MultipleReportPaginator rp = new MultipleReportPaginator(this, data);
rsm.SaveAsXaml(rp);
rsm.Commit();
pkg.Close();
return new XpsDocument(fileName, FileAccess.Read);
}
/// <summary>
/// Helper method to create page header or footer from flow document template
/// </summary>
/// <param name="data">report data</param>
/// <returns></returns>
public static XpsDocument CreateXpsDocument(FlowDocument document) {
MemoryStream ms = new MemoryStream();
Package pkg = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://report.xps";
PackageStore.RemovePackage(new Uri(pack));
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument xpsdoc = new XpsDocument(pkg, CompressionOption.NotCompressed, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsdoc), false);
DocumentPaginator dp =
((IDocumentPaginatorSource)document).DocumentPaginator;
rsm.SaveAsXaml(dp);
return xpsdoc;
}
public static XpsDocument GetXpsDocument(FlowDocument document)
{
//Uri DocumentUri = new Uri("pack://currentTicket_" + new Random().Next(1000).ToString() + ".xps");
Uri docUri = new Uri("pack://tempTicket.xps");
var ms = new MemoryStream();
{
Package package = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
PackageStore.RemovePackage(docUri);
PackageStore.AddPackage(docUri, package);
XpsDocument xpsDocument = new XpsDocument(package, CompressionOption.SuperFast, docUri.AbsoluteUri);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDocument), false);
DocumentPaginator docPage = ((IDocumentPaginatorSource)document).DocumentPaginator;
//docPage.PageSize = new System.Windows.Size(PageWidth, PageHeight);
//docPage.PageSize = new System.Windows.Size(document.PageWidth, document.PageHeight);
rsm.SaveAsXaml(docPage);
return xpsDocument;
}
}
/// <summary>
/// Helper method to create page header or footer from flow document template
/// </summary>
/// <param name="data">report data</param>
/// <returns></returns>
public XpsDocument CreateXpsDocument(ReportData data)
{
MemoryStream ms = new MemoryStream();
Package pkg = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://report.xps";
PackageStore.RemovePackage(new Uri(pack));
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument doc = new XpsDocument(pkg, CompressionOption.NotCompressed, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)CreateFlowDocument()).DocumentPaginator;
ReportPaginator rp = new ReportPaginator(this, data);
rsm.SaveAsXaml(rp);
return doc;
}
/// <summary>
/// Helper method to create page header or footer from flow document template
/// </summary>
/// <param name="data">report data</param>
/// <param name="fileName">file to save XPS to</param>
/// <returns></returns>
public XpsDocument CreateXpsDocument(ReportData data, string fileName)
{
Package pkg = Package.Open(fileName, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://report.xps";
PackageStore.RemovePackage(new Uri(pack));
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument doc = new XpsDocument(pkg, _xpsCompressionOption, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)CreateFlowDocument()).DocumentPaginator;
ReportPaginator rp = new ReportPaginator(this, data);
rsm.SaveAsXaml(rp);
rsm.Commit();
pkg.Close();
return new XpsDocument(fileName, FileAccess.Read);
}
/// <summary>
/// Helper method to create page header or footer from flow document template
/// </summary>
/// <param name="data">enumerable report data</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">data</exception>
public XpsDocument CreateXpsDocument(IEnumerable<ReportData> data)
{
using (var counter = new TimeCounter("CreateXpsDocument Total: {0}", true, true))
{
if (data == null)
throw new ArgumentNullException("data");
int count = 0;
ReportData firstData = null;
foreach (ReportData rd in data) { if (firstData == null) firstData = rd; count++; }
if (count == 1)
return CreateXpsDocument(firstData); // we have only one ReportData object -> use the normal ReportPaginator instead
MemoryStream ms = new MemoryStream();
Package pkg = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
string pack = "pack://report.xps";
PackageStore.RemovePackage(new Uri(pack));
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument doc = new XpsDocument(pkg, CompressionOption.NotCompressed, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
//DocumentPaginator paginator = ((IDocumentPaginatorSource)CreateFlowDocument()).DocumentPaginator;
counter.ShowTick("CreateXpsDocument Prepare: {0}");
MultipleReportPaginator rp = new MultipleReportPaginator(this, data);
counter.ShowTick("CreateXpsDocument Paginator: {0}");
rsm.SaveAsXaml(rp);
counter.ShowTick("CreateXpsDocument SaveAsXaml: {0}");
return doc;
}
}
/// <summary>
/// Helper method to create page header or footer from flow document template
/// </summary>
/// <param name="data">report data</param>
/// <returns></returns>
public XpsDocument CreateXpsDocument(ReportData data, Action<int,int> PageGeneratedCallBack = null)
{
MemoryStream ms = new MemoryStream();
Package pkg = Package.Open(ms, FileMode.Create, FileAccess.ReadWrite);
string pack = String.Format("pack://report{0}.xps", this.ReportName);
PackageStore.RemovePackage(new Uri(pack));
PackageStore.AddPackage(new Uri(pack), pkg);
XpsDocument doc = new XpsDocument(pkg, CompressionOption.NotCompressed, pack);
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(doc), false);
//DocumentPaginator paginator = ((IDocumentPaginatorSource)CreateFlowDocument()).DocumentPaginator;
ReportPaginator rp = new ReportPaginator(this, data, PageGeneratedCallBack);
rsm.SaveAsXaml(rp);
rsm.Commit();
//pkg.Close();
return doc;
}
public virtual int SaveAsXps(string fileName)
{
object doc;
if (Draft == null)
return -1;
FileInfo fileInfo = new FileInfo(fileName);
SavableDocument sav = new SavableDocument(Draft);
doc = sav.CloneDoc();
//using (FileStream file = fileInfo.OpenRead())
//{
// System.Windows.Markup.ParserContext context = new System.Windows.Markup.ParserContext();
// context.BaseUri = new Uri(fileInfo.FullName, UriKind.Absolute);
// //doc = System.Windows.Markup.XamlReader.Load(file, context);
//}
if (!(doc is IDocumentPaginatorSource))
{
Console.WriteLine("DocumentPaginatorSource expected");
return -1;
}
File.Delete(fileName);
using (Package container = Package.Open(fileName, FileMode.Create))
{
using (XpsDocument xpsDoc = new XpsDocument(container, CompressionOption.Maximum))
{
XpsSerializationManager rsm = new XpsSerializationManager(new XpsPackagingPolicy(xpsDoc), false);
DocumentPaginator paginator = ((IDocumentPaginatorSource)doc).DocumentPaginator;
// 8 inch x 6 inch, with half inch margin
paginator = new DocumentPaginatorWrapper(paginator, new Size(595*1.33, 842*1.3), new Size(48, 48));
rsm.SaveAsXaml(paginator);
}
}
return 0;
}
