Question

我有一个巨大的数据，我想用WPF打印。我发现WPF提供了一个PrintDialog.PrintVisual方法来打印从Visual类派生的任何WPF控件。

PrintVisual只会打印一个页面，所以我需要缩放控件以适应页面。不幸的是，这对我来说不起作用，因为报告有时足够长，以至于在缩放以适应页面时无法轻松阅读。

WPF提供的另一种打印选项是在FlowDocument中创建单独的视图。这可能是打印文档的最佳方式，但它比我想要的更多工作，更不用说我希望打印的每个控件都需要保留的额外视图。

我在这个link中得到了另一个解决方案，但对我来说似乎太复杂了。

有没有更好更简单的解决方案呢？谢谢你的帮助

Answer 1

我假设您的报告显示在DataGrid或其他可滚动的内容中？

我相信FlowDocument绝对是你最好的选择，如果你想打印一些外观，因为缺乏一个更好的词，专业。但是如果你想要快速和肮脏的东西，你可以使用RenderTargetBitmap.Render使用一系列操作。基本过程是：

创建RenderTargetBitmap
滚动视图，以便在一个页面上显示您想要打印的区域
致电RenderTargetBitmap.Render上的DataGrid或包含“大型”控件的ScrollViewer
打印生成的位图
重复下一个“Page”

同样，不要在“大”控件上调用RenderTargetBitmap.Render。如果尚未将大型控件包裹在ScrollViewer中。那将基本上是你的分页。

我不知道你是否会对结果感到满意，但这是我能想到的最简单的方法。看起来你每次都会手动点击PrintScreen。不确定这是不是你想要的，但如果你希望它看起来更好，我认为你需要使用FlowDocument。

Answer 2

我使用PrintDialog和DocumentPaginator进行打印。

我的工作是：

选择打印机（显示打印对话框或使用系统默认值）
创建页面（以纸张大小控制wpf）
打印

这是我的测试功能：

public static void PrintTest1(Viewbox viewboxInWindowForRender)
{
    FrameworkElement[] testContArr = PrepareTestContents();

    //=========================
    PrintManager man = new PrintManager();

    // Show print dialog (or select default printer)
    if (!man.SelectPrinter())
        return;

    man.SetPageMargins(new Thickness(PrintManager.Size1cm * 2));

    //=========================
    List<FrameworkElement> pagesForPrint = new List<FrameworkElement>();

    for (int i = 0; i < testContArr.Length; i++)
    {
        // Put the page content into the control of the size of paper
        FrameworkElement whitePage = man.CreatePageWithContentStretched(testContArr[i]);
        // Temporary put the page into window (need for UpdateLayout)
        viewboxInWindowForRender.Child = whitePage;
        // Update and render whitePage.
        // Measure and Arrange will be used properly.
        viewboxInWindowForRender.UpdateLayout();

        pagesForPrint.Add(whitePage);
    }
    viewboxInWindowForRender.Child = null;
    //=========================
    // Now you can show print preview to user.
    // pagesForPrint has all pages.
    // ...
    //=========================

    MyDocumentPaginator paginator = man.CreatePaginator();
    paginator.AddPages(pagesForPrint);

    // Start printing
    man.Print(paginator, "Printing Test");
}

// For testing
public static FrameworkElement[] PrepareTestContents()
{
    StackPanel sp1 = new StackPanel();
    sp1.Width = PrintManager.PageSizeA4.Width - PrintManager.Size1cm * 2;
    sp1.Children.Add(PrepareTestBorder("Alice has a cat."));
    sp1.Children.Add(PrepareTestBorder("Page number one."));

    StackPanel sp2 = new StackPanel();
    sp2.Width = sp1.Width / 2;
    sp2.Children.Add(PrepareTestBorder("Farmer has a dog."));
    sp2.Children.Add(PrepareTestBorder("Page number two."));

    return new FrameworkElement[] {sp1, sp2 };
}

// For testing
public static FrameworkElement PrepareTestBorder(string text)
{
    Border b = new Border();
    b.BorderBrush = Brushes.Black;
    b.BorderThickness = new Thickness(1);
    b.Margin = new Thickness(0, 0, 0, 5);

    TextBlock t = new TextBlock();
    t.Text = text;

    b.Child = t;
    return b;
}

在窗口的某个位置，您应该使用Viewbox进行临时布局更新和渲染。

