Impression en WPF

**cyberbobby** · 13/10/2009, 08h10

Bonjour,

J'aimerais imprimer un page contenant des Images et des zones de texte depuis mon application.

Actuellement, j'ai fais une fenêtre qui affiche la page qui va être imprimée à l'écran. Cette fenêtre est composée d'une Grid rassemblant les différentes informations.

J'aimerais l'imprimer de manière à ce qu'elle prenne l'entièreté de ma page A4, le souci, c'est que en fonction de la résolution, de la dimension de ma fenêtre, le résultat de l'impression n'est pas le même.

Actuellement j'utilise :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            var printDlg = new PrintDialog();
            if (printDlg.ShowDialog() == true)
            {
                // Impression du contenu de l'écran.
                printDlg.PrintVisual(this, "Commande " + "Test");
 
            }
        }

Je suis tombé sur d'autres source mais je suis un peu perdu.
Est-il possible de me donner un extrait de code dans lequel je peux forcer ma zone d'impression aux dimensions d'une page A4 et dans laquelle je pourrais recréer ma structure et ma disposition (Image + Texte) ?

Merci

**laedit** · 13/10/2009, 08h43

Il faudrait que tu passe par un PrintDocument. Là tu auras un Graphics dans lequel tu va définir ce que tu veux imprimer, tu as ainsi une plus grande liberté sur la disposition.

Quand au redimensionnement, je pense que tu va devoir le calculer par toi même en fonction de la résolution.

**seiryujay** · 13/10/2009, 15h14

Aller, c'est mon jour de bonté

: voici une méthode que j'ai faite en m'inspirant de bouts de code récupérés sur le net afin d'imprimer un FrameworkElement (donc tout objet visuel) et que celui-ci soit mis à l'échelle afin de remplir toute la page (mais vraiment toute la page, avec zéro marge) :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
        /// <summary>
        /// Method used to print a visual so that it fits the page.
        /// </summary>
        /// <param name="elementToPrint_l">The visual to print</param>
        public static void print(FrameworkElement elementToPrint_l)
        {
            // Create the print dialog object and set options
            PrintDialog printDialog_l = new PrintDialog();
            printDialog_l.PageRangeSelection = PageRangeSelection.AllPages;
            printDialog_l.UserPageRangeEnabled = true;
 
            // Display the dialog. This returns true if the user presses the Print button.
            bool? print_l = printDialog_l.ShowDialog();
            if (print_l == true)
            {
                // Get selected printer capabilities.
                PrintCapabilities capabilities_l =
                    printDialog_l.PrintQueue.GetPrintCapabilities(printDialog_l.PrintTicket);
 
                // Compute the scale to apply to the visual in order for it to fit in the page.
                double scale_l = Math.Min(capabilities_l.PageImageableArea.ExtentWidth/elementToPrint_l.ActualWidth,
                                          capabilities_l.PageImageableArea.ExtentHeight/elementToPrint_l.ActualHeight);
 
                //Save the printed element old attributes in order to render it back as
                //it was before printing (the printing mechanism modifying the actual
                //element render).
                //The transformation applied to the element to print.
                Transform oldTransform_l = elementToPrint_l.LayoutTransform;
                //The size of the element to print.
                Size oldSize_l = new Size(elementToPrint_l.ActualWidth, elementToPrint_l.ActualHeight);
                //The position of the element to print inside its parent visual.
                GeneralTransform transform_l = elementToPrint_l.TransformToAncestor((Visual)elementToPrint_l.Parent);
                Point topLeft_l = transform_l.Transform(new Point(0, 0));
 
                // Transform the Visual with the computed scale factor.
                elementToPrint_l.LayoutTransform = new ScaleTransform(scale_l, scale_l);
 
                // Get the size of the printer page.
                Size size_l = new Size(capabilities_l.PageImageableArea.ExtentWidth,
                                      capabilities_l.PageImageableArea.ExtentHeight);
 
                // Update the layout of the visual to the printer page size.
                elementToPrint_l.Measure(size_l);
                elementToPrint_l.Arrange(new Rect(
                                             new Point(capabilities_l.PageImageableArea.OriginWidth,
                                                       capabilities_l.PageImageableArea.OriginHeight),
                                             size_l));
 
                //Print the visual.
                printDialog_l.PrintVisual(elementToPrint_l, "Printing active panel...");
 
                // Reinitialize panel's attributes.
                elementToPrint_l.LayoutTransform = oldTransform_l;
                elementToPrint_l.Measure(oldSize_l);
                elementToPrint_l.Arrange(new Rect(topLeft_l, oldSize_l)); 
            }
        }

Et là, c'est sa petite soeur qui prend en plus en compte les marges et l'orientation définie pour le papier (infos stockées dans l'argument PageSettings, l'objet PrinterSettings n'étant pour l'instant pas utilisé):

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
        /// <summary>
        /// Method used to print a visual so that it fits the page.
        /// Use the given page settings.
        /// </summary>
        /// <param name="elementToPrint_l">The visual to print.</param>
        /// <param name="pageSettings_p">Page settings (margins, paper size, portrait/landscape, etc).</param>
        /// <param name="printerSettings_p">Printer settings (printer name, etc).</param>
        public static void print(FrameworkElement elementToPrint_l, 
            PageSettings pageSettings_p,
            PrinterSettings printerSettings_p)
        {
            // Create the print dialog object and set options
            PrintDialog printDialog_l = new PrintDialog();
            printDialog_l.PageRangeSelection = PageRangeSelection.AllPages;
            printDialog_l.UserPageRangeEnabled = true;
 
            // Display the dialog. This returns true if the user presses the Print button.
            bool? print_l = printDialog_l.ShowDialog();
            if (print_l == true)
            {
                // Get selected printer capabilities.
                PrintCapabilities capabilities_l =
                    printDialog_l.PrintQueue.GetPrintCapabilities(printDialog_l.PrintTicket);
 
                // Compute the scale to apply to the visual in order for it to fit in the page.
                double printableWidth_l;
                double printableHeight_l;
 
                if (pageSettings_p.Landscape)
                {
                    printableWidth_l = capabilities_l.PageImageableArea.ExtentHeight - pageSettings_p.Margins.Left - pageSettings_p.Margins.Right;
                    printableHeight_l = capabilities_l.PageImageableArea.ExtentWidth - pageSettings_p.Margins.Top - pageSettings_p.Margins.Bottom;
                }
                else
                {
                    printableWidth_l = capabilities_l.PageImageableArea.ExtentWidth - pageSettings_p.Margins.Left - pageSettings_p.Margins.Right;
                    printableHeight_l = capabilities_l.PageImageableArea.ExtentHeight - pageSettings_p.Margins.Top - pageSettings_p.Margins.Bottom;
                }
 
                double scale_l = Math.Min(printableWidth_l / elementToPrint_l.ActualWidth,
                    printableHeight_l / elementToPrint_l.ActualHeight);
 
                //Save the printed element old attributes in order to render it back as
                //it was before printing (the printing mechanism modifying the actual
                //element render).
                //The transformation applied to the element to print.
                Transform oldTransform_l = elementToPrint_l.LayoutTransform;
                //The size of the element to print.
                Size oldSize_l = new Size(elementToPrint_l.ActualWidth, 
                    elementToPrint_l.ActualHeight);
                //The position of the element to print inside its parent visual.
                GeneralTransform transform_l = elementToPrint_l.TransformToAncestor((Visual)elementToPrint_l.Parent);
                Point topLeft_l = transform_l.Transform(new Point(0, 0));
 
                // Transform the Visual with the computed scale factor.
                TransformGroup transformGroup_l = new TransformGroup();
                transformGroup_l.Children.Add(new ScaleTransform(scale_l, 
                    scale_l));
 
                if (pageSettings_p.Landscape)
                {
                    transformGroup_l.Children.Add(new RotateTransform(90.0));
                    transformGroup_l.Children.Add(new TranslateTransform(pageSettings_p.Margins.Bottom,
                        pageSettings_p.Margins.Left));
                }
                else
                {
                    transformGroup_l.Children.Add(new TranslateTransform(pageSettings_p.Margins.Left, 
                        pageSettings_p.Margins.Top));
                }
 
                //elementToPrint_l.LayoutTransform = new ScaleTransform(scale_l, scale_l);
                elementToPrint_l.LayoutTransform = transformGroup_l;
 
                // Get the size of the printer page.
                Size size_l;
                if (pageSettings_p.Landscape)
                {
                    size_l = new Size(printableHeight_l,
                        printableWidth_l);
                }
                else
                {
                    size_l = new Size(printableWidth_l,
                        printableHeight_l);
                }
 
                // Update the layout of the visual to the printer page size.
                elementToPrint_l.Measure(size_l);
                if (pageSettings_p.Landscape)
                {
                    elementToPrint_l.Arrange(new Rect(
                                                new Point(pageSettings_p.Margins.Bottom,
                                                          pageSettings_p.Margins.Left),
                                                size_l));
                }
                else
                {
                    elementToPrint_l.Arrange(new Rect(
                                                 new Point(pageSettings_p.Margins.Left,
                                                           pageSettings_p.Margins.Top),
                                                 size_l));
                }
 
                //Print the visual.
                printDialog_l.PrintVisual(elementToPrint_l, "Printing active panel...");
 
                // Reinitialize panel's attributes.
                elementToPrint_l.LayoutTransform = oldTransform_l;
                elementToPrint_l.Measure(oldSize_l);
                elementToPrint_l.Arrange(new Rect(topLeft_l, oldSize_l));
            }
        }

Pour l'instant je n'ai pas codé la prise en charge du format de la page (A4, A3, etc).
On se base sur les PrintCapabilities retournées par la PrintDialog (et chez moi c'est tout le temps A4).
En cherchant un peu, on doit pouvoir lui passer le format fourni par l'objet PageSettings, mais je n'ai pas pris le temps de le faire.

Pour ce qui est des objets PageSettings et PrinterSettings, tu peux les remplir en utilisant une PageSetupDialog ou directement à la main.

En espérant que ça t'aide.

PS : pour ce qui est de la PageSetupDialog, je me suis rendu compte d'un truc un peu surprenant qu'il faut que je regarde de plus près mais en gros, y'a des problèmes d'unités entre ce qu'est censé contenir la propriété Margins (normalement exprimée en centièmes de pouces) et ce qu'il faut réellement lui passer (des dixièmes de millimètres il me semble) pour que la valeur soit la bonne dans la PageSetupDialog.
A revérifier...

**cyberbobby** · 14/10/2009, 07h16

Excellent ça ! Un tout grand merci pour tes méthodes, j'ai utilisé la première et ça fonctionne ...

Alors, j'ai encore un ptit souci ... En fait, mon but final est d'imprimer mon document 4x sur une page A4.

L'idéal serait de pouvoir l'imprimer 4x de suite et de choisir dans les options d'impression de mon imprimante de mettre 4 pages sur une seule.

Mais ... Est-il possible d'imprimer 4x le document dans une seule opération (comme si il faisait 4 pages en fait) ?

Encore un tout grand merci pour ton aide !

**cyberbobby** · 14/10/2009, 08h37

Ca va, j'ai fais autrement, j'affiche la page telle que je vais l'imprimer (Avec 4 UserControl dans une Grid).

Encore merci pour tout !

Impression en WPF

Windows Presentation Foundation

Vue hybride

Discussions similaires

Partager

Partager