616 lines
30 KiB
C#
616 lines
30 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Drawing;
|
|
using System.Diagnostics;
|
|
using System.Resources;
|
|
using System.Collections;
|
|
using System.Windows.Forms;
|
|
using System.Globalization;
|
|
using System.ComponentModel;
|
|
using System.Drawing.Imaging;
|
|
using System.Drawing.Printing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Workflow.Interop;
|
|
using Microsoft.Win32;
|
|
|
|
namespace System.Workflow.ComponentModel.Design
|
|
{
|
|
#region Class WorkflowPrintDocument
|
|
// What did I do in this file:
|
|
/// 1. Eliminated the synching of events OnBeginPrint and OnPrintPage as these can be overridden
|
|
/// 2. Eliminated member variable firstpage as this can be deduced from the currentpage variable
|
|
/// 3. Reorganized all the functions and bunched relavant functions togather
|
|
/// 4. Eliminated the PageSetupDataChanged event.
|
|
/// 5. Initialized all the member variables appropriately.
|
|
/// 6. Eliminated unused functions and properties
|
|
|
|
[ToolboxItem(false)]
|
|
internal sealed class WorkflowPrintDocument : PrintDocument
|
|
{
|
|
#region Members and Constructor
|
|
private WorkflowView workflowView = null;
|
|
private PageSetupData pageSetupData = null;
|
|
private PrintPreviewLayout previewLayout = null;
|
|
|
|
//These are the temporary variables we calculate in PrepareToPrint
|
|
private Point totalPrintablePages = Point.Empty; //number of pages in x and y
|
|
private Point currentPrintablePage = Point.Empty; //page number (in the grid x,y)) we are printing right now
|
|
private Point workflowAlignment = Point.Empty; //amount of alignment translation
|
|
private float scaling; //1.0f is 100%
|
|
private DateTime printTime; //when the document started to print
|
|
private const int MaxHeaderFooterLines = 5; //maximum number of lines in header/footer
|
|
|
|
public WorkflowPrintDocument(WorkflowView workflowView)//, IServiceProvider serviceProvider)
|
|
{
|
|
//this.serviceProvider = serviceProvider;
|
|
this.pageSetupData = new PageSetupData();
|
|
this.workflowView = workflowView;
|
|
this.previewLayout = new PrintPreviewLayout(this.workflowView, this);
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
try
|
|
{
|
|
if (disposing)
|
|
{
|
|
if (this.previewLayout != null)
|
|
{
|
|
this.previewLayout.Dispose();
|
|
this.previewLayout = null;
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
base.Dispose(disposing);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Properties and Methods
|
|
internal PrintPreviewLayout PrintPreviewLayout
|
|
{
|
|
get
|
|
{
|
|
return this.previewLayout;
|
|
}
|
|
}
|
|
|
|
internal PageSetupData PageSetupData
|
|
{
|
|
get
|
|
{
|
|
return this.pageSetupData;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Events and Overrides
|
|
protected override void OnBeginPrint(PrintEventArgs printArgs)
|
|
{
|
|
base.OnBeginPrint(printArgs);
|
|
|
|
this.currentPrintablePage = Point.Empty;
|
|
|
|
//Validate the printer
|
|
bool validPrinter = (PrinterSettings.IsValid &&
|
|
PrinterSettings.InstalledPrinters.Count > 0 &&
|
|
new ArrayList(PrinterSettings.InstalledPrinters).Contains(PrinterSettings.PrinterName));
|
|
if (!validPrinter)
|
|
DesignerHelpers.ShowError(this.workflowView, DR.GetString(DR.SelectedPrinterIsInvalidErrorMessage));
|
|
|
|
printArgs.Cancel = (!validPrinter || this.workflowView.RootDesigner == null);
|
|
}
|
|
|
|
protected override void OnPrintPage(PrintPageEventArgs printPageArg)
|
|
{
|
|
base.OnPrintPage(printPageArg);
|
|
|
|
AmbientTheme ambientTheme = WorkflowTheme.CurrentTheme.AmbientTheme;
|
|
|
|
Graphics graphics = printPageArg.Graphics;
|
|
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
|
|
graphics.SmoothingMode = SmoothingMode.HighQuality;
|
|
|
|
//STEP1: We get the printer graphics only in the OnPrintPage function hence for layouting we need to call this function
|
|
if (this.currentPrintablePage.IsEmpty)
|
|
PrepareToPrint(printPageArg);
|
|
|
|
//STEP2: GET ALL THE VALUES NEEDED FOR CALCULATION
|
|
Margins hardMargins = GetHardMargins(graphics);
|
|
Margins margins = new Margins(Math.Max(printPageArg.PageSettings.Margins.Left, hardMargins.Left),
|
|
Math.Max(printPageArg.PageSettings.Margins.Right, hardMargins.Right),
|
|
Math.Max(printPageArg.PageSettings.Margins.Top, hardMargins.Top),
|
|
Math.Max(printPageArg.PageSettings.Margins.Bottom, hardMargins.Bottom));
|
|
Size printableArea = new Size(printPageArg.PageBounds.Size.Width - (margins.Left + margins.Right), printPageArg.PageBounds.Size.Height - (margins.Top + margins.Bottom));
|
|
Rectangle boundingRectangle = new Rectangle(margins.Left, margins.Top, printableArea.Width, printableArea.Height);
|
|
Region clipRegion = new Region(boundingRectangle);
|
|
|
|
try
|
|
{
|
|
graphics.TranslateTransform(-hardMargins.Left, -hardMargins.Top);
|
|
graphics.FillRectangle(ambientTheme.BackgroundBrush, boundingRectangle);
|
|
graphics.DrawRectangle(ambientTheme.ForegroundPen, boundingRectangle);
|
|
|
|
//Draw the watermark image
|
|
if (ambientTheme.WorkflowWatermarkImage != null)
|
|
ActivityDesignerPaint.DrawImage(graphics, ambientTheme.WorkflowWatermarkImage, boundingRectangle, new Rectangle(Point.Empty, ambientTheme.WorkflowWatermarkImage.Size), ambientTheme.WatermarkAlignment, AmbientTheme.WatermarkTransparency, false);
|
|
|
|
Matrix oldTransform = graphics.Transform;
|
|
Region oldClipRegion = graphics.Clip;
|
|
graphics.Clip = clipRegion;
|
|
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
|
|
|
|
//STEP3: PRINT
|
|
//Printer bitmap starts at the unprintable top left corner, hence, need to take it into account - move by the unprintable area:
|
|
//Setup the translation and scaling for the page printing
|
|
Point pageOffset = new Point(this.currentPrintablePage.X * printableArea.Width - this.workflowAlignment.X, this.currentPrintablePage.Y * printableArea.Height - this.workflowAlignment.Y);
|
|
graphics.TranslateTransform(boundingRectangle.Left - pageOffset.X, boundingRectangle.Top - pageOffset.Y);
|
|
graphics.ScaleTransform(this.scaling, this.scaling);
|
|
|
|
//Calculate the viewport by reverse scaling the printable area size
|
|
Size viewPortSize = Size.Empty;
|
|
viewPortSize.Width = Convert.ToInt32(Math.Ceiling((float)printableArea.Width / this.scaling));
|
|
viewPortSize.Height = Convert.ToInt32(Math.Ceiling((float)printableArea.Height / this.scaling));
|
|
|
|
Point scaledAlignment = Point.Empty;
|
|
scaledAlignment.X = Convert.ToInt32(Math.Ceiling((float)this.workflowAlignment.X / this.scaling));
|
|
scaledAlignment.Y = Convert.ToInt32(Math.Ceiling((float)this.workflowAlignment.Y / this.scaling));
|
|
|
|
Rectangle viewPort = new Rectangle(this.currentPrintablePage.X * viewPortSize.Width - scaledAlignment.X, this.currentPrintablePage.Y * viewPortSize.Height - scaledAlignment.Y, viewPortSize.Width, viewPortSize.Height);
|
|
|
|
using (PaintEventArgs paintEventArgs = new PaintEventArgs(graphics, this.workflowView.RootDesigner.Bounds))
|
|
{
|
|
((IWorkflowDesignerMessageSink)this.workflowView.RootDesigner).OnPaint(paintEventArgs, viewPort);
|
|
}
|
|
|
|
graphics.Clip = oldClipRegion;
|
|
graphics.Transform = oldTransform;
|
|
|
|
//Now prepare the graphics for header footer printing
|
|
HeaderFooterData headerFooterData = new HeaderFooterData();
|
|
headerFooterData.Font = ambientTheme.Font;
|
|
headerFooterData.PageBounds = printPageArg.PageBounds;
|
|
headerFooterData.PageBoundsWithoutMargin = boundingRectangle;
|
|
headerFooterData.HeaderFooterMargins = new Margins(0, 0, this.pageSetupData.HeaderMargin, this.pageSetupData.FooterMargin);
|
|
headerFooterData.PrintTime = this.printTime;
|
|
headerFooterData.CurrentPage = this.currentPrintablePage.X + this.currentPrintablePage.Y * this.totalPrintablePages.X + 1;
|
|
headerFooterData.TotalPages = this.totalPrintablePages.X * this.totalPrintablePages.Y;
|
|
headerFooterData.Scaling = this.scaling;
|
|
WorkflowDesignerLoader serviceDesignerLoader = ((IServiceProvider)this.workflowView).GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader;
|
|
headerFooterData.FileName = (serviceDesignerLoader != null) ? serviceDesignerLoader.FileName : String.Empty;
|
|
|
|
//Print the header
|
|
if (this.pageSetupData.HeaderTemplate.Length > 0)
|
|
PrintHeaderFooter(graphics, true, headerFooterData);
|
|
|
|
//footer
|
|
if (this.pageSetupData.FooterTemplate.Length > 0)
|
|
PrintHeaderFooter(graphics, false, headerFooterData);
|
|
|
|
//are there more pages left?
|
|
printPageArg.HasMorePages = MoveNextPage();
|
|
}
|
|
catch (Exception exception)
|
|
{
|
|
DesignerHelpers.ShowError(this.workflowView, DR.GetString(DR.SelectedPrinterIsInvalidErrorMessage) + "\n" + exception.Message);
|
|
printPageArg.Cancel = true;
|
|
printPageArg.HasMorePages = false;
|
|
}
|
|
finally
|
|
{
|
|
clipRegion.Dispose();
|
|
}
|
|
|
|
if (!printPageArg.HasMorePages)
|
|
this.workflowView.PerformLayout(); //no more pages - redo regular layout using screen graphics
|
|
}
|
|
#endregion
|
|
|
|
#region Helpers
|
|
//Hard margins is part of the area the printer absolutely can not print onto.
|
|
//This area changes from printer to printer; CreateMeasurementGraphics creates appropriate DC
|
|
//for the selected printer
|
|
internal Margins GetHardMargins(Graphics graphics)
|
|
{
|
|
IntPtr hDC = graphics.GetHdc();
|
|
|
|
//Printer unit is hudredth of an inch hence convert the unprintable area from DPI to DPHI
|
|
Point dpi = new Point(Math.Max(NativeMethods.GetDeviceCaps(hDC, NativeMethods.LOGPIXELSX), 1), Math.Max(NativeMethods.GetDeviceCaps(hDC, NativeMethods.LOGPIXELSY), 1));
|
|
|
|
int printAreaHorz = (int)((float)NativeMethods.GetDeviceCaps(hDC, NativeMethods.HORZRES) * 100.0f / (float)dpi.X);
|
|
int printAreaVert = (int)((float)NativeMethods.GetDeviceCaps(hDC, NativeMethods.VERTRES) * 100.0f / (float)dpi.Y);
|
|
|
|
int physicalWidth = (int)((float)NativeMethods.GetDeviceCaps(hDC, NativeMethods.PHYSICALWIDTH) * 100.0f / (float)dpi.X);
|
|
int physicalHeight = (int)((float)NativeMethods.GetDeviceCaps(hDC, NativeMethods.PHYSICALHEIGHT) * 100.0f / (float)dpi.Y);
|
|
|
|
//margins in 1/100 inches
|
|
int leftMargin = (int)((float)NativeMethods.GetDeviceCaps(hDC, NativeMethods.PHYSICALOFFSETX) * 100.0f / (float)dpi.X);
|
|
int topMargin = (int)((float)NativeMethods.GetDeviceCaps(hDC, NativeMethods.PHYSICALOFFSETY) * 100.0f / (float)dpi.Y);
|
|
int rightMargin = physicalWidth - printAreaHorz - leftMargin;
|
|
int bottomMargin = physicalHeight - printAreaVert - topMargin;
|
|
|
|
graphics.ReleaseHdc(hDC);
|
|
|
|
return new Margins(leftMargin, rightMargin, topMargin, bottomMargin);
|
|
}
|
|
|
|
internal void PrintHeaderFooter(Graphics graphics, bool drawHeader, HeaderFooterData headerFooterPrintData)
|
|
{
|
|
//Format the header/footer
|
|
string headerFooter = (drawHeader) ? this.pageSetupData.HeaderTemplate : this.pageSetupData.FooterTemplate;
|
|
|
|
//these are the new format strings
|
|
headerFooter = headerFooter.Replace("{#}", headerFooterPrintData.CurrentPage.ToString(CultureInfo.CurrentCulture));
|
|
headerFooter = headerFooter.Replace("{##}", headerFooterPrintData.TotalPages.ToString(CultureInfo.CurrentCulture));
|
|
headerFooter = headerFooter.Replace("{Date}", headerFooterPrintData.PrintTime.ToShortDateString());
|
|
headerFooter = headerFooter.Replace("{Time}", headerFooterPrintData.PrintTime.ToShortTimeString());
|
|
headerFooter = headerFooter.Replace("{FullFileName}", headerFooterPrintData.FileName);
|
|
headerFooter = headerFooter.Replace("{FileName}", Path.GetFileName(headerFooterPrintData.FileName));
|
|
headerFooter = headerFooter.Replace("{User}", SystemInformation.UserName);
|
|
|
|
//limit the string to 5 lines of text max
|
|
string[] headerFooterLines = headerFooter.Split(new char[] { '\n', '\r' }, MaxHeaderFooterLines + 1, StringSplitOptions.RemoveEmptyEntries);
|
|
System.Text.StringBuilder text = new System.Text.StringBuilder();
|
|
for (int i = 0; i < Math.Min(headerFooterLines.Length, MaxHeaderFooterLines); i++)
|
|
{
|
|
text.Append(headerFooterLines[i]);
|
|
text.Append("\r\n");
|
|
}
|
|
headerFooter = text.ToString();
|
|
|
|
//Measure the header /footer string
|
|
Rectangle layoutRectangle = Rectangle.Empty;
|
|
SizeF stringSize = graphics.MeasureString(headerFooter, headerFooterPrintData.Font);
|
|
layoutRectangle.Size = new Size(Convert.ToInt32(Math.Ceiling((stringSize.Width))), Convert.ToInt32(Math.Ceiling((stringSize.Height))));
|
|
layoutRectangle.Width = Math.Min(headerFooterPrintData.PageBoundsWithoutMargin.Width, layoutRectangle.Width);
|
|
|
|
HorizontalAlignment alignment = (drawHeader) ? this.pageSetupData.HeaderAlignment : this.pageSetupData.FooterAlignment;
|
|
StringFormat stringFormat = new StringFormat();
|
|
stringFormat.Trimming = StringTrimming.EllipsisCharacter;
|
|
switch (alignment)
|
|
{
|
|
case HorizontalAlignment.Left:
|
|
layoutRectangle.X = headerFooterPrintData.PageBoundsWithoutMargin.Left;
|
|
stringFormat.Alignment = StringAlignment.Near;
|
|
break;
|
|
|
|
case HorizontalAlignment.Center:
|
|
layoutRectangle.X = headerFooterPrintData.PageBoundsWithoutMargin.Left + ((headerFooterPrintData.PageBoundsWithoutMargin.Width - layoutRectangle.Width) / 2); //align to the middle
|
|
stringFormat.Alignment = StringAlignment.Center;
|
|
break;
|
|
|
|
case HorizontalAlignment.Right:
|
|
layoutRectangle.X = headerFooterPrintData.PageBoundsWithoutMargin.Left + (headerFooterPrintData.PageBoundsWithoutMargin.Width - layoutRectangle.Width); //align to the right corner
|
|
stringFormat.Alignment = StringAlignment.Far;
|
|
break;
|
|
}
|
|
|
|
//Align header footer vertically
|
|
if (drawHeader)
|
|
{
|
|
layoutRectangle.Y = headerFooterPrintData.PageBounds.Top + headerFooterPrintData.HeaderFooterMargins.Top;
|
|
stringFormat.LineAlignment = StringAlignment.Near;
|
|
}
|
|
else
|
|
{
|
|
layoutRectangle.Y = headerFooterPrintData.PageBounds.Bottom - headerFooterPrintData.HeaderFooterMargins.Bottom - layoutRectangle.Size.Height;
|
|
stringFormat.LineAlignment = StringAlignment.Far;
|
|
}
|
|
|
|
//Draw header/footer string
|
|
graphics.DrawString(headerFooter, headerFooterPrintData.Font, WorkflowTheme.CurrentTheme.AmbientTheme.ForegroundBrush, layoutRectangle, stringFormat);
|
|
}
|
|
|
|
private void PrepareToPrint(PrintPageEventArgs printPageArg)
|
|
{
|
|
Graphics graphics = printPageArg.Graphics;
|
|
|
|
Size selectionSize = WorkflowTheme.CurrentTheme.AmbientTheme.SelectionSize;
|
|
((IWorkflowDesignerMessageSink)this.workflowView.RootDesigner).OnLayoutSize(graphics);
|
|
((IWorkflowDesignerMessageSink)this.workflowView.RootDesigner).OnLayoutPosition(graphics);
|
|
this.workflowView.RootDesigner.Location = Point.Empty;
|
|
|
|
//STEP2: Get the units needed for calculation
|
|
Size rootDesignerSize = this.workflowView.RootDesigner.Size;
|
|
rootDesignerSize.Width += 3 * selectionSize.Width;
|
|
rootDesignerSize.Height += 3 * selectionSize.Height;
|
|
|
|
Size paperSize = printPageArg.PageBounds.Size;
|
|
Margins hardMargins = GetHardMargins(graphics);
|
|
Margins margins = new Margins(Math.Max(printPageArg.PageSettings.Margins.Left, hardMargins.Left),
|
|
Math.Max(printPageArg.PageSettings.Margins.Right, hardMargins.Right),
|
|
Math.Max(printPageArg.PageSettings.Margins.Top, hardMargins.Top),
|
|
Math.Max(printPageArg.PageSettings.Margins.Bottom, hardMargins.Bottom));
|
|
Size printableArea = new Size(paperSize.Width - (margins.Left + margins.Right), paperSize.Height - (margins.Top + margins.Bottom));
|
|
printableArea.Width = Math.Max(printableArea.Width, 1);
|
|
printableArea.Height = Math.Max(printableArea.Height, 1);
|
|
|
|
//STEP3: Calculate the scaling
|
|
if (this.pageSetupData.AdjustToScaleFactor)
|
|
{
|
|
this.scaling = ((float)this.pageSetupData.ScaleFactor) / 100.0f;
|
|
}
|
|
else
|
|
{
|
|
float xScaling = (float)this.pageSetupData.PagesWide * (float)printableArea.Width / (float)rootDesignerSize.Width;
|
|
float YScaling = (float)this.pageSetupData.PagesTall * (float)printableArea.Height / (float)rootDesignerSize.Height;
|
|
|
|
this.scaling = Math.Min(xScaling, YScaling);
|
|
//leave just 3 digital points (also, that will remove potential problems with ceiling e.g. when the number of pages would be 3.00000000001 we'll get 4)
|
|
this.scaling = (float)(Math.Floor((double)this.scaling * 1000.0d) / 1000.0d);
|
|
}
|
|
|
|
//STEP4: Calculate the number of pages
|
|
this.totalPrintablePages.X = Convert.ToInt32(Math.Ceiling((this.scaling * (float)rootDesignerSize.Width) / (float)printableArea.Width));
|
|
this.totalPrintablePages.X = Math.Max(this.totalPrintablePages.X, 1);
|
|
this.totalPrintablePages.Y = Convert.ToInt32(Math.Ceiling((this.scaling * (float)rootDesignerSize.Height) / (float)printableArea.Height));
|
|
this.totalPrintablePages.Y = Math.Max(this.totalPrintablePages.Y, 1);
|
|
|
|
//STEP5: Calculate the workflow alignment
|
|
this.workflowAlignment = Point.Empty;
|
|
|
|
if (this.pageSetupData.CenterHorizontally)
|
|
this.workflowAlignment.X = (int)(((float)this.totalPrintablePages.X * (float)printableArea.Width / this.scaling - (float)rootDesignerSize.Width) / 2.0f * this.scaling);
|
|
|
|
if (this.pageSetupData.CenterVertically)
|
|
this.workflowAlignment.Y = (int)(((float)this.totalPrintablePages.Y * (float)printableArea.Height / this.scaling - (float)rootDesignerSize.Height) / 2.0f * this.scaling);
|
|
|
|
this.workflowAlignment.X = Math.Max(this.workflowAlignment.X, selectionSize.Width + selectionSize.Width / 2);
|
|
this.workflowAlignment.Y = Math.Max(this.workflowAlignment.Y, selectionSize.Height + selectionSize.Height / 2);
|
|
|
|
//STEP6: Store other variables used
|
|
this.printTime = DateTime.Now;
|
|
}
|
|
|
|
private bool MoveNextPage()
|
|
{
|
|
this.currentPrintablePage.X++;
|
|
if (this.currentPrintablePage.X < this.totalPrintablePages.X)
|
|
return true;
|
|
|
|
//move to the next row
|
|
this.currentPrintablePage.X = 0;
|
|
this.currentPrintablePage.Y++;
|
|
return (this.currentPrintablePage.Y < this.totalPrintablePages.Y);
|
|
}
|
|
|
|
internal sealed class HeaderFooterData
|
|
{
|
|
internal Font Font;
|
|
internal Rectangle PageBounds;
|
|
internal Rectangle PageBoundsWithoutMargin;
|
|
internal Margins HeaderFooterMargins;
|
|
internal DateTime PrintTime;
|
|
internal int CurrentPage;
|
|
internal int TotalPages;
|
|
internal float Scaling;
|
|
internal string FileName;
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
|
|
#region Class PageSetupData
|
|
internal sealed class PageSetupData
|
|
{
|
|
#region Members and Constructors
|
|
internal static readonly int DefaultScaleFactor = 100;
|
|
internal static readonly int DefaultMinScaleFactor = 10;
|
|
internal static readonly int DefaultMaxScaleFactor = 400;
|
|
internal static readonly int DefaultPages = 1;
|
|
internal static readonly int DefaultHeaderMargin = 50;
|
|
internal static readonly int DefaultFooterMargin = 50;
|
|
|
|
private Margins margins = null;
|
|
private bool landscape = false;
|
|
private int headerMargin = PageSetupData.DefaultHeaderMargin;
|
|
private int footerMargin = PageSetupData.DefaultFooterMargin;
|
|
private string headerTemplate = string.Empty;
|
|
private string footerTemplate = string.Empty;
|
|
private HorizontalAlignment headerAlignment = HorizontalAlignment.Center;
|
|
private HorizontalAlignment footerAlignment = HorizontalAlignment.Center;
|
|
private bool adjustToScaleFactor = true;
|
|
private int scaleFactor = PageSetupData.DefaultScaleFactor;
|
|
private int pagesWide = PageSetupData.DefaultPages;
|
|
private int pagesTall = PageSetupData.DefaultPages;
|
|
private bool centerHorizontally = false;
|
|
private bool centerVertically = false;
|
|
private bool headerCustom = false;
|
|
private bool footerCustom = false;
|
|
|
|
private static readonly string WinOEPrintingSubKey = DesignerHelpers.DesignerPerUserRegistryKey + "\\Printing";
|
|
private const string RegistryHeaderTemplate = "HeaderTemplate";
|
|
private const string RegistryHeaderMarging = "HeaderMargin";
|
|
private const string RegistryHeaderCustom = "HeaderCustom";
|
|
private const string RegistryHeaderAlignment = "HeaderAlignment";
|
|
private const string RegistryFooterTemplate = "FooterTemplate";
|
|
private const string RegistryFooterMarging = "FooterMargin";
|
|
private const string RegistryFooterCustom = "FooterCustom";
|
|
private const string RegistryFooterAlignment = "FooterAlignment";
|
|
private const string RegistryCenterHorizontally = "CenterHorizontally";
|
|
private const string RegistryCenterVertically = "CenterVertically";
|
|
|
|
internal PageSetupData()
|
|
{
|
|
RegistryKey key = Registry.CurrentUser.OpenSubKey(WinOEPrintingSubKey);
|
|
if (null != key)
|
|
{
|
|
try
|
|
{
|
|
object registryValue = null;
|
|
|
|
registryValue = key.GetValue(RegistryHeaderAlignment);
|
|
if (null != registryValue && registryValue is int) this.headerAlignment = (HorizontalAlignment)registryValue;
|
|
|
|
registryValue = key.GetValue(RegistryFooterAlignment);
|
|
if (null != registryValue && registryValue is int) this.footerAlignment = (HorizontalAlignment)registryValue;
|
|
|
|
registryValue = key.GetValue(RegistryHeaderMarging);
|
|
if (null != registryValue && registryValue is int) this.headerMargin = (int)registryValue;
|
|
|
|
registryValue = key.GetValue(RegistryFooterMarging);
|
|
if (null != registryValue && registryValue is int) this.footerMargin = (int)registryValue;
|
|
|
|
registryValue = key.GetValue(RegistryHeaderTemplate);
|
|
if (null != registryValue && registryValue is string) this.headerTemplate = (string)registryValue;
|
|
|
|
registryValue = key.GetValue(RegistryFooterTemplate);
|
|
if (null != registryValue && registryValue is string) this.footerTemplate = (string)registryValue;
|
|
|
|
registryValue = key.GetValue(RegistryHeaderCustom);
|
|
if (null != registryValue && registryValue is int) this.headerCustom = Convert.ToBoolean((int)registryValue);
|
|
|
|
registryValue = key.GetValue(RegistryFooterCustom);
|
|
if (null != registryValue && registryValue is int) this.footerCustom = Convert.ToBoolean((int)registryValue);
|
|
|
|
registryValue = key.GetValue(RegistryCenterHorizontally);
|
|
if (null != registryValue && registryValue is int) this.centerHorizontally = Convert.ToBoolean((int)registryValue);
|
|
|
|
registryValue = key.GetValue(RegistryCenterVertically);
|
|
if (null != registryValue && registryValue is int) this.centerVertically = Convert.ToBoolean((int)registryValue);
|
|
}
|
|
finally
|
|
{
|
|
key.Close();
|
|
}
|
|
}
|
|
|
|
PrinterSettings printerSettings = new PrinterSettings();
|
|
this.landscape = printerSettings.DefaultPageSettings.Landscape;
|
|
this.margins = printerSettings.DefaultPageSettings.Margins;
|
|
}
|
|
|
|
public void StorePropertiesToRegistry()
|
|
{
|
|
RegistryKey key = Registry.CurrentUser.CreateSubKey(WinOEPrintingSubKey);
|
|
if (null != key)
|
|
{
|
|
try
|
|
{
|
|
key.SetValue(RegistryHeaderAlignment, (int)this.headerAlignment);
|
|
key.SetValue(RegistryFooterAlignment, (int)this.footerAlignment);
|
|
key.SetValue(RegistryHeaderMarging, this.headerMargin);
|
|
key.SetValue(RegistryFooterMarging, this.footerMargin);
|
|
key.SetValue(RegistryHeaderTemplate, this.headerTemplate);
|
|
key.SetValue(RegistryFooterTemplate, this.footerTemplate);
|
|
key.SetValue(RegistryHeaderCustom, Convert.ToInt32(this.headerCustom));
|
|
key.SetValue(RegistryFooterCustom, Convert.ToInt32(this.footerCustom));
|
|
key.SetValue(RegistryCenterHorizontally, Convert.ToInt32(this.centerHorizontally));
|
|
key.SetValue(RegistryCenterVertically, Convert.ToInt32(this.centerVertically));
|
|
}
|
|
finally
|
|
{
|
|
key.Close();
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Properties and Methods
|
|
public bool Landscape
|
|
{
|
|
get { return this.landscape; }
|
|
set { this.landscape = value; }
|
|
}
|
|
public bool AdjustToScaleFactor
|
|
{
|
|
get { return this.adjustToScaleFactor; }
|
|
set { this.adjustToScaleFactor = value; }
|
|
}
|
|
public int ScaleFactor
|
|
{
|
|
get { return this.scaleFactor; }
|
|
set
|
|
{
|
|
if (value >= PageSetupData.DefaultMinScaleFactor && value <= PageSetupData.DefaultMaxScaleFactor)
|
|
this.scaleFactor = value;
|
|
}
|
|
}
|
|
public int PagesWide
|
|
{
|
|
get { return this.pagesWide < 1 ? 1 : this.pagesWide; }
|
|
set
|
|
{
|
|
if (value > 0)
|
|
this.pagesWide = value;
|
|
}
|
|
}
|
|
public int PagesTall
|
|
{
|
|
get { return this.pagesTall < 1 ? 1 : this.pagesTall; }
|
|
set
|
|
{
|
|
if (value > 0)
|
|
this.pagesTall = value;
|
|
}
|
|
}
|
|
public Margins Margins
|
|
{
|
|
get { return this.margins; }
|
|
set { this.margins = value; }
|
|
}
|
|
public int HeaderMargin
|
|
{
|
|
get { return this.headerMargin; }
|
|
set
|
|
{
|
|
if (value >= 0)
|
|
this.headerMargin = value;
|
|
}
|
|
}
|
|
public int FooterMargin
|
|
{
|
|
get { return this.footerMargin; }
|
|
set
|
|
{
|
|
if (value >= 0)
|
|
this.footerMargin = value;
|
|
}
|
|
}
|
|
public string HeaderTemplate
|
|
{
|
|
get { return this.headerTemplate; }
|
|
set { this.headerTemplate = value; }
|
|
}
|
|
public string FooterTemplate
|
|
{
|
|
get { return this.footerTemplate; }
|
|
set { this.footerTemplate = value; }
|
|
}
|
|
public HorizontalAlignment HeaderAlignment
|
|
{
|
|
get { return this.headerAlignment; }
|
|
set { this.headerAlignment = value; }
|
|
}
|
|
public HorizontalAlignment FooterAlignment
|
|
{
|
|
get { return this.footerAlignment; }
|
|
set { this.footerAlignment = value; }
|
|
}
|
|
public bool HeaderCustom
|
|
{
|
|
get { return this.headerCustom; }
|
|
set { this.headerCustom = value; }
|
|
}
|
|
public bool FooterCustom
|
|
{
|
|
get { return this.footerCustom; }
|
|
set { this.footerCustom = value; }
|
|
}
|
|
public bool CenterHorizontally
|
|
{
|
|
get { return this.centerHorizontally; }
|
|
set { this.centerHorizontally = value; }
|
|
}
|
|
public bool CenterVertically
|
|
{
|
|
get { return this.centerVertically; }
|
|
set { this.centerVertically = value; }
|
|
}
|
|
#endregion
|
|
}
|
|
#endregion
|
|
}
|