<Window ...>
    <Grid>
        <Viewbox x:Name="forRender" Visibility="Hidden" Width="100" Height="100"/>
        ...
    </Grid>
</Window>

而且你可以运行test：PrintTest1(forRender);

这是 PrintManager 类：

public class PrintManager
{
    public static readonly Size PageSizeA4 = new Size(21 * 96 / 2.54, 29.7 * 96 / 2.54); // (793.700787401575, 1122.51968503937)
    public static readonly double Size1cm = 96 / 2.54; // 37.7952755905512

    private PrintDialog _printDialog;

    public PrintTicket PrintTicket { get; private set; }
    public PrintCapabilities TicketCapabilities { get; private set; }

    // Page size selected in print dialog (may not be exactly as paper size)
    public Size PageSize { get; private set; }
    public Thickness PageMargins { get; private set; }

    public Rect PageContentRect {
        get {
            return new Rect(PageMargins.Left, PageMargins.Top,
                PageSize.Width - PageMargins.Left - PageMargins.Right,
                PageSize.Height - PageMargins.Top - PageMargins.Bottom);
        }
    }

    public PrintManager()
    {
    }

    /// <summary>
    /// Show print dialog or try use default printer when useDefaultPrinter param set to true.
    /// <para/>
    /// Return false on error or when user pushed Cancel.
    /// </summary>
    public bool SelectPrinter(bool useDefaultPrinter = false)
    {
        if (_printDialog == null)
            _printDialog = new PrintDialog();

        try
        {
            if (useDefaultPrinter)
                _printDialog.PrintQueue = LocalPrintServer.GetDefaultPrintQueue();

            // pDialog.PrintQueue == null when default printer is not selected in system
            if (_printDialog.PrintQueue == null || !useDefaultPrinter)
            {
                // Show print dialog
                if (_printDialog.ShowDialog() != true)
                    return false;
            }

            if (_printDialog.PrintQueue == null)
                throw new Exception("Printer error");

            // Get default printer settings
            //_printDialog.PrintTicket = _printDialog.PrintQueue.DefaultPrintTicket;
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
            return false;
        }

        PrintTicket = _printDialog.PrintTicket;
        TicketCapabilities = _printDialog.PrintQueue.GetPrintCapabilities(PrintTicket);
        PageSize = new Size((double)TicketCapabilities.OrientedPageMediaWidth,
            (double)TicketCapabilities.OrientedPageMediaHeight);
        SetPageMargins(PageMargins); // Update margins if too small

        return true;
    }

    /// <summary>
    ///  Start printing pages from paginator.
    /// </summary>
    public void Print(MyDocumentPaginator paginator, string printTaskDescription)
    {
        if (_printDialog == null)
            return;

        // Start printing document
        _printDialog.PrintDocument(paginator, printTaskDescription);
    }

    /// <summary>
    /// Set page margins and return true.
    /// <para/>
    /// If new page margins are too small (unprinted area) then set minimum and return false.
    /// </summary>
    public bool SetPageMargins(Thickness margins)
    {
        PageImageableArea pia = TicketCapabilities.PageImageableArea;

        PageMargins = new Thickness(Math.Max(margins.Left, pia.OriginWidth),
            Math.Max(margins.Top, pia.OriginHeight),
            Math.Max(margins.Right, PageSize.Width - pia.OriginWidth - pia.ExtentWidth),
            Math.Max(margins.Bottom, PageSize.Height - pia.OriginHeight - pia.ExtentHeight));

        return PageMargins == margins;
    }

    /// <summary>
    /// Set pate margins with minimal
    /// </summary>
    public void SetMinimalPageMargins()
    {
        PageImageableArea pia = TicketCapabilities.PageImageableArea;

        // Set minimal page margins to bypass the unprinted area.
        PageMargins = new Thickness(pia.OriginWidth, pia.OriginHeight,
            (double)TicketCapabilities.OrientedPageMediaWidth - - pia.OriginWidth - pia.ExtentWidth,
            (double)TicketCapabilities.OrientedPageMediaHeight - pia.OriginHeight - pia.ExtentHeight);
    }

    /// <summary>
    /// Create page control witch pageContent ready to print.
    /// Content is stretched to the margins.
    /// </summary>
    public FrameworkElement CreatePageWithContentStretched(FrameworkElement pageContent)
    {
        // Place the content inside the page (without margins)
        Viewbox pageInner = new Viewbox();
        pageInner.VerticalAlignment = VerticalAlignment.Top; // From the upper edge
        pageInner.Child = pageContent;

        // Printed control - the page with content
        Border whitePage = new Border();
        whitePage.Width = PageSize.Width;
        whitePage.Height = PageSize.Height;
        whitePage.Padding = PageMargins;
        whitePage.Child = pageInner;

        return whitePage;
    }

