private void renderBarcode(string textData, PrintCapabilities printCaps)
{
//create barcode image
CodeQrBarcodeDraw barcode = BarcodeDrawFactory.CodeQr;
//draw barcode image
DrawImage image = barcode.Draw(textData, 2);
image = resizeImage(image, new Size(printCaps.PageImageableArea.ExtentWidth, printCaps.PageImageableArea.ExtentHeight));
//create memory stream for barcode conversion
MemoryStream ms = new MemoryStream();
//save barcode image to memory stream as PNG
image.Save(ms, ImageFormat.Png);
//set memory stream position back to the beginning
ms.Position = 0;
//create bitmap image
bitmap = new BitmapImage();
//prep bitmap for memory stream
bitmap.BeginInit();
//set memory stream
bitmap.StreamSource = ms;
//end stream prep
bitmap.EndInit();
ms = new MemoryStream();
saveAsPng(getImage(getDrawingVisual(bitmap)), ms);
bitmap = bitmapImageFromStream(ms);
//use bitmap as image source
imgBarcode.Source = bitmap;
}
private static Rect GetImageableRect(PrintDialog dialog)
{
Rect empty = Rect.Empty;
Invariant.Assert(dialog != null, "Dialog should not be null.");
PrintCapabilities printCapabilities = null;
CodeAccessPermission codeAccessPermission = SystemDrawingHelper.NewDefaultPrintingPermission();
codeAccessPermission.Assert();
try
{
PrintQueue printQueue = dialog.PrintQueue;
if (printQueue != null)
{
printCapabilities = printQueue.GetPrintCapabilities();
}
}
finally
{
CodeAccessPermission.RevertAssert();
}
if (printCapabilities != null)
{
PageImageableArea pageImageableArea = printCapabilities.PageImageableArea;
if (pageImageableArea != null)
{
empty = new Rect(pageImageableArea.OriginWidth, pageImageableArea.OriginHeight, pageImageableArea.ExtentWidth, pageImageableArea.ExtentHeight);
}
}
if (empty == Rect.Empty)
{
empty = new Rect(15.0, 15.0, dialog.PrintableAreaWidth, dialog.PrintableAreaHeight);
}
return(empty);
}
private void PrintCharts(Grid grid)
{
PrintDialog print = new PrintDialog();
if (print.ShowDialog() == true)
{
PrintCapabilities capabilities = print.PrintQueue.GetPrintCapabilities(print.PrintTicket);
double scale = Math.Min(capabilities.PageImageableArea.ExtentWidth / grid.ActualWidth,
capabilities.PageImageableArea.ExtentHeight / grid.ActualHeight);
Transform oldTransform = grid.LayoutTransform;
grid.LayoutTransform = new ScaleTransform(scale, scale);
Size oldSize = new Size(grid.ActualWidth, grid.ActualHeight);
Size sz = new Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
grid.Measure(sz);
((UIElement)grid).Arrange(new Rect(new Point(capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight),
sz));
print.PrintVisual(grid, "Print Results");
grid.LayoutTransform = oldTransform;
grid.Measure(oldSize);
((UIElement)grid).Arrange(new Rect(new Point(0, 0),
oldSize));
}
else
{
MessageBox.Show("Please connect your printer");
}
}
public void PrintSnapshot()
{
PrintDialog printDlg = new System.Windows.Controls.PrintDialog();
if (printDlg.ShowDialog() == true)
{
//get selected printer capabilities
PrintCapabilities capabilities = printDlg.PrintQueue.GetPrintCapabilities(printDlg.PrintTicket);
//Capture the image
RenderTargetBitmap bmp = new RenderTargetBitmap((int)mainGrid.ActualWidth, (int)mainGrid.ActualHeight, 96, 96, PixelFormats.Pbgra32);
bmp.Render(this);
//Place on a panel
StackPanel myPanel = new StackPanel();
myPanel.Margin = new Thickness(25);
Image myImage = new Image();
myImage.Stretch = Stretch.Uniform;
myImage.Source = bmp;
myPanel.Children.Add(myImage);
//TextBlock myBlock = new TextBlock();
//myBlock.Text = "A Great Image.";
//myBlock.TextAlignment = TextAlignment.Center;
//myPanel.Children.Add(myBlock);
myPanel.Measure(new Size(printDlg.PrintableAreaWidth, printDlg.PrintableAreaHeight));
myPanel.Arrange(new Rect(new Point(0, 0), myPanel.DesiredSize));
printDlg.PrintVisual(myPanel, "Map capture");
}
}
private void printBarcode(FrameworkElement visual, string description)
{
PrintDialog pDiag = new PrintDialog();
//Dispatcher.BeginInvoke(DispatcherPriority.Render, new Action(() =>
//{
if (pDiag.ShowDialog() == true)
{
//get selected printer capabilities
PrintCapabilities printCaps = pDiag.PrintQueue.GetPrintCapabilities(pDiag.PrintTicket);
//get scale of the print wrt to screen of WPF visual
double scale = Math.Min(printCaps.PageImageableArea.ExtentWidth / visual.ActualWidth, printCaps.PageImageableArea.ExtentHeight / visual.ActualHeight);
//double scale = Math.Min(pDiag.PrintableAreaWidth / this.ActualWidth, pDiag.PrintableAreaHeight / this.ActualHeight);
//Transform the Visual to scale
visual.LayoutTransform = new ScaleTransform(scale, scale);
//get the size of the printer page
Size sz = new Size(printCaps.PageImageableArea.ExtentWidth, printCaps.PageImageableArea.ExtentHeight);
//update the layout of the visual to the printer page size.
visual.Measure(sz);
visual.Arrange(new Rect(new Point(printCaps.PageImageableArea.OriginWidth, printCaps.PageImageableArea.OriginHeight), sz));
pDiag.PrintVisual(visual, description);
}
//}));
}
public static PrintDialog ConfigureAndPrintAdjustments()
{
m_printCapabilities = m_printDialog.PrintQueue.GetPrintCapabilities(m_printDialog.PrintTicket);
PrintDialog printDialog = AdjustPrinterCapabilities();
return(printDialog);
}
//Set the states of the controls defined in the markup
//for this Window.
private void SetControlStates(
PrintCapabilities printCapabilities,
PrintTicket printTicket)
{
gbStage1.IsEnabled = false;
gbStage2.IsEnabled = true;
gbStage3.IsEnabled = true;
//Set duplexing options.
rbDuplexing1.IsEnabled =
printCapabilities.DuplexingCapability.Contains(
Duplexing.OneSided);
rbDuplexing1.IsChecked =
printTicket.Duplexing == Duplexing.OneSided;
rbDuplexing2.IsEnabled =
printCapabilities.DuplexingCapability.Contains(
Duplexing.TwoSidedLongEdge);
rbDuplexing2.IsChecked =
printTicket.Duplexing == Duplexing.TwoSidedLongEdge;
rbDuplexing3.IsEnabled =
printCapabilities.DuplexingCapability.Contains(
Duplexing.TwoSidedShortEdge);
rbDuplexing3.IsChecked =
printTicket.Duplexing == Duplexing.TwoSidedShortEdge;
//Set colation properties.
rbCollation1.IsEnabled =
printCapabilities.CollationCapability.Contains(
Collation.Collated);
rbCollation1.IsChecked =
printTicket.Collation == Collation.Collated;
rbCollation2.IsEnabled =
printCapabilities.CollationCapability.Contains(
Collation.Uncollated);
rbCollation2.IsChecked =
printTicket.Collation == Collation.Uncollated;
//Set the orientation properties
rbOrientation1.IsEnabled =
printCapabilities.PageOrientationCapability.Contains(
PageOrientation.Landscape);
rbOrientation1.IsChecked =
printTicket.PageOrientation == PageOrientation.Landscape;
rbOrientation2.IsEnabled =
printCapabilities.PageOrientationCapability.Contains(
PageOrientation.Portrait);
rbOrientation2.IsChecked =
printTicket.PageOrientation == PageOrientation.Portrait;
}
public static void AskToPrint(FrameworkElement ctrl
, string printJobDesc = "Scaled Visual")
{
PrintDialog print = new PrintDialog();
if (print.ShowDialog() != true)
{
return;
}
PrintCapabilities capabilities = print.PrintQueue.GetPrintCapabilities(print.PrintTicket);
double scale = Math.Min(capabilities.PageImageableArea.ExtentWidth / ctrl.ActualWidth,
capabilities.PageImageableArea.ExtentHeight / ctrl.ActualHeight);
ctrl.LayoutTransform = new ScaleTransform(scale, scale);
Size sz = new Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
ctrl.Measure(sz);
((UIElement)ctrl).Arrange(new Rect(new Point(capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight),
sz));
ctrl.Focus();
print.PrintVisual(ctrl, printJobDesc);
}
public static void Print(FrameworkElement objectToPrint, string print_job_name)
{
double original_width = objectToPrint.ActualWidth;
double original_height = objectToPrint.ActualHeight;
PrintDialog printDialog = new PrintDialog();
if ((bool)printDialog.ShowDialog().GetValueOrDefault())
{
PrintCapabilities capabilities = printDialog.PrintQueue.GetPrintCapabilities(printDialog.PrintTicket);
// Convert the UI control into a bitmap
double DPI = 200;
double dpiScale = DPI / 96.0;
RenderTargetBitmap bmp = new RenderTargetBitmap(
Convert.ToInt32(objectToPrint.ActualWidth * dpiScale),
Convert.ToInt32(objectToPrint.ActualHeight * dpiScale),
DPI, DPI, PixelFormats.Pbgra32
);
bmp.Render(objectToPrint);
bmp.Freeze();
// Create the document
FixedDocument document = new FixedDocument();
document.DocumentPaginator.PageSize = new Size(printDialog.PrintableAreaWidth, printDialog.PrintableAreaHeight);
// Break the bitmap down into pages
int pageWidth = Convert.ToInt32(capabilities.PageImageableArea.ExtentWidth * dpiScale);
int pageHeight = Convert.ToInt32(capabilities.PageImageableArea.ExtentHeight * dpiScale);
{
FixedPage printDocumentPage = new FixedPage();
printDocumentPage.Width = pageWidth;
printDocumentPage.Height = pageHeight;
// Create a new bitmap for the contents of this page
Image pageImage = new Image();
pageImage.Source = bmp;
pageImage.VerticalAlignment = VerticalAlignment.Center;
pageImage.HorizontalAlignment = HorizontalAlignment.Center;
// Place the bitmap on the page
printDocumentPage.Children.Add(pageImage);
PageContent pageContent = new PageContent();
((IAddChild)pageContent).AddChild(printDocumentPage);
pageImage.Width = capabilities.PageImageableArea.ExtentWidth;
pageImage.Height = capabilities.PageImageableArea.ExtentHeight;
FixedPage.SetLeft(pageImage, capabilities.PageImageableArea.OriginWidth);
FixedPage.SetTop(pageImage, capabilities.PageImageableArea.OriginHeight);
document.Pages.Add(pageContent);
}
printDialog.PrintDocument(document.DocumentPaginator, print_job_name);
}
}
// </GetPrintQueues>
// <GetPrintTicket>
/// <summary>
/// Returns a print ticket, which is a set of instructions telling a printer how
/// to set its various features, such as duplexing, collating, and stapling.
/// </summary>
/// <param name="printQueue">The print queue to print to.</param>
/// <returns>A print ticket.</returns>
public static PrintTicket GetPrintTicket(PrintQueue printQueue)
{
PrintCapabilities printCapabilites = printQueue.GetPrintCapabilities();
// Get a default print ticket from printer.
PrintTicket printTicket = printQueue.DefaultPrintTicket;
// Modify the print ticket.
if (printCapabilites.CollationCapability.Contains(Collation.Collated))
{
printTicket.Collation = Collation.Collated;
}
if (printCapabilites.DuplexingCapability.Contains(Duplexing.TwoSidedLongEdge))
{
printTicket.Duplexing = Duplexing.TwoSidedLongEdge;
}
if (printCapabilites.StaplingCapability.Contains(Stapling.StapleDualLeft))
{
printTicket.Stapling = Stapling.StapleDualLeft;
}
// Returns a print ticket, which is a set of instructions telling a printer how
// to set its various features, such as duplexing, collating, and stapling.
return(printTicket);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
PrintDialog printDlg = new PrintDialog();
// printDlg.PrintVisual(dgArhiva, "Grid Printing.");
if (printDlg.ShowDialog() == true)
{
//get selected printer capabilities
PrintCapabilities capabilities = printDlg.PrintQueue.GetPrintCapabilities(printDlg.PrintTicket);
//get scale of the print wrt to screen of WPF visual
double scale = Math.Min(capabilities.PageImageableArea.ExtentWidth / this.ActualWidth, capabilities.PageImageableArea.ExtentHeight /
this.ActualHeight);
//Transform the Visual to scale
dgArhiva.LayoutTransform = new ScaleTransform(scale, scale);
//get the size of the printer page
Size sz = new Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
//update the layout of the visual to the printer page size.
dgArhiva.Measure(sz);
dgArhiva.Arrange(new Rect(new Point(capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight), sz));
//now print the visual to printer to fit on the one page.
printDlg.PrintVisual(dgArhiva, "First Fit to Page WPF Print");
}
}
/// <summary>
/// Returns the minimum page margins supported by the printer for a specific page size. Make sure the <see cref="PrintCapabilities"/> parameter
/// contains the correct printer and page size, otherwise you will get the wrong margins.
/// </summary>
/// <param name="printerCapabilities"><see cref="PrintCapabilities"/> for a specific printer and page size.</param>
/// <returns>Minimum margins that this printer supports for a given page size.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="printerCapabilities" /> is <see langword="null" />.</exception>
public Thickness GetMinimumPageMargins(PrintCapabilities printerCapabilities)
{
if (printerCapabilities is null)
{
throw new ArgumentNullException(nameof(PrintCapabilities), $"{nameof(PrintCapabilities)} cannot be null.");
}
if (!printerCapabilities.OrientedPageMediaWidth.HasValue)
{
throw new ArgumentNullException(nameof(printerCapabilities.OrientedPageMediaWidth), $"{nameof(printerCapabilities.OrientedPageMediaWidth)} cannot be null.");
}
if (!printerCapabilities.OrientedPageMediaHeight.HasValue)
{
throw new ArgumentNullException(nameof(printerCapabilities.OrientedPageMediaHeight), $"{nameof(printerCapabilities.OrientedPageMediaHeight)} cannot be null.");
}
if (printerCapabilities.PageImageableArea == null)
{
throw new ArgumentNullException(nameof(printerCapabilities.PageImageableArea), $"{nameof(printerCapabilities.PageImageableArea)} cannot be null.");
}
var minLeftMargin = printerCapabilities.PageImageableArea.OriginWidth;
var minTopMargin = printerCapabilities.PageImageableArea.OriginHeight;
var minRightMargin = printerCapabilities.OrientedPageMediaWidth.Value - printerCapabilities.PageImageableArea.ExtentWidth - minLeftMargin;
var minBottomMargin = printerCapabilities.OrientedPageMediaHeight.Value - printerCapabilities.PageImageableArea.ExtentHeight - minTopMargin;
return(new Thickness(minLeftMargin, minTopMargin, minRightMargin, minBottomMargin));
}
private void PrintCharts(Grid grid)
{
PrintDialog print = new PrintDialog();
if (print.ShowDialog() == true)
{
//print.PrintTicket.PageOrientation = PageOrientation.Landscape;
PrintCapabilities capabilities = print.PrintQueue.GetPrintCapabilities(print.PrintTicket);
print.PrintTicket.OutputColor = OutputColor.Grayscale;
double scale = Math.Min((capabilities.PageImageableArea.ExtentWidth / grid.ActualWidth),
(capabilities.PageImageableArea.ExtentHeight / grid.ActualHeight));
Transform oldTransform = grid.LayoutTransform;
grid.LayoutTransform = new ScaleTransform(scale, scale);
Size oldSize = new Size(grid.ActualWidth, grid.ActualHeight);
Size sz = new Size((capabilities.PageImageableArea.ExtentWidth), (capabilities.PageImageableArea.ExtentHeight));
grid.Measure(sz);
((UIElement)grid).Arrange(new Rect(new Point(capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight),
sz));
print.PrintVisual(grid, "Print Results");
grid.LayoutTransform = oldTransform;
grid.Measure(oldSize);
((UIElement)grid).Arrange(new Rect(new Point(0, 0),
oldSize));
gridPrint.SetValue(Grid.RowSpanProperty, 3);
gridPrint1.Visibility = Visibility.Visible;
}
}
private void printersCombo_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (!IsLoaded)
{
return;
}
if (e.AddedItems.Count == 0)
{
return;
}
PrintQueue printer = (PrintQueue)((FrameworkElement)e.AddedItems[0]).Tag;
if (printer == null)
{
return;
}
if (selectedPrinter != null)
{
if (selectedPrinter.Description == printer.Description)
{
return;
}
}
selectedPrinter = printer;
PrintCapabilities capabilities = printer.GetPrintCapabilities();
UpdateDuplexUI(printer, capabilities);
}
/*
* PageMediaSizeName.BusinessCard Business card
* PageMediaSizeName.CreditCard Credit card
* PageMediaSizeName.ISOA0 A0
* PageMediaSizeName.ISOA1 A1
* PageMediaSizeName.ISOA10 A10
* PageMediaSizeName.ISOA2 A2
* PageMediaSizeName.ISOA3 A3
* PageMediaSizeName.ISOA3Extra A3 Extra
* PageMediaSizeName.ISOA3Rotated A3 Rotated
* PageMediaSizeName.ISOA4 A4
* PageMediaSizeName.ISOA4Extra A4 Extra
* PageMediaSizeName.ISOA4Rotated A4 Rotated
* PageMediaSizeName.ISOA5 A5
* PageMediaSizeName.ISOA5Extra A5 Extra
* PageMediaSizeName.ISOA5Rotated A5 Rotated
* PageMediaSizeName.ISOA6 A6
* PageMediaSizeName.ISOA6Rotated A6 Rotated
* PageMediaSizeName.ISOA7 A7
* PageMediaSizeName.ISOA8 A8
* PageMediaSizeName.PageMediaSizeName.ISOA9 A9
* PageMediaSizeName.ISOB0 B0
* PageMediaSizeName.ISOB1 B1
* PageMediaSizeName.ISOB10 B10
* PageMediaSizeName.ISOB2 B2
* PageMediaSizeName.ISOB3 B3
* PageMediaSizeName.ISOB4 B4
* PageMediaSizeName.ISOB4Envelope B4 Envelope
* PageMediaSizeName.ISOB5Envelope B5 Envelope
* PageMediaSizeName.ISOB5Extra B5 Extra
* PageMediaSizeName.ISOB7 B7
* PageMediaSizeName.ISOB8 B8
* PageMediaSizeName.ISOB9 B9
* PageMediaSizeName.ISOC0 C0
* PageMediaSizeName.ISOC1 C1
* PageMediaSizeName.ISOC10 C10
* PageMediaSizeName.ISOC2 C2
* PageMediaSizeName.ISOC3 C3
* PageMediaSizeName.ISOC3Envelope C3 Envelope
* PageMediaSizeName.ISOC4 C4
* PageMediaSizeName.ISOC4Envelope C4 Envelope
* PageMediaSizeName.ISOC5 C5
* PageMediaSizeName.ISOC5Envelope C5 Envelope
* PageMediaSizeName.ISOC6 C6
* PageMediaSizeName.ISOC6C5Envelope C6C5 Envelope
* PageMediaSizeName.ISOC6Envelope C6 Envelope
* PageMediaSizeName.ISOC7 C7
* PageMediaSizeName.ISOC8 C8
* PageMediaSizeName.ISOC9 C9
* PageMediaSizeName.ISODLEnvelope DL Envelope
* PageMediaSizeName.ISODLEnvelopeRotated DL Envelope Rotated
* PageMediaSizeName.ISOSRA3 SRA 3
* PageMediaSizeName.Japan2LPhoto 2L Photo
* PageMediaSizeName.JapanChou3Envelope Chou 3 Envelope
* PageMediaSizeName.JapanChou3EnvelopeRotated Chou 3 Envelope Rotated
* PageMediaSizeName.JapanChou4Envelope Chou 4 Envelope
* PageMediaSizeName.JapanChou4EnvelopeRotated Chou 4 Envelope Rotated
* PageMediaSizeName.JapanDoubleHagakiPostcard Double Hagaki Postcard
* PageMediaSizeName.JapanDoubleHagakiPostcardRotated Double Hagaki Postcard Rotated
* PageMediaSizeName.JapanHagakiPostcard Hagaki Postcard
* PageMediaSizeName.JapanHagakiPostcardRotated Hagaki Postcard Rotated
* PageMediaSizeName.JapanKaku2Envelope Kaku 2 Envelope
* PageMediaSizeName.JapanKaku2EnvelopeRotated Kaku 2 Envelope Rotated
* PageMediaSizeName.JapanKaku3Envelope Kaku 3 Envelope
* PageMediaSizeName.JapanKaku3EnvelopeRotated Kaku 3 Envelope Rotated
* PageMediaSizeName.JapanLPhoto L Photo
* PageMediaSizeName.JapanQuadrupleHagakiPostcard Quadruple Hagaki Postcard
* PageMediaSizeName.JapanYou1Envelope You 1 Envelope
* PageMediaSizeName.JapanYou2Envelope You 2 Envelope
* PageMediaSizeName.JapanYou3Envelope You 3 Envelope
* PageMediaSizeName.JapanYou4Envelope You 4 Envelope
* PageMediaSizeName.JapanYou4EnvelopeRotated You 4 Envelope Rotated
* PageMediaSizeName.JapanYou6Envelope You 6 Envelope
* PageMediaSizeName.JapanYou6EnvelopeRotated You 6 Envelope Rotated
* PageMediaSizeName.JISB0 Japanese Industrial Standard B0
* PageMediaSizeName.JISB1 Japanese Industrial Standard B1
* PageMediaSizeName.JISB10 Japanese Industrial Standard B10
* PageMediaSizeName.JISB2 Japanese Industrial Standard B2
* PageMediaSizeName.JISB3 Japanese Industrial Standard B3
* PageMediaSizeName.JISB4 Japanese Industrial Standard B4
* PageMediaSizeName.JISB4Rotated Japanese Industrial Standard B4 Rotated
* PageMediaSizeName.JISB5 Japanese Industrial Standard B5
* PageMediaSizeName.JISB5Rotated Japanese Industrial Standard B5 Rotated
* PageMediaSizeName.JISB6 Japanese Industrial Standard B6
* PageMediaSizeName.JISB6Rotated Japanese Industrial Standard B6 Rotated
* PageMediaSizeName.JISB7 Japanese Industrial Standard B7
* PageMediaSizeName.JISB8 Japanese Industrial Standard B8
* PageMediaSizeName.JISB9 Japanese Industrial Standard B9
* PageMediaSizeName.NorthAmerica10x11 10 x 11
* PageMediaSizeName.NorthAmerica10x12 10 x 12
* PageMediaSizeName.NorthAmerica10x14 10 x 14
* PageMediaSizeName.NorthAmerica11x17 11 x 17
* PageMediaSizeName.NorthAmerica14x17 14 x 17
* PageMediaSizeName.NorthAmerica4x6 4 x 6
* PageMediaSizeName.NorthAmerica4x8 4 x 8
* PageMediaSizeName.NorthAmerica5x7 5 x 7
* PageMediaSizeName.NorthAmerica8x10 8 x 10
* PageMediaSizeName.NorthAmerica9x11 9 x 11
* PageMediaSizeName.NorthAmericaArchitectureASheet Architecture A Sheet
* PageMediaSizeName.NorthAmericaArchitectureBSheet Architecture B Sheet
* PageMediaSizeName.NorthAmericaArchitectureCSheet Architecture C Sheet
* PageMediaSizeName.NorthAmericaArchitectureDSheet Architecture D Sheet
* PageMediaSizeName.NorthAmericaArchitectureESheet Architecture E Sheet
* PageMediaSizeName.NorthAmericaCSheet C Sheet
* PageMediaSizeName.NorthAmericaDSheet D Sheet
* PageMediaSizeName.NorthAmericaESheet E Sheet
* PageMediaSizeName.NorthAmericaExecutive Executive
* PageMediaSizeName.NorthAmericaGermanLegalFanfold German Legal Fanfold
* PageMediaSizeName.NorthAmericaGermanStandardFanfold German Standard Fanfold
* PageMediaSizeName.NorthAmericaLegal Legal
* PageMediaSizeName.NorthAmericaLegalExtra Legal Extra
* PageMediaSizeName.NorthAmericaLetter Letter
* PageMediaSizeName.NorthAmericaLetterExtra Letter Extra
* PageMediaSizeName.NorthAmericaLetterPlus Letter Plus
* PageMediaSizeName.NorthAmericaLetterRotated Letter Rotated
* PageMediaSizeName.NorthAmericaMonarchEnvelope Monarch Envelope
* PageMediaSizeName.NorthAmericaNote Note
* PageMediaSizeName.NorthAmericaNumber10Envelope #10 Envelope
* PageMediaSizeName.NorthAmericaNumber10EnvelopeRotated #10 Envelope Rotated
* PageMediaSizeName.NorthAmericaNumber11Envelope #11 Envelope
* PageMediaSizeName.NorthAmericaNumber12Envelope #12 Envelope
* PageMediaSizeName.NorthAmericaNumber14Envelope #14 Envelope
* PageMediaSizeName.NorthAmericaNumber9Envelope #9 Envelope
* PageMediaSizeName.NorthAmericaPersonalEnvelope Personal Envelope
* PageMediaSizeName.NorthAmericaQuarto Quarto
* PageMediaSizeName.NorthAmericaStatement Statement
* PageMediaSizeName.NorthAmericaSuperA Super A
* PageMediaSizeName.NorthAmericaSuperB Super B
* PageMediaSizeName.NorthAmericaTabloid Tabloid
* PageMediaSizeName.NorthAmericaTabloidExtra Tabloid Extra
* PageMediaSizeName.OtherMetricA3Plus A3 Plus
* PageMediaSizeName.OtherMetricA4Plus A4 Plus
* PageMediaSizeName.OtherMetricFolio Folio
* PageMediaSizeName.OtherMetricInviteEnvelope Invite Envelope
* PageMediaSizeName.OtherMetricItalianEnvelope Italian Envelope
* PageMediaSizeName.PRC10Envelope People's Republic of China #10 Envelope
* PageMediaSizeName.PRC10EnvelopeRotated People's Republic of China #10 Envelope Rotated
* PageMediaSizeName.PRC16K People's Republic of China 16K
* PageMediaSizeName.PRC16KRotated People's Republic of China 16K Rotated
* PageMediaSizeName.PRC1Envelope People's Republic of China #1 Envelope
* PageMediaSizeName.PRC1EnvelopeRotated People's Republic of China #1 Envelope Rotated
* PageMediaSizeName.PRC2Envelope People's Republic of China #2 Envelope
* PageMediaSizeName.PRC2EnvelopeRotated People's Republic of China #2 Envelope Rotated
* PageMediaSizeName.PRC32K People's Republic of China 32K
* PageMediaSizeName.PRC32KBig People's Republic of China 32K Big
* PageMediaSizeName.PRC32KRotated People's Republic of China 32K Rotated
* PageMediaSizeName.PRC3Envelope People's Republic of China #3 Envelope
* PageMediaSizeName.PRC3EnvelopeRotated People's Republic of China #3 Envelope Rotated
* PageMediaSizeName.PRC4Envelope People's Republic of China #4 Envelope
* PageMediaSizeName.PRC4EnvelopeRotated People's Republic of China #4 Envelope Rotated
* PageMediaSizeName.PRC5Envelope People's Republic of China #5 Envelope
* PageMediaSizeName.PRC5EnvelopeRotated People's Republic of China #5 Envelope Rotated
* PageMediaSizeName.PRC6Envelope People's Republic of China #6 Envelope
* PageMediaSizeName.PRC6EnvelopeRotated People's Republic of China #6 Envelope Rotated
* PageMediaSizeName.PRC7Envelope People's Republic of China #7 Envelope
* PageMediaSizeName.PRC7EnvelopeRotated People's Republic of China #7 Envelope Rotated
* PageMediaSizeName.PRC8Envelope People's Republic of China #8 Envelope
* PageMediaSizeName.PRC8EnvelopeRotated People's Republic of China #8 Envelope Rotated
* PageMediaSizeName.PRC9Envelope People's Republic of China #9 Envelope
* PageMediaSizeName.PRC9EnvelopeRotated People's Republic of China #9 Envelope Rotated
* PageMediaSizeName.Roll04Inch 4-inch wide roll
* PageMediaSizeName.Roll06Inch 6-inch wide roll
* PageMediaSizeName.Roll08Inch 8-inch wide roll
* PageMediaSizeName.Roll12Inch 12-inch wide roll
* PageMediaSizeName.Roll15Inch 15-inch wide roll
* PageMediaSizeName.Roll18Inch 18-inch wide roll
* PageMediaSizeName.Roll22Inch 22-inch wide roll
* PageMediaSizeName.Roll24Inch 24-inch wide roll
* PageMediaSizeName.Roll30Inch 30-inch wide roll
* PageMediaSizeName.Roll36Inch 36-inch wide roll
* PageMediaSizeName.Roll54Inch 54-inch wide roll
*/
private void InitializePaperSizeGallery()
{
this.paperSizeGallery.Gallery.BeginUpdate();
try {
GalleryItem defaultItem = this.paperSizeGallery.Gallery.GetCheckedItem();
PageMediaSize defaultSize = defaultItem == null ? PicturePrint.PrintTicket.PageMediaSize : (PageMediaSize)defaultItem.Value;
this.paperSizeGallery.Gallery.Groups[0].Items.Clear();
PrintCapabilities caps = PicturePrint.PrintQueue.GetPrintCapabilities();
foreach (PageMediaSize size in caps.PageMediaSizeCapability)
{
GalleryItem item = CreatePageMediaSizeItem(size);
this.paperSizeGallery.Gallery.Groups[0].Items.Add(item);
if (defaultSize.PageMediaSizeName.HasValue && defaultSize.PageMediaSizeName.Value == ((PageMediaSize)item.Value).PageMediaSizeName)
{
defaultItem = item;
}
}
if (defaultItem == null && this.paperSizeGallery.Gallery.Groups[0].Items.Count > 0)
{
defaultItem = this.paperSizeGallery.Gallery.Groups[0].Items[0];
}
if (defaultItem != null)
{
defaultItem.Checked = true;
}
} finally {
this.paperSizeGallery.Gallery.EndUpdate();
}
}
/// <summary>
/// Создаю документ на основе карточек и настроек принтера
/// </summary>
/// <param name="cards"></param>
/// <param name="dlg"></param>
public CustomDocumentPaginator(List <Card> cards, PrintDialog dlg)
{
_cards = cards;
PageCount = (int)Math.Ceiling((decimal)(_cards.Count / 2));
_printCapabilities = dlg.PrintQueue.GetPrintCapabilities(dlg.PrintTicket);
SetA4Size();
}
/// <summary>
/// Отличается тем, что сразу ставит прогружаться кучу контролов.
/// Ест больше, зато быстрее
/// </summary>
/// <param name="cards"></param>
/// <param name="dlg"></param>
public FastCardPrinter(List <Card> cards, PrintDialog dlg)
{
_cards = cards;
_count = (int)Math.Ceiling((decimal)(_cards.Count / 2));
_printCapabilities = dlg.PrintQueue.GetPrintCapabilities(dlg.PrintTicket);
_pageSize = new Size((double)_printCapabilities.OrientedPageMediaWidth,
(double)_printCapabilities.OrientedPageMediaHeight);
}
//****************************************************************************************
// Construction
//****************************************************************************************
/// <summary>
/// Constructor for printing
/// </summary>
/// <param name="printQueue"></param>
/// <param name="printTicket"></param>
public WpfPrint(PrintQueue printQueue, PrintTicket printTicket)
{
PrintCapabilities capabilities = printQueue.GetPrintCapabilities(printTicket);
Size sz = new Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
_fixedDocument = new FixedDocument();
_fixedDocument.DocumentPaginator.PageSize = sz;
StartPage();
}
private void Print_Click(object sender, RoutedEventArgs e)
{
PrintDialog prnt = new PrintDialog();
prnt.UserPageRangeEnabled = true;
prnt.MaxPage = (uint)data.pages.Count;
prnt.MinPage = 1;
if (prnt.ShowDialog() == true)
{
if (CB_OutPutColor.SelectedIndex > 0)
{
prnt.PrintTicket.OutputColor = (OutputColor)(CB_OutPutColor.SelectedIndex);
}
if (CB_Orientation.SelectedIndex > 0)
{
prnt.PrintTicket.PageOrientation = (PageOrientation)(CB_Orientation.SelectedIndex);
}
FixedDocument document = new FixedDocument();
PrintCapabilities capabilities = prnt.PrintQueue.GetPrintCapabilities(prnt.PrintTicket);
Size visibleSize = new Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
Size Margins = new Size(capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight);
if (SB_Fit.IsChecked())
{
document.DocumentPaginator.PageSize = new Size(prnt.PrintableAreaWidth, prnt.PrintableAreaHeight);
}
else
{
document.DocumentPaginator.PageSize = new Size(data.CanvasW, data.CanvasH);
}
Debug.WriteLine("Page Range: From: " + prnt.PageRange.PageFrom + " To: " + prnt.PageRange.PageTo);
if (prnt.PageRange.PageTo < 1)
{
for (int i = 0; i < data.pages.Count; i++)
{
PrintAddPage(i, document, visibleSize, Margins);
}
}
else
{
for (int i = (prnt.PageRange.PageFrom - 1); i < prnt.PageRange.PageTo; i++)
{
PrintAddPage(i, document, visibleSize, Margins);
}
}
prnt.PrintDocument(document.DocumentPaginator, "Good Teacher");
}
}
UpdatePrintableAreaSize(
)
{
PrintQueue printQueue = null;
PrintTicket printTicket = null;
PickCorrectPrintingEnvironment(ref printQueue, ref printTicket);
PrintCapabilities printCap = null;
if (printQueue != null)
{
printCap = printQueue.GetPrintCapabilities(printTicket);
}
// PrintCapabilities OrientedPageMediaWidth/Height are Nullable
if ((printCap != null) &&
(printCap.OrientedPageMediaWidth != null) &&
(printCap.OrientedPageMediaHeight != null))
{
_printableAreaWidth = (double)printCap.OrientedPageMediaWidth;
_printableAreaHeight = (double)printCap.OrientedPageMediaHeight;
}
else
{
// Initialize page size to portrait Letter size.
// This is our fallback if PrintTicket doesn't specify the page size.
_printableAreaWidth = 816;
_printableAreaHeight = 1056;
// PrintTicket's PageMediaSize could be null and PageMediaSize Width/Height are Nullable
if ((printTicket.PageMediaSize != null) &&
(printTicket.PageMediaSize.Width != null) &&
(printTicket.PageMediaSize.Height != null))
{
_printableAreaWidth = (double)printTicket.PageMediaSize.Width;
_printableAreaHeight = (double)printTicket.PageMediaSize.Height;
}
// If we are using PrintTicket's PageMediaSize dimensions to populate the widht/height values,
// we need to adjust them based on current orientation. PrintTicket's PageOrientation is Nullable.
if (printTicket.PageOrientation != null)
{
PageOrientation orientation = (PageOrientation)printTicket.PageOrientation;
// need to swap width/height in landscape orientation
if ((orientation == PageOrientation.Landscape) ||
(orientation == PageOrientation.ReverseLandscape))
{
double t = _printableAreaWidth;
_printableAreaWidth = _printableAreaHeight;
_printableAreaHeight = t;
}
}
}
}
public static PrintDialog DefaultPrintAdjustments()
{
PrintQueue printQueue = new LocalPrintServer().DefaultPrintQueue;
m_printCapabilities = printQueue.GetPrintCapabilities();
m_printDialog.PrintQueue = printQueue;
PrintDialog PrintDialog = AdjustPrinterCapabilities();
return(m_printDialog);
}
private void PrintPage()
{
PrintDialog printDialog = new PrintDialog();
if ((bool)printDialog.ShowDialog().GetValueOrDefault())
{
PrintCapabilities capabilities = printDialog.PrintQueue.GetPrintCapabilities(printDialog.PrintTicket);
printDialog.PrintVisual(this.PrintLayoutPage, "Test");
}
}
private static void ResetVisualState(ContentPresenter objectToPrint, PrintCapabilities printCaps)
{
objectToPrint.Width = double.NaN;
objectToPrint.UpdateLayout();
objectToPrint.LayoutTransform = new ScaleTransform(1, 1);
Size size = new Size(printCaps.PageImageableArea.ExtentWidth,
printCaps.PageImageableArea.ExtentHeight);
objectToPrint.Measure(size);
objectToPrint.Arrange(new Rect(new Point(printCaps.PageImageableArea.OriginWidth,
printCaps.PageImageableArea.OriginHeight), size));
}
private static void ResetVisualState(ContentPresenter objectToPrint, PrintCapabilities printCaps)
{
objectToPrint.Width = double.NaN;
objectToPrint.UpdateLayout();
objectToPrint.LayoutTransform = new ScaleTransform(1, 1);
Size size = new Size(printCaps.PageImageableArea.ExtentWidth,
printCaps.PageImageableArea.ExtentHeight);
objectToPrint.Measure(size);
objectToPrint.Arrange(new Rect(new Point(printCaps.PageImageableArea.OriginWidth,
printCaps.PageImageableArea.OriginHeight), size));
}
public static void Print(this Panel panel)
{
PrintDialog printDialog = new PrintDialog();
if (printDialog.ShowDialog().GetValueOrDefault())
{
bool?proceed = true;
if (printDialog == null)
{
printDialog = new PrintDialog();
proceed = printDialog.ShowDialog();
}
if (proceed != true)
{
return;
}
PrintCapabilities capabilities = printDialog.PrintQueue.GetPrintCapabilities(printDialog.PrintTicket);
if (capabilities.PageImageableArea != null)
{
// scale the area to the smaller of width zoom or height zoom
double scale = Math.Min(capabilities.PageImageableArea.ExtentWidth / panel.ActualWidth,
capabilities.PageImageableArea.ExtentHeight / panel.ActualHeight);
// remember current values so we can restore later, then rescale
Transform oldTransform = panel.LayoutTransform;
Size oldSize = new Size(panel.ActualWidth, panel.ActualHeight);
panel.LayoutTransform = new ScaleTransform(scale, scale);
Size newSize = new Size(capabilities.PageImageableArea.ExtentWidth,
capabilities.PageImageableArea.ExtentHeight);
panel.Measure(newSize);
// might re-flow depending on the needs of the new size
panel.Arrange(
new Rect(
new Point(capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight),
newSize));
// do the work
printDialog.PrintVisual(panel, "Print Results");
// back to where we were
panel.LayoutTransform = oldTransform;
panel.Measure(oldSize);
panel.Arrange(new Rect(new Point(0, 0), oldSize));
}
}
}
private PrintTicket GetPrintTicketFromPrinter(Report_Template printerSettings)
{
PrintQueue printQueue = null;
LocalPrintServer localPrintServer = new LocalPrintServer();
// Retrieving collection of local printer on user machine
PrintQueueCollection localPrinterCollection =
localPrintServer.GetPrintQueues();
System.Collections.IEnumerator localPrinterEnumerator =
localPrinterCollection.GetEnumerator();
if (localPrinterEnumerator.MoveNext())
{
// Get PrintQueue from first available printer
printQueue = (PrintQueue)localPrinterEnumerator.Current;
MessageBox.Show(printQueue.Name);
}
else
{
// No printer exist, return null PrintTicket
return(null);
}
// Get default PrintTicket from printer
PrintTicket printTicket = printQueue.DefaultPrintTicket;
PrintCapabilities printCapabilites = printQueue.GetPrintCapabilities();
// Modify PrintTicket
if (printCapabilites.CollationCapability.Contains(Collation.Collated))
{
printTicket.Collation = Collation.Collated;
}
if (printCapabilites.DuplexingCapability.Contains(
Duplexing.TwoSidedLongEdge))
{
printTicket.Duplexing = Duplexing.TwoSidedLongEdge;
}
if (printCapabilites.StaplingCapability.Contains(Stapling.StapleDualLeft))
{
printTicket.Stapling = Stapling.StapleDualLeft;
}
printTicket.PageMediaSize = new PageMediaSize(PageMediaSizeName.JISB4);
printTicket.PageOrientation = PageOrientation.Unknown;
printTicket.Duplexing = Duplexing.TwoSidedShortEdge;
printTicket.PageResolution = new PageResolution(PageQualitativeResolution.Draft);
return(printTicket);
}// end:GetPrintTicketFromPrinter()
private void PrintButton_Click(object sender, RoutedEventArgs e)
{
// ChangePaperSize();
PrintDialog pd = new PrintDialog
{
PrintQueue = GetPrintQueue(printers.Text)
};
PrintTicket pt = pd.PrintTicket;
if (orientation.SelectedIndex == 0)
{
pt.PageOrientation = PageOrientation.Portrait;
}
else
{
pt.PageOrientation = PageOrientation.Landscape;
}
pt.PageBorderless = PageBorderless.Borderless;
// pt.PageMediaSize = new PageMediaSize(_pagewidth, _pageheight);
pd.PrintTicket = pt;
PrintCapabilities capabilities = pd.PrintQueue.GetPrintCapabilities(pd.PrintTicket);
const double inch = 96;
// Set the margins.
double xMargin = 0.75 * inch;
double yMargin = 0.75 * inch;
double printableWidth = pt.PageMediaSize.Width.Value;
double printableHeight = pt.PageMediaSize.Height.Value;
double xScale = (printableWidth - xMargin * 2) / printableWidth;
double yScale = (printableHeight - yMargin * 2) / printableHeight;
thedocument.Width = thedocument.Width * xScale;
thedocument.Height = thedocument.Height * yScale;
Size sz = new Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
//Size sz = new Size(thedocument.Width, thedocument.Height);
//if (papersize.Text == "A4")
// sz = new Size(A4Width, A4Height);
//else
// sz = new Size(LetterWidth, LetterHeight);
//update the layout of the visual to the printer page size.
thedocument.Measure(sz);
thedocument.Arrange(new Rect(new Point(capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight), sz));
pd.PrintVisual(thedocument, "Printing...");
//apply the original transform.
ChangePaperSize();
}
public static FixedDocument GetFixedDocument(FrameworkElement toPrint, PrintDialog printDialog)
{
PrintCapabilities capabilities = printDialog.PrintQueue.GetPrintCapabilities(printDialog.PrintTicket);
System.Windows.Size pageSize = new System.Windows.Size(printDialog.PrintableAreaWidth, printDialog.PrintableAreaHeight);
System.Windows.Size visibleSize = new System.Windows.Size((int)capabilities.PageImageableArea.ExtentWidth, (int)capabilities.PageImageableArea.ExtentHeight);
FixedDocument fixedDoc = new FixedDocument();
//If the toPrint visual is not displayed on screen we neeed to measure and arrange it
toPrint.Measure(new System.Windows.Size(double.PositiveInfinity, double.PositiveInfinity));
toPrint.Arrange(new Rect(new System.Windows.Point(0, 0), toPrint.DesiredSize));
//
System.Windows.Size size = toPrint.DesiredSize;
//Will assume for simplicity the control fits horizontally on the page
double yOffset = 0;
double xOffset = 0;
while (yOffset < size.Height)
{
while (xOffset < size.Width)
{
VisualBrush vb = new VisualBrush(toPrint);
vb.Stretch = Stretch.None;
vb.AlignmentX = AlignmentX.Left;
vb.AlignmentY = AlignmentY.Top;
vb.ViewboxUnits = BrushMappingMode.Absolute;
vb.TileMode = TileMode.None;
vb.Viewbox = new Rect(xOffset, yOffset, visibleSize.Width, visibleSize.Height);
PageContent pageContent = new PageContent();
FixedPage page = new FixedPage();
((IAddChild)pageContent).AddChild(page);
fixedDoc.Pages.Add(pageContent);
page.Width = pageSize.Width;
page.Height = pageSize.Height;
Canvas canvas = new Canvas();
FixedPage.SetLeft(canvas, capabilities.PageImageableArea.OriginWidth);
FixedPage.SetTop(canvas, capabilities.PageImageableArea.OriginHeight);
canvas.Width = visibleSize.Width;
canvas.Height = visibleSize.Height;
canvas.Background = vb;
page.Children.Add(canvas);
xOffset += visibleSize.Width;
}
xOffset = 0;
yOffset += visibleSize.Height;
}
return(fixedDoc);
}
private void InitializeMediaTypeCombo()
{
this.cbMediaType.Properties.Items.BeginUpdate();
this.cbMediaType.Properties.Items.Clear();
try {
PrintCapabilities caps = PicturePrint.PrintQueue.GetPrintCapabilities();
foreach (PageMediaType type in caps.PageMediaTypeCapability)
{
this.cbMediaType.Properties.Items.Add(type);
}
} finally {
this.cbMediaType.Properties.Items.EndUpdate();
this.cbMediaType.EditValue = PicturePrint.PrintTicket.PageMediaType.HasValue ? (object)PicturePrint.PrintTicket.PageMediaType.Value : null;
}
}
}// end:AddPageResources()
//</SnippetXpsCreateAddPageResources>
//<SnippetPrinterCapabilities>
// ---------------------- GetPrintTicketFromPrinter -----------------------
/// <summary>
/// Returns a PrintTicket based on the current default printer.</summary>
/// <returns>
/// A PrintTicket for the current local default printer.</returns>
private PrintTicket GetPrintTicketFromPrinter()
{
PrintQueue printQueue = null;
LocalPrintServer localPrintServer = new LocalPrintServer();
// Retrieving collection of local printer on user machine
PrintQueueCollection localPrinterCollection =
localPrintServer.GetPrintQueues();
System.Collections.IEnumerator localPrinterEnumerator =
localPrinterCollection.GetEnumerator();
if (localPrinterEnumerator.MoveNext())
{
// Get PrintQueue from first available printer
printQueue = (PrintQueue)localPrinterEnumerator.Current;
}
else
{
// No printer exist, return null PrintTicket
return(null);
}
// Get default PrintTicket from printer
PrintTicket printTicket = printQueue.DefaultPrintTicket;
PrintCapabilities printCapabilities = printQueue.GetPrintCapabilities();
// Modify PrintTicket
if (printCapabilities.CollationCapability.Contains(Collation.Collated))
{
printTicket.Collation = Collation.Collated;
}
if (printCapabilities.DuplexingCapability.Contains(
Duplexing.TwoSidedLongEdge))
{
printTicket.Duplexing = Duplexing.TwoSidedLongEdge;
}
if (printCapabilities.StaplingCapability.Contains(Stapling.StapleDualLeft))
{
printTicket.Stapling = Stapling.StapleDualLeft;
}
return(printTicket);
}// end:GetPrintTicketFromPrinter()
private void OnPrint(object sender, RoutedEventArgs e)
{
var dlg = new PrintDialog();
if (dlg.ShowDialog() == true)
{
dlg.PrintVisual(canvas1, "Print Demo");
}
// PrintServer printServer = new PrintServer(@"\\treslunas\laserjet");
var printServer = new LocalPrintServer();
PrintQueue queue = printServer.DefaultPrintQueue;
PrintTicket ticket = queue.DefaultPrintTicket;
PrintCapabilities capabilities = queue.GetPrintCapabilities(ticket);
if (capabilities.DuplexingCapability.Contains(Duplexing.TwoSidedLongEdge))
{
ticket.Duplexing = Duplexing.TwoSidedLongEdge;
}
if (capabilities.InputBinCapability.Contains(InputBin.AutoSelect))
{
ticket.InputBin = InputBin.AutoSelect;
}
if (capabilities.MaxCopyCount > 3)
{
ticket.CopyCount = 3;
}
if (capabilities.PageOrientationCapability.Contains(PageOrientation.Landscape))
{
ticket.PageOrientation = PageOrientation.Landscape;
}
if (capabilities.PagesPerSheetCapability.Contains(2))
{
ticket.PagesPerSheet = 2;
}
if (capabilities.StaplingCapability.Contains(Stapling.StapleBottomLeft))
{
ticket.Stapling = Stapling.StapleBottomLeft;
}
XpsDocumentWriter writer = PrintQueue.CreateXpsDocumentWriter(queue);
writer.Write(canvas1, ticket);
}
private static void ResetVisualState(ContentPresenter objectToPrint, PrintCapabilities printCaps, bool wasVirtualized)
{
objectToPrint.Width = double.NaN;
objectToPrint.UpdateLayout();
objectToPrint.LayoutTransform = new ScaleTransform(1, 1);
Size size = new Size(printCaps.PageImageableArea.ExtentWidth,
printCaps.PageImageableArea.ExtentHeight);
objectToPrint.Measure(size);
objectToPrint.Arrange(new Rect(new Point(printCaps.PageImageableArea.OriginWidth,
printCaps.PageImageableArea.OriginHeight), size));
if (!wasVirtualized) return;
var dg = objectToPrint.FindChild<DataGrid>();
dg.EnableRowVirtualization = true;
dg.EnableColumnVirtualization = true;
VirtualizingPanel.SetIsVirtualizing(dg, true);
}
