/// <summary>
/// Called to calculate the size that this section requires on
/// the next call to Print. This method will be called exactly once
/// prior to each call to Print. It must update the values Size and
/// Continued of the ReportSection base class.
/// </summary>
/// <param name="reportDocument">The parent ReportDocument that is printing.</param>
/// <param name="g">Graphics object to print on.</param>
/// <param name="bounds">Bounds of the area to print within.</param>
/// <returns>Size.Width and Size.Height are for the largest sub-section
/// in each direction, fits is true if any section fits, and continued
/// is true if any section is continued.</returns>
protected override SectionSizeValues DoCalcSize(
ReportDocument reportDocument,
Graphics g,
Bounds bounds
)
{
SectionSizeValues retval = new SectionSizeValues();
if (this.sections.Count == 0)
{
retval.Fits = true;
}
else
{
// TODO: get rid of enumerator, eventually hide sections
foreach (ReportSection section in this.sections)
{
section.CalcSize (reportDocument, g, bounds);
retval.RequiredSize.Height = Math.Max (
retval.RequiredSize.Height, section.Size.Height);
retval.RequiredSize.Width = Math.Max (
retval.RequiredSize.Width, section.Size.Width);
if (section.Continued)
{
retval.Continued = true;
}
if (section.Fits)
{
retval.Fits = true;
}
}
}
return retval;
}
/// <summary>
/// Called to actually print this section.
/// The DoCalcSize method will be called exactly once prior to each
/// call of DoPrint.
/// It should obey the value or Size and Continued as set by
/// DoCalcSize().
/// </summary>
/// <param name="reportDocument">The parent ReportDocument that is printing.</param>
/// <param name="g">Graphics object to print on.</param>
/// <param name="bounds">Bounds of the area to print within.</param>
protected override void DoPrint(
ReportDocument reportDocument,
Graphics g,
Bounds bounds
)
{
base.DoPrint(reportDocument, g, bounds);
this.sectionIndex = 0;
Reset();
}
/// <summary>
/// Paints or measures the object passed in according
/// to the formatting rules of this column.
/// </summary>
/// <param name="g">the graphics to paint the value onto</param>
/// <param name="headerRow">True if this is a header row</param>
/// <param name="alternatingRow">True if this row is an "alternating" row (even row most likely)</param>
/// <param name="summaryRow">True if this row is a summary row</param>
/// <param name="drv">DataRowView to grab the cell from</param>
/// <param name="x">the x coordinate to start the paint</param>
/// <param name="y">the y coordinate to start the paint</param>
/// <param name="width">the width of the cell</param>
/// <param name="height">The max height of this cell (when in sizeOnly mode)</param>
/// <param name="sizeOnly">only calculate the sizes</param>
/// <returns>A sizeF representing the measured size of the string + margins</returns>
public override SizeF SizePaintCell(
Graphics g, bool headerRow, bool alternatingRow, bool summaryRow,
DataRowView drv, float x, float y, float width,
float height, bool sizeOnly)
{
if (headerRow || summaryRow)
{
return base.SizePaintCell (g, headerRow, alternatingRow, summaryRow, drv, x, y, width, height, sizeOnly);
}
// else it's a data row...
// TODO: Update cell count and sum???
SizeF cellSize = new SizeF(width, height);
Image image = GetImage (drv);
TextStyle textStyle = GetTextStyle (headerRow, alternatingRow, summaryRow);
float sideMargins = textStyle.MarginNear + textStyle.MarginFar + RightPenWidth;
float topBottomMargins = textStyle.MarginTop + textStyle.MarginBottom;
Bounds bounds = new Bounds (x, y, x + width, y + height);
Bounds innerBounds = bounds.GetBounds (textStyle.MarginTop,
textStyle.MarginFar + RightPenWidth, textStyle.MarginBottom, textStyle.MarginNear);
SizeF maxSize = innerBounds.GetSizeF();
if (sizeOnly)
{
if (image == null)
{
cellSize.Width = 0;
cellSize.Height = 0;
}
else
{
cellSize.Width = ImageWidth;
cellSize.Height = ImageHeight;
}
}
else
{
// draw background
if (textStyle.BackgroundBrush != null)
{
g.FillRectangle (textStyle.BackgroundBrush, bounds.GetRectangleF());
}
// draw image
if (image != null)
{
RectangleF cellLayout = GetImageRect (innerBounds, image, textStyle);
g.DrawImage (image, cellLayout);
}
}
return cellSize;
}
/// <summary>
/// Sets the size variable based on the requiredSize provided.
/// The requiredSize should not include margins since
/// those are added by SetSize().
/// It also takes into account FullWidth and FullHeight and
/// uses the values from bounds if required.
/// </summary>
/// <param name="requiredSize">The size required for the section</param>
/// <param name="bounds">The full bounds allowed</param>
protected virtual void SetSize(SizeF requiredSize, Bounds bounds)
{
this.requiredSize = requiredSize;
this.size = new SizeF (0,0); // just to get rid of a compiler warning
if (this.UseFullWidth)
{
this.size.Width = bounds.Width;
}
else
{
this.size.Width = requiredSize.Width + this.MarginLeft + this.MarginRight;
}
if (this.UseFullHeight)
{
this.size.Height = bounds.Height;
}
else
{
this.size.Height = requiredSize.Height + this.MarginTop + this.MarginBottom;
}
if (this.MaxWidth > 0)
{
this.size.Width = Math.Min (this.size.Width, this.MaxWidth);
}
if (this.MaxHeight > 0)
{
this.size.Height = Math.Min (this.size.Height, this.MaxHeight);
}
}
/// <summary>
/// Called to calculate the size that this section requires on
/// the next call to Print. This method will be called once
/// prior to each call to Print.
/// </summary>
/// <param name="reportDocument">The parent ReportDocument that is printing.</param>
/// <param name="g">Graphics object to print on.</param>
/// <param name="bounds">Bounds of the area to print within.
/// The bounds passed already takes the margins into account - so you cannot
/// print or do anything within these margins.
/// </param>
/// <returns>The values for RequireSize, Fits and Continues for this section.</returns>
protected abstract SectionSizeValues DoCalcSize(
ReportDocument reportDocument,
Graphics g,
Bounds bounds
);
/// <summary>
/// Method called to Print this ReportSection.
/// If CalcSize has not already been called, it will call it.
/// </summary>
/// <param name="reportDocument">The parent ReportDocument that is printing.</param>
/// <param name="g">Graphics object to print on.</param>
/// <param name="bounds">Bounds of the area to print within.</param>
public void Print(
ReportDocument reportDocument,
Graphics g,
Bounds bounds)
{
Bounds printingBounds = LimitBounds (bounds);
if (this.sized && (printingBounds != this.sizingBounds))
{
SectionSizeValues vals = BoundsChanged (this.sizingBounds, printingBounds);
SetSize (vals.RequiredSize, bounds);
this.fits = vals.Fits;
this.continued = vals.Continued;
}
CalcSize (reportDocument, g, bounds);
if (this.fits)
{
DoPrint (reportDocument, g, printingBounds);
}
ResetSize ();
}
/// <summary>
/// Gets an inner bounds based on the widths of each pen
/// </summary>
/// <param name="bounds">Bounds inside the border</param>
/// <returns>Bounds that takes the border into accound</returns>
public Bounds GetInnerBounds(Bounds bounds)
{
if (Top != null)
{
bounds.Position.Y += Top.Width;
}
if (Right != null)
{
bounds.Limit.X -= Right.Width;
}
if (Bottom != null)
{
bounds.Limit.Y -= Bottom.Width;
}
if (Left != null)
{
bounds.Position.X += Left.Width;
}
return bounds;
}
/// <summary>
/// Called to actually print this section.
/// The DoCalcSize method will be called exactly once prior to each
/// call of DoPrint.
/// It should obey the value or Size and Continued as set by
/// DoCalcSize().
/// </summary>
/// <param name="reportDocument">The parent ReportDocument that is printing.</param>
/// <param name="g">Graphics object to print on.</param>
/// <param name="bounds">Bounds of the area to print within.</param>
protected override void DoPrint(
ReportDocument reportDocument,
Graphics g,
Bounds bounds
)
{
SizeF mySize = new SizeF (0,0);
if (ShowDividerFirst && (Divider != null))
{
divider.Print (reportDocument, g, bounds);
AdvancePointers (divider.Size, ref bounds, ref mySize);
}
// size first
SectionSizeValues oneCall = SizePrintLine (reportDocument, g, bounds, true, false);
bool fits = oneCall.Fits;
while (oneCall.Fits)
{
Bounds printBounds = bounds.GetBounds (oneCall.RequiredSize);
SizePrintLine (reportDocument, g, printBounds, false, true); // print
AdvancePointers (oneCall.RequiredSize, ref bounds, ref mySize);
// if this section is not continued, quit now
// or if this was the last column/row on this page, quit now
if (!oneCall.Continued || bounds.IsEmpty())
{
break;
}
oneCall = SizePrintLine (reportDocument, g, bounds, true, false); // size
if ( oneCall.Fits && Divider != null)
{
divider.Print (reportDocument, g, bounds);
AdvancePointers (divider.Size, ref bounds, ref mySize);
}
}
SetSize (mySize, bounds);
SetFits (fits);
SetContinued (oneCall.Continued);
}
/// <summary>
/// If width / height is not specified, then it subtracts
/// the border and padding bounds to create the returned bounds.
/// If width / height is specified, then result is based
/// on that width / height minux margins, border and padding.
/// </summary>
/// <param name="bounds">The bounds inside margins</param>
/// <returns>The bounds outside the content area</returns>
Bounds GetMaxContentBounds(Bounds bounds)
{
bounds.Position.X += border.LeftWidth + PaddingLeft;
bounds.Position.Y += border.TopWidth + PaddingTop;
if (Width > 0)
{
float contentWidth = Width
- MarginLeft - MarginRight
- border.LeftWidth - border.RightWidth
- PaddingLeft - PaddingRight;
bounds.Limit.X = bounds.Position.X + contentWidth;
}
else if (WidthPercent > 0)
{
float contentWidth = (bounds.Width * WidthPercent / 100)
- MarginLeft - MarginRight
- border.LeftWidth - border.RightWidth
- PaddingLeft - PaddingRight;
bounds.Limit.X = bounds.Position.X + contentWidth;
}
else
{
bounds.Limit.X -= border.RightWidth + PaddingRight;
}
if (Height > 0)
{
float contentHeight = Height
- MarginTop - MarginBottom
- border.TopWidth - border.BottomWidth
- PaddingTop - PaddingBottom;
bounds.Limit.Y = bounds.Position.Y + contentHeight;
}
else if (HeightPercent > 0)
{
float contentHeight = (bounds.Height * HeightPercent / 100)
- MarginTop - MarginBottom
- border.TopWidth - border.BottomWidth
- PaddingTop - PaddingBottom;
bounds.Limit.Y = bounds.Position.Y + contentHeight;
}
else
{
bounds.Limit.Y -= border.BottomWidth + PaddingBottom;
}
return bounds;
}
/// <summary>
/// The
/// </summary>
/// <param name="pageRectangle"></param>
/// <param name="desiredMargins"></param>
/// <param name="scale"></param>
/// <returns></returns>
public Bounds GetBounds(Rectangle pageRectangle, Rectangle desiredMargins,
float scale)
{
// take the hard margins into account by using them simply
// as an offset that the print would apply...
float leftMargin = desiredMargins.Left - hardLeftMargin;
float topMargin = desiredMargins.Top - hardTopMargin;
float rightMargin = desiredMargins.Right - hardLeftMargin;
float bottomMargin = desiredMargins.Bottom - hardTopMargin;
leftMargin *= scale;
topMargin *= scale;
rightMargin *= scale;
bottomMargin *= scale;
Bounds pageBounds = new Bounds(leftMargin, topMargin, rightMargin, bottomMargin);
return pageBounds;
}
/// <summary>
/// Paints or measures the object passed in according
/// to the formatting rules of this column.
/// </summary>
/// <param name="g">the graphics to paint the value onto</param>
/// <param name="text">the text to paint</param>
/// <param name="textStyle">the textStyle to use to paint the text</param>
/// <param name="x">the x coordinate to start the paint</param>
/// <param name="y">the y coordinate to start the paint</param>
/// <param name="width">the width of the cell</param>
/// <param name="height">The max height of this cell (when in sizeOnly mode)</param>
/// <param name="sizeOnly">only calculate the sizes</param>
/// <returns>A sizeF representing the measured size of the string + margins</returns>
public virtual SizeF SizePaintCell(
Graphics g, string text, TextStyle textStyle,
float x, float y, float width,
float height, bool sizeOnly)
{
SizeF stringSize = new SizeF(width, height);
Font font = textStyle.GetFont();
StringFormat stringFormat = textStyle.GetStringFormat();
float sideMargins = textStyle.MarginNear + textStyle.MarginFar + RightPenWidth;
float topBottomMargins = textStyle.MarginTop + textStyle.MarginBottom;
Bounds bounds = new Bounds (x, y, x + width, y + height);
Bounds innerBounds = bounds.GetBounds (textStyle.MarginTop,
textStyle.MarginFar + RightPenWidth, textStyle.MarginBottom, textStyle.MarginNear);
SizeF maxSize = innerBounds.GetSizeF();
if (sizeOnly)
{
// Find the height of the actual string to be drawn
stringSize = g.MeasureString(text, font, maxSize, stringFormat);
stringSize.Width += sideMargins;
stringSize.Height += topBottomMargins;
// Don't go bigger than maxHeight
stringSize.Height = Math.Min (stringSize.Height, height);
}
else
{
// draw background & text
if (textStyle.BackgroundBrush != null)
{
g.FillRectangle (textStyle.BackgroundBrush, bounds.GetRectangleF());
}
RectangleF textLayout = innerBounds.GetRectangleF (stringSize,
SectionText.ConvertAlign (textStyle.StringAlignment),
textStyle.VerticalAlignment);
g.DrawString(text, font, textStyle.Brush, textLayout, stringFormat);
}
return stringSize;
}
/// <summary>
/// Sizes or prints the header, if it is enabled
/// </summary>
/// <param name="g"></param>
/// <param name="bounds"></param>
/// <param name="sizeOnly"></param>
/// <returns>True if it fits, false if it doesn't</returns>
bool SizePrintHeader(Graphics g, ref Bounds bounds, bool sizeOnly)
{
bool headerFits = true;
if (!this.SuppressHeaderRow && this.RepeatHeaderRow)
{
// if it fits, print it
if (bounds.SizeFits(this.HeaderSize))
{
if (!sizeOnly)
{
SizePrintRow (g, HeaderRowNumber, bounds.Position.X, bounds.Position.Y,
this.GetPageInfo().Width, this.headerRowHeight, false, false);
}
bounds.Position.Y += this.headerRowHeight;
}
else
{
headerFits = false;
}
}
return headerFits;
}
/// <summary>
/// Prints rows of a table based on current rowIndex and dataRowsFit variables
/// Also, bounds is incremented as each row is printed.
/// </summary>
/// <param name="g">Graphics object used for printing</param>
/// <param name="bounds">Bounds allowed for table</param>
/// <returns>True if at least one row fits</returns>
void PrintRows(Graphics g, ref Bounds bounds)
{
// print all the rows that we already decided fit on the page...
for (int rowCount = 0; rowCount < this.dataRowsFit; rowCount++, this.rowIndex++ )
{
float height = (float) rowHeights[rowCount];
bool showLine = false; //rowCount != this.dataRowsFit - 1;
SizePrintRow (g, this.rowIndex, bounds.Position.X,
bounds.Position.Y, bounds.Width, height, false, showLine);
bounds.Position.Y += height;
Debug.Assert (bounds.Position.Y - bounds.Limit.Y < 0.005f, // TODO: Bad magic number
"Row doesn't really fit, but we thought it did. Delta: " + (bounds.Position.Y - bounds.Limit.Y));
}
}
void PrintAllRowLines(Graphics g, Bounds bounds, bool includeHeader)
{
float x = bounds.Position.X;
float y = bounds.Position.Y;
float rowWidth = bounds.Width;
if (includeHeader)
{
RowLine (g, x, y + this.headerRowHeight, rowWidth, true, false);
y += this.headerRowHeight;
}
for (int rowCount = 0; rowCount < this.dataRowsFit - 1; rowCount++ )
{
float height = (float) rowHeights[rowCount];
bool showLine = rowCount != this.dataRowsFit - 1;
RowLine (g, x, y + height, rowWidth, false, false);
y += height;
}
}
void PrintAllColumnLines(Graphics g, Bounds bounds)
{
PageInfo info = GetPageInfo();
float x = bounds.Position.X;
float y = bounds.Position.Y;
for (int colNumber = info.FirstColumn; colNumber <= info.LastColumn - 1; colNumber++)
{
IDataColumn col = GetColumn(colNumber);
x += col.Width;
col.DrawRightLine (g, x, y, bounds.Height);
}
}
/// <summary>
/// Called to actually print this section.
/// </summary>
/// <param name="reportDocument">The parent ReportDocument that is printing.</param>
/// <param name="g">Graphics object to print on.</param>
/// <param name="bounds">Bounds of the area to print within.
/// These bounds already take the margins into account.
/// </param>
protected override void DoPrint(
ReportDocument reportDocument,
Graphics g,
Bounds bounds
)
{
if ( !reportDocument.NoPrint )
border.DrawBorder (g, this.borderBounds);
if (Background != null)
{
if ( !reportDocument.NoPrint )
g.FillRectangle (Background, this.paddingBounds.GetRectangleF());
}
if (CurrentSection != null)
{
CurrentSection.Print (reportDocument, g, this.contentBounds);
}
}
/// <summary>
/// Gets the BorderBounds based on the bounds inside
/// the margins,
/// using Width and Height, UseFullWidth and UseFullHeight,
/// and optinally the contentSize (if non-zero)
/// </summary>
Bounds GetBorderBounds(Bounds bounds, SizeF contentSize)
{
SizeF borderSize = bounds.GetSizeF();
if (SizeToContentsWidth)
{
borderSize.Width = contentSize.Width + PaddingLeft + PaddingRight
+ this.border.LeftWidth + this.border.RightWidth;
}
else
{
float widthToUse = Width;
if (WidthPercent > 0)
{
widthToUse = bounds.Width * (WidthPercent / 100);
}
borderSize.Width = widthToUse - MarginLeft - MarginRight;
}
if (SizeToContentsHeight)
{
borderSize.Height = contentSize.Height + PaddingTop + PaddingBottom
+ this.border.LeftWidth + this.border.RightWidth;
}
else
{
float heightToUse = Height;
if (HeightPercent > 0)
{
heightToUse = bounds.Height * (HeightPercent / 100);
}
borderSize.Height = heightToUse - MarginTop - MarginBottom;
}
Bounds borderBounds = bounds.GetBounds (borderSize,
this.HorizontalAlignment, this.VerticalAlignment);
return borderBounds;
}
/// <summary>
/// Notification that the bounds has changed between
/// the size and the print.
/// Override this function to update anything based on the new location
/// </summary>
/// <param name="originalBounds">Bounds originally passed for sizing</param>
/// <param name="newBounds">New bounds for printing</param>
/// <returns>New required size</returns>
protected override SectionSizeValues BoundsChanged(
Bounds originalBounds,
Bounds newBounds)
{
// Find the cases where a resizing is not-necessary.
// For now, we can handle a change in the size of the
// bounds as long as the placement doesn't change relative to
// our "aligned" corner, and the size is still big enough.
bool resize = true;
int corner = GetOrigin();
if (corner >= 0)
{
if (GetPoint(originalBounds, corner) == GetPoint(newBounds, corner))
{
if (newBounds.SizeFits(this.RequiredSize))
{
resize = false;
}
}
}
if (resize)
{
this.ResetSize();
}
return base.BoundsChanged (originalBounds, newBounds);
}
/// <summary>
/// Called to calculate the size that this section requires on
/// the next call to Print.
/// Simply returns the full size (up to MaxWidth and MaxHeight
/// </summary>
/// <param name="reportDocument">The parent ReportDocument that is printing.</param>
/// <param name="g">Graphics object to print on.</param>
/// <param name="bounds">Bounds of the area to print within.</param>
/// <returns>size is the full size of the bounds given,
/// fits is always true, and continued is always false from this
/// routine. Note that DoPrint may change the values of all these.
/// </returns>
protected override SectionSizeValues DoCalcSize(
ReportDocument reportDocument,
Graphics g,
Bounds bounds
)
{
SectionSizeValues retvals = new SectionSizeValues();
// assume worst-case size...
retvals.RequiredSize = bounds.GetSizeF();
retvals.Fits = true;
return retvals;
}
/// <summary>
/// Called to calculate the size that this section requires on
/// the next call to Print. This method will be called exactly once
/// prior to each call to Print. It must update the values Size and
/// Continued of the ReportSection base class.
/// </summary>
/// <param name="reportDocument">Pparent ReportDocument that is printing.</param>
/// <param name="g">Graphics object to print on.</param>
/// <param name="bounds">Bounds of the area to print within.</param>
/// <returns>SectionSizeValues</returns>
protected override SectionSizeValues DoCalcSize(
ReportDocument reportDocument,
Graphics g,
Bounds bounds
)
{
SectionSizeValues retval = new SectionSizeValues();
textFont = this.TextStyle.GetFont();
textLayout = bounds.GetRectangleF();
if (CheckTextLayout(g))
{
// Get a new string starting from where-ever we left off on the last page
textToPrint = GetText(reportDocument);
retval = SetTextSize (reportDocument, g, bounds);
}
else
{
retval.Fits = false;
}
return retval;
}
/// <summary>
/// Draws a border inside the given bounds
/// </summary>
/// <param name="g">Graphics object to print on</param>
/// <param name="bounds">Outer bounds of the border</param>
public void DrawBorder(Graphics g, Bounds bounds)
{
RectangleF rect = bounds.GetRectangleF();
DrawBorder (g, rect);
}
/// <summary>
/// Called to actually print this section.
/// The DoCalcSize method will be called exactly once prior to each
/// call of DoPrint.
/// It should obey the value or Size and Continued as set by
/// DoCalcSize().
/// </summary>
/// <param name="reportDocument">The parent ReportDocument that is printing.</param>
/// <param name="g">Graphics object to print on.</param>
/// <param name="bounds">Bounds of the area to print within.</param>
protected override void DoPrint(
ReportDocument reportDocument,
Graphics g,
Bounds bounds
)
{
if ( !reportDocument.NoPrint )
{
// draw background and text
if (this.TextStyle.BackgroundBrush != null)
{
RectangleF backgroundRect = textLayout;
if (this.UseFullWidth)
{
backgroundRect.X = bounds.Position.X;
backgroundRect.Width = bounds.Width;
}
if (this.UseFullHeight)
{
backgroundRect.Y = bounds.Position.Y;
backgroundRect.Height = bounds.Height;
}
g.FillRectangle (this.TextStyle.BackgroundBrush, backgroundRect);
}
g.DrawString(textToPrint, textFont, this.TextStyle.Brush, textLayout, GetStringFormat());
if (debugEnabled)
{
Console.WriteLine ("Draw string '" + textToPrint + "' at " + textLayout);
}
}
// Increment the character pointer...
this.CharIndex += charsFitted;
}
/// <summary>
/// Method called to Calculate the size required for
/// the next Print. Calling this method initializes
/// the values Size and Continued. Once these values
/// are initialized, further calls to CalcSize have
/// no affect, unless ResetSize() is called.
/// </summary>
/// <param name="reportDocument">The parent ReportDocument that is printing.</param>
/// <param name="g">Graphics object to print on.</param>
/// <param name="bounds">Bounds of the area to print within.</param>
public void CalcSize(
ReportDocument reportDocument,
Graphics g,
Bounds bounds)
{
BeginPrint(g);
if (this.requiresNonEmptyBounds && bounds.IsEmpty())
{
this.fits = false;
}
else if (!this.sized)
{
// two default values
this.sizingBounds = LimitBounds (bounds);
SectionSizeValues vals = DoCalcSize(reportDocument, g, this.sizingBounds);
SetSize (vals.RequiredSize, bounds);
if (this.keepTogether && vals.Continued)
{
this.fits = false;
}
else
{
this.fits = vals.Fits;
}
this.continued = vals.Continued;
this.sized = true;
}
}
/// <summary>
/// Gets a Point from a bounds based on a given corner 0-3
/// </summary>
PointF GetPoint(Bounds bounds, int corner)
{
Debug.Assert (corner >= 0 && corner <= 3, "Illegal origin value.");
float x = 0;
float y = 0;
if ((corner & 1) == 0)
{
x = bounds.Position.X;
}
else
{
x = bounds.Limit.X;
}
if ((corner & 2) == 0)
{
y = bounds.Position.Y;
}
else
{
y = bounds.Limit.Y;
}
return new PointF (x,y);
}
/// <summary>
/// This method is called after a size and before a print if
/// the bounds have changed between the sizing and the printing.
/// Override this function to update anything based on the new location
/// </summary>
/// <param name="originalBounds">Bounds originally passed for sizing</param>
/// <param name="newBounds">New bounds for printing</param>
/// <returns>SectionSizeValues for the new values of size, fits, continued</returns>
/// <remarks>To simply have size recalled, implement the following:
/// <code>
/// this.ResetSize();
/// return base.BoundsChanged (originalBounds, newBounds);
/// </code>
/// </remarks>
protected virtual SectionSizeValues BoundsChanged(
Bounds originalBounds,
Bounds newBounds)
{
SectionSizeValues retval = new SectionSizeValues();
retval.Fits = this.Fits;
retval.Continued = this.Continued;
retval.RequiredSize = this.RequiredSize;
return retval;
}
/// <summary>
/// Sets the TextLayout rectangle to the correct size
/// Also sets size, itFits, and continued of the base class
/// </summary>
/// <param name="doc">The parent ReportDocument</param>
/// <param name="g">Graphics object</param>
/// <param name="bounds">Bounds to draw within</param>
/// <returns>SectionSizeValues</returns>
SectionSizeValues SetTextSize(ReportDocument doc, Graphics g, Bounds bounds)
{
SectionSizeValues retval = new SectionSizeValues();
retval.Fits = true;
// Find the height of the actual string + margins to be drawn
SizeF requiredSize = g.MeasureString(textToPrint, textFont,
textLayout.Size, GetStringFormat(), out charsFitted, out linesFitted);
if (charsFitted < textToPrint.Length)
{
// it doesn't all fit.
if (this.KeepTogether)
{
// try on the next page.
// HACK: This is bad if the whole section doesn't
// ever fit on a page, since it will end up in an infinite loop.
retval.Fits = false;
charsFitted = 0;
linesFitted = 0;
return retval;
}
retval.Continued = true;
}
if (this.HorizontalAlignment != HorizontalAlignment.Left)
requiredSize.Width = textLayout.Size.Width;
// Get a new rectangle aligned within the bounds and margins
textLayout = bounds.GetRectangleF(requiredSize,
this.HorizontalAlignment, this.VerticalAlignment);
retval.RequiredSize = textLayout.Size;
if (debugEnabled)
{
Console.WriteLine ("Layout for string '" + textToPrint + "' is " + textLayout);
}
return retval;
}
/// <summary>
/// Called to actually print this section.
/// The DoCalcSize method will be called once prior to each
/// call of DoPrint.
/// DoPrint is not called if DoCalcSize sets fits to false.
/// It should obey the values of Size and Continued as set by
/// DoCalcSize().
/// </summary>
/// <param name="reportDocument">The parent ReportDocument that is printing.</param>
/// <param name="g">Graphics object to print on.</param>
/// <param name="bounds">Bounds of the area to print within.
/// These bounds already take the margins into account.
/// </param>
protected abstract void DoPrint(
ReportDocument reportDocument,
Graphics g,
Bounds bounds
);
/// <summary>
/// This method is called after a size and before a print if
/// the bounds have changed between the sizing and the printing.
/// Override this function to update anything based on the new location
/// </summary>
/// <param name="originalBounds">Bounds originally passed for sizing</param>
/// <param name="newBounds">New bounds for printing</param>
/// <returns>SectionSizeValues for the new values of size, fits, continued</returns>
/// <remarks>To simply have size recalled, implement the following:
/// <code>
/// this.ResetSize();
/// return base.ChangeBounds (originalBounds, newBounds);
/// </code>
/// </remarks>
protected override SectionSizeValues BoundsChanged(
Bounds originalBounds,
Bounds newBounds)
{
// don't really do anything... (this is the base implementation)
SectionSizeValues retval = new SectionSizeValues();
retval.Fits = this.Fits;
retval.Continued = this.Continued;
retval.RequiredSize = this.RequiredSize;
return retval;
}
/// <summary>
/// Limits a bounds down to MaxWidth and MaxHeight
/// </summary>
Bounds LimitBounds(Bounds bounds)
{
if ((this.MaxWidth > 0) && (bounds.Width > this.MaxWidth))
{
bounds.Limit.X = bounds.Position.X + this.MaxWidth;
}
if ((this.MaxHeight > 0) && (bounds.Height > this.MaxHeight))
{
bounds.Limit.Y = bounds.Position.Y + this.MaxHeight;
}
// Take margins into account
bounds = bounds.GetBounds (this.MarginTop,
this.MarginRight, this.MarginBottom, this.MarginLeft);
return bounds;
}
/// <summary>
/// Called to calculate the size that this section requires on
/// the next call to Print. This method will be called once
/// prior to each call to Print.
/// </summary>
/// <param name="reportDocument">The parent ReportDocument that is printing.</param>
/// <param name="g">Graphics object to print on.</param>
/// <param name="bounds">Bounds of the area to print within.
/// The bounds passed already takes the margins into account - so you cannot
/// print or do anything within these margins.
/// </param>
/// <returns>The values for RequireSize, Fits and Continues for this section.</returns>
protected override SectionSizeValues DoCalcSize(
ReportDocument reportDocument,
Graphics g,
Bounds bounds
)
{
// Take offset into account...
bounds.Position.X += OffsetLeft;
bounds.Position.Y += OffsetTop;
SectionSizeValues retval = new SectionSizeValues();
// need to determine what to do with these values...
retval.Fits = true;
retval.Continued = false;
SizeF contentSize = new SizeF (0,0);
if (CurrentSection != null)
{
CurrentSection.CalcSize (reportDocument, g, GetMaxContentBounds(bounds));
contentSize = CurrentSection.Size; // or could use RequiredSize?
}
this.borderBounds = GetBorderBounds (bounds, contentSize);
this.paddingBounds = border.GetInnerBounds (this.borderBounds);
this.contentBounds = paddingBounds.GetBounds (PaddingTop, PaddingRight,
PaddingBottom, PaddingLeft);
retval.RequiredSize = this.borderBounds.GetSizeF();
return retval;
}