    /// <summary>
    /// Create page control witch pageContent ready to print.
    /// <para/>
    /// Content is aligned to the top-center and must have
    /// a fixed size (max PageSize-PageMargins).
    /// </summary>
    public FrameworkElement CreatePageWithContentSpecSize(FrameworkElement contentSpecSize)
    {
        // Place the content inside the page
        Decorator pageInner = new Decorator();
        pageInner.HorizontalAlignment = HorizontalAlignment.Center;
        pageInner.VerticalAlignment = VerticalAlignment.Top;
        pageInner.Child = contentSpecSize;

        // Printed control - the page with content
        Border whitePage = new Border();
        whitePage.Width = PageSize.Width;
        whitePage.Height = PageSize.Height;

        // We align to the top-center only, because padding will cut controls
        whitePage.Padding = new Thickness(0, PageMargins.Top, 0, 0);

        whitePage.Child = pageInner;
        return whitePage;
    }

    /// <summary>
    /// Create paginator for pages created by CreatePageWithContent().
    /// </summary>
    public MyDocumentPaginator CreatePaginator()
    {
        return new MyDocumentPaginator(PageSize);
    }
}

这是 MyDocumentPaginator 课程：

public class MyDocumentPaginator : DocumentPaginator
{
    private List<FrameworkElement> _pages = new List<FrameworkElement>();

    public override bool IsPageCountValid  { get { return true; } }
    public override int PageCount { get { return _pages.Count; } }
    public override Size PageSize { get; set; } 
    public override IDocumentPaginatorSource Source { get { return null; } }  

    public MyDocumentPaginator(Size pageSize)
    {
        PageSize = pageSize;
    }

    public override DocumentPage GetPage(int pageNumber)
    {
        // Warning: DocumentPage remember only reference to Visual object.
        // Visual object can not be changed until PrintDialog.PrintDocument() called
        // or e.g. XpsDocumentWriter.Write().
        // That's why I don't create DocumentPage in AddPage method.
        return new DocumentPage(_pages[pageNumber], PageSize, new Rect(PageSize), new Rect(PageSize));
    }

    public void AddPage(FrameworkElement page)
    {
        _pages.Add(page);
    }
    public void AddPages(List<FrameworkElement> pages)
    {
        _pages.AddRange(pages);
    }
}

你告诉我你要打印已有的控件。
您可以使用我的解决方案打印出来。

例如：
假设您有UserCtrl，ParentBorder。您需要将其从父控件中删除，然后才能使用它。

ParentBorder.Child = null;
// Or you can use my function
RemoveFromParent(UserCtrl);

比你可以准备页面：

FrameworkElement whitePage = man.CreatePageWithContentStretched(UserCtrl);
viewboxInWindowForRender.Child = whitePage;
viewboxInWindowForRender.UpdateLayout();

MyDocumentPaginator paginator = man.CreatePaginator();
paginator.AddPages(whitePage);

man.Print(paginator, "Printing UserControl");

// After print you can restore UserCtrl
RemoveFromParent(UserCtrl);
ParentBorder.Child = UserCtrl;

这里的 RemoveFromParent 功能：

public static void RemoveFromParent(FrameworkElement child)
{
    DependencyObject parent = child.Parent;

    if (parent == null)
        return;
    if (parent is Panel)
        ((Panel)parent).Children.Remove(child);
    else if (parent is Decorator)
        ((Decorator)parent).Child = null;
    else if (parent is ContentControl)
        ((ContentControl)parent).Content = null;
    else if (parent is ContentPresenter)
        ((ContentPresenter)parent).Content = null;
    else
        throw new Exception("RemoveFromParent: Unsupported type " + parent.GetType().ToString());
}

为什么我在窗口中使用UpdateLayout和Viewbox，而不像其他示例中的人那样使用测量和排列？

我试试，但我遇到了很多问题。我使用了我已经拥有的控件，我改变了打印样式，我也export to PDF。衡量和安排不适合我。控件必须停靠在窗口中，以便正确进行布局更新和渲染。

打印大型WPF用户控件

2 个答案: