|
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
}
|