/// <summary> /// Constructor /// </summary> /// <param name="report">report document</param> /// <param name="data">report data</param> /// <exception cref="ArgumentException">Flow document must have a specified page height</exception> /// <exception cref="ArgumentException">Flow document must have a specified page width</exception> /// <exception cref="ArgumentException">Flow document can have only one report header section</exception> /// <exception cref="ArgumentException">Flow document can have only one report footer section</exception> public ReportPaginator(ReportDocument report, ReportData data) { _report = report; _data = data; _flowDocument = report.CreateFlowDocument(); _pageSize = new Size(_flowDocument.PageWidth, _flowDocument.PageHeight); if (_flowDocument.PageHeight == double.NaN) throw new ArgumentException("Flow document must have a specified page height"); if (_flowDocument.PageWidth == double.NaN) throw new ArgumentException("Flow document must have a specified page width"); _dynamicCache = new ReportPaginatorDynamicCache(_flowDocument); ArrayList listPageHeaders = _dynamicCache.GetFlowDocumentVisualListByType(typeof(SectionReportHeader)); if (listPageHeaders.Count > 1) throw new ArgumentException("Flow document can have only one report header section"); if (listPageHeaders.Count == 1) _blockPageHeader = (SectionReportHeader)listPageHeaders[0]; ArrayList listPageFooters = _dynamicCache.GetFlowDocumentVisualListByType(typeof(SectionReportFooter)); if (listPageFooters.Count > 1) throw new ArgumentException("Flow document can have only one report footer section"); if (listPageFooters.Count == 1) _blockPageFooter = (SectionReportFooter)listPageFooters[0]; _paginator = ((IDocumentPaginatorSource)_flowDocument).DocumentPaginator; // remove header and footer in our working copy Block block = _flowDocument.Blocks.FirstBlock; while (block != null) { Block thisBlock = block; block = block.NextBlock; if ((thisBlock == _blockPageHeader) || (thisBlock == _blockPageFooter)) _flowDocument.Blocks.Remove(thisBlock); } // get report context values _reportContextValues = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(IInlineContextValue)); FillData(); }
public ReportPaginator(DocumentPaginator documentPaginator) { _paginator = documentPaginator; _reportDefinition = new ReportDefinition(); _paginator.PageSize = _reportDefinition.ContentSize; }
public DocumentPaginatorWrapper(DocumentPaginator paginator, Size pageSize, Size margin) { m_PageSize = pageSize; m_Margin = margin; m_Paginator = paginator; m_Paginator.PageSize = new Size(m_PageSize.Width - margin.Width * 2, m_PageSize.Height - margin.Height * 2); _dateTime = DateTime.Now; }
public DocumentPaginatorWrapper(DocumentPaginator paginator, Size pageSize, Size margin) { m_PageSize = pageSize; m_Margin = margin; m_Paginator = paginator; m_Paginator.PageSize = new Size(PageSize.Width - margin.Width * 2, PageSize.Height - margin.Height * 2); m_Typeface = new Typeface("Times New Roman"); }
public PageRangeDocumentPaginator( DocumentPaginator paginator, PageRange pageRange) { _startIndex = pageRange.PageFrom - 1; _endIndex = pageRange.PageTo - 1; _paginator = paginator; // Adjust the _endIndex _endIndex = Math.Min(_endIndex, _paginator.PageCount - 1); }
public CustomDocumentPaginator(DocumentPaginator paginator, Size pageSize, Size margin, String headerText) { m_PageSize = pageSize; m_Margin = margin; m_Paginator = paginator; m_Paginator.PageSize = new Size(m_PageSize.Width - margin.Width * 2, m_PageSize.Height - margin.Height * 2); HeaderText = headerText; }
public PrintingPaginator(DocumentPaginator originalPaginator, Size pageSize, Size pageMargin) { this._originalPaginator = originalPaginator; this._pageSize = pageSize; this._pageMargin = pageMargin; _originalPaginator.PageSize = new Size( _pageSize.Width - _pageMargin.Width * 2, _pageSize.Height - _pageMargin.Height * 2); _originalPaginator.ComputePageCount(); }
//------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors /// <summary> /// Standard constructor. /// </summary> public DocumentGridPage(DocumentPaginator paginator) : base() { _paginator = paginator; //Attach the GetPageCompleted event handler to the paginator so we can //use it to keep track of whether our page has been loaded yet. _paginator.GetPageCompleted += new GetPageCompletedEventHandler(OnGetPageCompleted); //Set up the static elements of our Visual Tree. Init(); }
private XpsDocument LoadAsXPS(DocumentPaginator paginator) { var stream = new MemoryStream(); var docPackage = Package.Open(stream, FileMode.Create, FileAccess.ReadWrite); var uri = new Uri(@"memorystream://myXps.xps"); PackageStore.RemovePackage(uri); PackageStore.AddPackage(uri, docPackage); var xpsDoc = new XpsDocument(docPackage) { Uri = uri }; XpsDocument.CreateXpsDocumentWriter(xpsDoc).Write(paginator); return xpsDoc; }
/// <summary> /// Class constructor /// </summary> /// <param name="paginator"></param> /// <param name="pageSettings"></param> /// <param name="printTicket"></param> /// <param name="headerFooterfontFamily"></param> public DocumentPaginatorWrapper(DocumentPaginator paginator, PageSettings pageSettings, PrintTicket printTicket, FontFamily headerFooterfontFamily) { m_Margins = ConvertMarginsToPx(pageSettings.Margins); if (pageSettings.Landscape) m_PageSize = new Size((int)printTicket.PageMediaSize.Height, (int)printTicket.PageMediaSize.Width); else m_PageSize = new Size((int)printTicket.PageMediaSize.Width, (int)printTicket.PageMediaSize.Height); m_Paginator = paginator; m_Paginator.PageSize = new Size(m_PageSize.Width - m_Margins.Left - m_Margins.Right, m_PageSize.Height - m_Margins.Top - m_Margins.Bottom); m_Typeface = new Typeface(headerFooterfontFamily, FontStyles.Normal, FontWeights.Normal, FontStretches.Normal); }
// ReSharper restore InconsistentNaming /// <summary> /// Constructor /// </summary> /// <param name="report">report document</param> /// <param name="data">report data</param> /// <exception cref="ArgumentException">Flow document must have a specified page height</exception> /// <exception cref="ArgumentException">Flow document must have a specified page width</exception> /// <exception cref="ArgumentException">Flow document can have only one report header section</exception> /// <exception cref="ArgumentException">Flow document can have only one report footer section</exception> public ReportPaginator(ReportDocument report, ReportData data, Action<int, int> PageGeneratedCallBack = null, FlowDocument flowDocument = null) { _report = report; _data = data; _pageGeneratedCallBack = PageGeneratedCallBack; _flowDocument = flowDocument; if (_flowDocument == null) _flowDocument = report.CreateFlowDocument(); _pageSize = new Size(_flowDocument.PageWidth, _flowDocument.PageHeight); if (_flowDocument.PageHeight == double.NaN) throw new ArgumentException("Flow document must have a specified page height"); if (_flowDocument.PageWidth == double.NaN) throw new ArgumentException("Flow document must have a specified page width"); _dynamicCache = new ReportPaginatorDynamicCache(_flowDocument); ArrayList listPageHeaders = _dynamicCache.GetFlowDocumentVisualListByType(typeof(SectionReportHeader)); if (listPageHeaders.Count > 1) throw new ArgumentException("Flow document can have only one report header section"); if (listPageHeaders.Count == 1) _blockPageHeader = (SectionReportHeader)listPageHeaders[0]; ArrayList listPageFooters = _dynamicCache.GetFlowDocumentVisualListByType(typeof(SectionReportFooter)); if (listPageFooters.Count > 1) throw new ArgumentException("Flow document can have only one report footer section"); if (listPageFooters.Count == 1) _blockPageFooter = (SectionReportFooter)listPageFooters[0]; _paginator = ((IDocumentPaginatorSource)_flowDocument).DocumentPaginator; // remove header and footer in our working copy Block block = _flowDocument.Blocks.FirstBlock; while (block != null) { Block thisBlock = block; block = block.NextBlock; if ((thisBlock == _blockPageHeader) || (thisBlock == _blockPageFooter)) _flowDocument.Blocks.Remove(thisBlock); } // get report context values _reportContextValues = _dynamicCache.GetFlowDocumentVisualListByInterface(typeof(IInlineContextValue)); FillData(); /*Application.Current.Dispatcher.Invoke(new Action(() => { Window aa = new Window(); FlowDocumentPageViewer bb = new FlowDocumentPageViewer(); bb.Document = _flowDocument; aa.Content = bb; aa.SizeToContent = SizeToContent.WidthAndHeight; aa.ShowDialog(); }));*/ }
// --------------------- AdjustFlowDocumentToPage --------------------- /// <summary> /// Fits a given flow document to a specified media size.</summary> /// <param name="ipd"> /// The document paginator containing the flow document.</param> /// <param name="pq"> /// The print queue the document will be output to. public Visual AdjustFlowDocumentToPage( DocumentPaginator idp, PrintQueue pq) { const double inch = 96; PrintTicket pt = pq.UserPrintTicket; // Get the media size. double width = pt.PageMediaSize.Width.Value; double height = pt.PageMediaSize.Height.Value; // Set the margins. double leftmargin = 1.25 * inch; double rightmargin = 1.25 * inch; double topmargin = 1 * inch; double bottommargin = 1 * inch; // Calculate the content size. double contentwidth = width - leftmargin - rightmargin; double contentheight = height - topmargin - bottommargin; idp.PageSize = new Size(contentwidth, contentheight); DocumentPage p = idp.GetPage(0); // Create a wrapper visual for transformation and add extras. ContainerVisual page = new ContainerVisual(); page.Children.Add(p.Visual); DrawingVisual title = new DrawingVisual(); using (DrawingContext ctx = title.RenderOpen()) { Typeface typeface = new Typeface("Times New Roman"); Brush pen = Brushes.Black; FormattedText text = new FormattedText("Page 0", System.Globalization.CultureInfo.CurrentCulture, FlowDirection.LeftToRight, typeface, 14, pen); ctx.DrawText(text, new Point(inch / 4, -inch / 2)); } page.Children.Add(title); page.Transform = new TranslateTransform(leftmargin, topmargin); return page; }
public Paginator(FlowDocument document, Definition def) { this.paginator = ((IDocumentPaginatorSource)document).DocumentPaginator; this.definition = def; def.Margins = document.PagePadding; def.FooterHeight = 40; paginator.PageSize = def.ContentSize; // Change page size of the document to // the size of the content area document.ColumnWidth = definition.ContentSize.Width; // Prevent columns document.PageWidth = definition.ContentSize.Width; document.PageHeight = definition.ContentSize.Height; document.PagePadding = new Thickness(0); }
/// <summary> /// Create an instance of AnnotationDocumentPaginator for a given document and annotation store. /// </summary> /// <param name="originalPaginator">document to add annotations to</param> /// <param name="annotationStore">store to retrieve annotations from</param> /// <param name="flowDirection"></param> public AnnotationDocumentPaginator(DocumentPaginator originalPaginator, AnnotationStore annotationStore, FlowDirection flowDirection) { _isFixedContent = originalPaginator is FixedDocumentPaginator || originalPaginator is FixedDocumentSequencePaginator; if (!_isFixedContent && !(originalPaginator is FlowDocumentPaginator)) throw new ArgumentException(SR.Get(SRID.OnlyFlowAndFixedSupported)); _originalPaginator = originalPaginator; _annotationStore = annotationStore; _locatorManager = new LocatorManager(_annotationStore); _flowDirection = flowDirection; // Register for events _originalPaginator.GetPageCompleted += new GetPageCompletedEventHandler(HandleGetPageCompleted); _originalPaginator.ComputePageCountCompleted += new AsyncCompletedEventHandler(HandleComputePageCountCompleted); _originalPaginator.PagesChanged += new PagesChangedEventHandler(HandlePagesChanged); }
public Visual GetNextPortion(Size availableSpace) { if (_docPaginator == null) _docPaginator = GetDocumentPaginator(availableSpace); var page = _docPaginator.GetPage(_nextPageToRetrieveNumber++); if (page == DocumentPage.Missing) return null; var pageSize = page.Size; if (pageSize.Height > availableSpace.Height || pageSize.Width > availableSpace.Width) throw new ArgumentOutOfRangeException("availableSpace"); return page.Visual; }
public PimpedPaginator(FlowDocument document, Definition def) { // Create a copy of the flow document, // so we can modify it without modifying // the original. MemoryStream stream = new MemoryStream(); TextRange sourceDocument = new TextRange(document.ContentStart, document.ContentEnd); sourceDocument.Save(stream, DataFormats.Xaml); FlowDocument copy = new FlowDocument(); TextRange copyDocumentRange = new TextRange(copy.ContentStart, copy.ContentEnd); copyDocumentRange.Load(stream, DataFormats.Xaml); this.paginator = ((IDocumentPaginatorSource)copy).DocumentPaginator; this.definition = def; paginator.PageSize = def.ContentSize; // Change page size of the document to // the size of the content area copy.ColumnWidth = double.MaxValue; // Prevent columns copy.PageWidth = definition.ContentSize.Width; copy.PageHeight = definition.ContentSize.Height; copy.PagePadding = new Thickness(0); }
//IDocumentPaginatorSource flowDocument, public static FixedDocument ConvertToFixedDocument(DocumentPaginator documentPaginator) { FixedDocument fixeddoc = new FixedDocument(); // DocumentPaginator paginator = documentPaginator; if (!documentPaginator.IsPageCountValid) documentPaginator.ComputePageCount(); int pageindex; for (pageindex = 0; pageindex < documentPaginator.PageCount; pageindex++) { Grid grid = new Grid(); DocumentPageView pageView = new DocumentPageView(); pageView.DocumentPaginator = documentPaginator; pageView.PageNumber = pageindex; grid.Children.Add(new Border() { BorderBrush = Brushes.Black, BorderThickness = new Thickness(1), HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center, Child = pageView }); FixedPage fixedpage = new FixedPage(); fixedpage.Width = documentPaginator.PageSize.Width; fixedpage.Height = documentPaginator.PageSize.Height; fixedpage.Children.Add(grid); PageContent pc = new PageContent(); ((IAddChild)pc).AddChild(fixedpage); fixeddoc.Pages.Add(pc); } return fixeddoc; }
public DocumentPaginatorWrapper(DocumentPaginator paginator, PrintableDocumentDefinition definition) { if (!(paginator.Source is PrintableDocument)) { throw new Exception("This paginator can be used only in PrintableDocument classes"); } _paginator = paginator; _definition = definition; doc = Source as PrintableDocument; var headerSize = GetModelContentSize(doc.DataContext, doc.Header, _definition.PageSize); var footerSize = GetModelContentSize(doc.DataContext, doc.Footer, _definition.PageSize); _definition.HeaderHeight = double.IsInfinity(headerSize.Height) ? 0 : headerSize.Height; _definition.FooterHeight = double.IsInfinity(footerSize.Height) ? 0 : footerSize.Height; _paginator.PageSize = _definition.ContentSize; ComputePageCount(); doc.DataSource.PageCount = _paginator.PageCount; }
public override void WriteAsync(DocumentPaginator documentPaginator) { throw new NotSupportedException(); }
/// <summary> /// Create an instance of AnnotationDocumentPaginator for a given document and annotation store. /// </summary> /// <param name="originalPaginator">document to add annotations to</param> /// <param name="annotationStore">store to retrieve annotations from</param> public AnnotationDocumentPaginator(DocumentPaginator originalPaginator, AnnotationStore annotationStore) : this(originalPaginator, annotationStore, FlowDirection.LeftToRight) { }
/// <summary> /// Create an instance of AnnotationDocumentPaginator for a given document and annotation store. /// </summary> /// <param name="originalPaginator">document to add annotations to</param> /// <param name="annotationStore">store to retrieve annotations from</param> /// <param name="flowDirection"></param> public AnnotationDocumentPaginator(DocumentPaginator originalPaginator, Stream annotationStore, FlowDirection flowDirection) : this(originalPaginator, new XmlStreamStore(annotationStore), flowDirection) { }
//----------------------------------------------------- // // Public Constructors // //----------------------------------------------------- #region Public Constructors /// <summary> /// Create an instance of AnnotationDocumentPaginator for a given document and annotation store. /// </summary> /// <param name="originalPaginator">document to add annotations to</param> /// <param name="annotationStore">store to retrieve annotations from</param> public AnnotationDocumentPaginator(DocumentPaginator originalPaginator, Stream annotationStore) : this(originalPaginator, new XmlStreamStore(annotationStore), FlowDirection.LeftToRight) { }
public void PrintDocument(DocumentPaginator documentPaginator, string description) { DocumentPaginator = documentPaginator; Description = description; }
public void PrintDocument(DocumentPaginator documentPaginator, string description) { printDialog.PrintDocument(documentPaginator, description); }
public override void Write(DocumentPaginator documentPaginator, PrintTicket printTicket) { SerializeObjectTree(documentPaginator.Source); }
public override void Write(DocumentPaginator documentPaginator) { Write(documentPaginator, null); }
private void GenerateReport() { using (new TimeCounter("Build report: {0}")) using (new WaitWrapper()) { var reportDocument = new ReportDocument(); using (new TimeCounter("\tGet template: {0}")) reportDocument.XamlData = GetXaml(); using (new TimeCounter("\tGet paginator: {0}")) DocumentPaginator = GetPaginator(reportDocument); PageNumber = 0; } }
/// <summary> /// Builds the fixed document. /// </summary> /// <param name="sourceFlowDocPaginator">The source flow doc paginator.</param> /// <param name="size">The size.</param> /// <param name="margins">The margins.</param> /// <returns>The document.</returns> private FixedDocument BuildFixedDocument(DocumentPaginator sourceFlowDocPaginator, Size size, Thickness margins) { var fixedDocument = new FixedDocument(); for (int pageNo = 0; pageNo < sourceFlowDocPaginator.PageCount; pageNo++) { var pageCanvas = new Canvas { Margin = margins }; this.AddPageBody(sourceFlowDocPaginator, pageNo, pageCanvas, margins); this.AddPageToDocument(fixedDocument, pageCanvas, size); } return fixedDocument; }
/// <summary> /// The add page body. /// </summary> /// <param name="sourceFlowDocPaginator"> /// The source flow doc paginator. /// </param> /// <param name="pageNo"> /// The page no. /// </param> /// <param name="pageCanvas"> /// The page canvas. /// </param> /// <param name="margins"> /// The margins. /// </param> private void AddPageBody( DocumentPaginator sourceFlowDocPaginator, int pageNo, Canvas pageCanvas, Thickness margins) { using (var dpv = new DocumentPageView()) { dpv.DocumentPaginator = sourceFlowDocPaginator; dpv.PageNumber = pageNo; Canvas.SetTop(dpv, margins.Top); Canvas.SetLeft(dpv, margins.Left); pageCanvas.Children.Add(dpv); } }
public override void WriteAsync(DocumentPaginator documentPaginator, PrintTicket printTicket, object userState) { throw new NotSupportedException(); }