/// <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 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> /// 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> /// 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); }
/// <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 ) { this.linesToPrint = new ArrayList(100); SectionSizeValues retval = new SectionSizeValues(); WordToPrint nextWord = null; int nextIndex; while (charIndex < this.richTextBox1.Text.Length) { LineToPrint line = LineToPrint.Get(charIndex, g, bounds.Position, bounds.Width, this.richTextBox1, ref nextWord, out nextIndex); if (line.Size.Height + bounds.Position.Y < bounds.Limit.Y) { linesToPrint.Add(line); charIndex = nextIndex; retval.RequiredSize.Width = Math.Max(retval.RequiredSize.Width, line.Size.Width); retval.RequiredSize.Height += line.Size.Height; bounds.Position.Y += line.Size.Height; } else { retval.Continued = true; break; } } retval.Fits = true; return(retval); }
} // AdvancePointers /// <summary> /// Sizes all the sections that fit within a single row/column /// </summary> /// <param name="reportDocument">Parent ReportDocument</param> /// <param name="g">Graphics object for sizing / printing</param> /// <param name="bounds">The bounds the line must fit within</param> /// <param name="sizeOnly">Indicates that no printing should be done, /// just size the line</param> /// <param name="advanceSectionIndex">Advance the section index, /// so that it's ready for the next line</param> /// <returns>Size and flags for if it fits and if it's continued</returns> protected SectionSizeValues SizePrintLine( ReportDocument reportDocument, Graphics g, Bounds bounds, bool sizeOnly, bool advanceSectionIndex ) { SectionSizeValues retvals = new SectionSizeValues(); retvals.Fits = false; int savedSectionIndex = this.sectionIndex; // Debug.WriteLine("\nEntering " + Direction + " section, sizeonly = " + sizeOnly); // Debug.WriteLine(" Bounds: " + bounds); // The following loop sizes all sections that fit on one line // If it runs out of room within the current bounds, it returns // and will continue where it left off on the next call. while (this.sectionIndex < this.SectionCount) { CurrentSection.CalcSize(reportDocument, g, bounds); if (CurrentSection.Fits) { retvals.Fits = true; if (!sizeOnly) { CurrentSection.Print(reportDocument, g, bounds); } AdvancePointers(CurrentSection.Size, ref bounds, ref retvals.RequiredSize); if (CurrentSection.Continued) { break; } else { this.sectionIndex++; } } else // it doesn't fit { // reset size since we didn't print but need the size to be // refigured next time CurrentSection.ResetSize(); break; } } // while // Debug.WriteLine("Leaving " + Direction + " section"); // Debug.WriteLine(" Size: " + RequiredSize); retvals.Continued = this.sectionIndex < this.SectionCount; if (!advanceSectionIndex) { this.sectionIndex = savedSectionIndex; } return(retvals); } // SizePrintLine
/// <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> /// 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) { SectionSizeValues retval = new SectionSizeValues(); this.imageRect = GetImageRect(newBounds); retval.RequiredSize = this.imageRect.Size; retval.Fits = newBounds.SizeFits(retval.RequiredSize); retval.Continued = false; return(retval); }
/// <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> /// Re-computes the line based on changed bounds /// </summary> /// <param name="originalBounds">Original bounds used for size</param> /// <param name="newBounds">New bounds</param> /// <returns>SectionSizeValues struct</returns> protected override SectionSizeValues BoundsChanged( Bounds originalBounds, Bounds newBounds) { SetLinePoints(newBounds); SectionSizeValues retvals = new SectionSizeValues(); retvals.Fits = true; retvals.Continued = false; retvals.RequiredSize = GetSizeF(); return(retvals); }
/// <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 override void DoPrint( ReportDocument reportDocument, Graphics g, Bounds bounds ) { //g.TextRenderingHint = TextRenderingHint.AntiAlias; SectionSizeValues results = DrawEditControl(g, bounds, false); SetContinued(results.Continued); SetFits(results.Fits); SetSize(results.RequiredSize, 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 ) { SectionSizeValues retval = new SectionSizeValues(); retval.Fits = true; retval.RequiredSize = bounds.GetSizeF(); //DrawEditControl(g, bounds, true); return(retval); }
/// <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 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 ) { SectionSizeValues retval = new SectionSizeValues(); this.imageRect = GetImageRect(bounds); retval.RequiredSize = this.imageRect.Size; retval.Fits = bounds.SizeFits(retval.RequiredSize); retval.Continued = false; return(retval); }
/// <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> protected override SectionSizeValues DoCalcSize( ReportDocument reportDocument, Graphics g, Bounds bounds ) { SetDefaultPen(reportDocument); SetLinePoints(bounds); SectionSizeValues retvals = new SectionSizeValues(); retvals.Fits = true; retvals.Continued = false; retvals.RequiredSize = GetSizeF(); 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">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>SectionSizeValues of requiredSize, fits, and continues.</returns> protected override SectionSizeValues DoCalcSize( ReportDocument reportDocument, Graphics g, Bounds bounds ) { // Default values SectionSizeValues retvals = new SectionSizeValues(); Bounds insideBorder = this.borderPens.GetInnerBounds(bounds); CalcHeaderSize(g, insideBorder); Bounds tableBounds = GetTableBounds(insideBorder); PointF originalPosition = tableBounds.Position; if (SizePrintHeader(g, ref tableBounds, true)) { if (this.currentHorizPage == 0) { this.dataRowsFit = FindDataRowsFit(g, ref tableBounds); this.tableHeightForPage = tableBounds.Position.Y - originalPosition.Y; } if (this.TotalRows == 0) // special case of 0 rows { retvals.Fits = true; } else if (this.dataRowsFit > 0) { retvals.Fits = true; if (this.currentHorizPage < this.infoForPages.Count - 1) { retvals.Continued = true; } else if (this.rowIndex + this.dataRowsFit < this.TotalRows) { retvals.Continued = true; } } } retvals.RequiredSize = this.borderPens.AddBorderSize( new SizeF(GetPageInfo().Width, tableHeightForPage)); return(retvals); }
/// <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> /// 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> /// 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 if (!oneCall.Continued) { break; } if (Divider != null) { divider.Print(reportDocument, g, bounds); AdvancePointers(divider.Size, ref bounds, ref mySize); } oneCall = SizePrintLine(reportDocument, g, bounds, true, false); // size } SetSize(mySize, bounds); SetFits(fits); SetContinued(oneCall.Continued); }
/// <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; } // 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 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 ) { SectionSizeValues retval = new SectionSizeValues(); retval.Fits = true; int page = reportDocument.GetCurrentPage(); if (this.firstTimeCalled) { this.pageNumber = page; retval.Continued = this.pageBreak; retval.RequiredSize = bounds.GetSizeF(); this.firstTimeCalled = false; if (this.setOrientation) { reportDocument.SetPageOrientation(page + 1, this.newPageOrientation); } } else { if (this.pageBreak && (page == this.pageNumber)) { retval.Continued = true; retval.RequiredSize = bounds.GetSizeF(); } else { retval.Continued = false; retval.RequiredSize = new SizeF(0, 0); } } return(retval); }
/// <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>SectionSizeValues of requiredSize, fits, and continues.</returns> protected override SectionSizeValues DoCalcSize( ReportDocument reportDocument, Graphics g, Bounds bounds ) { // Default values SectionSizeValues retvals = new SectionSizeValues(); Bounds insideBorder = this.borderPens.GetInnerBounds (bounds); CalcHeaderSize (g, insideBorder); Bounds tableBounds = GetTableBounds (insideBorder); PointF originalPosition = tableBounds.Position; if (SizePrintHeader (g, ref tableBounds, true)) { if (this.currentHorizPage == 0) { this.dataRowsFit = FindDataRowsFit (g, ref tableBounds); this.tableHeightForPage = tableBounds.Position.Y - originalPosition.Y; } if (this.TotalRows == 0) // special case of 0 rows { retvals.Fits = true; } else if (this.dataRowsFit > 0) { retvals.Fits = true; if (this.currentHorizPage < this.infoForPages.Count - 1) { retvals.Continued = true; } else if (this.rowIndex + this.dataRowsFit < this.TotalRows) { retvals.Continued = true; } } } retvals.RequiredSize = this.borderPens.AddBorderSize ( new SizeF (GetPageInfo().Width, tableHeightForPage)); 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">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>SectionSizeValues of requiredSize, fits, and continues.</returns> protected override SectionSizeValues DoCalcSize( ReportDocument reportDocument, Graphics g, Bounds bounds ) { // Default values SectionSizeValues retvals = new SectionSizeValues(); DataSource.RowFilter = RowFilter; Bounds tableBounds = new Bounds(0, 0, 0, 0); if (TableHeader == null || rowIndex > 0) tableBounds = bounds; else { TableHeader.CalcSize(reportDocument, g, bounds); if ( TableHeader.Fits ) tableBounds = new Bounds( bounds.Position.X, bounds.Position.Y + TableHeader.RequiredSize.Height, bounds.Limit.X, bounds.Limit.Y); } if ( !tableBounds.IsEmpty() ) { retvals = base.DoCalcSize(reportDocument, g, tableBounds); if ( retvals.Fits ) { if (TableHeader != null && rowIndex <= 0) retvals.RequiredSize = new SizeF(retvals.RequiredSize.Width, retvals.RequiredSize.Height + TableHeader.RequiredSize.Height); if ( !retvals.Continued && TableFooter != null) { Bounds footerBounds = new Bounds( tableBounds.Position.X, tableBounds.Position.Y + RequiredSize.Height, tableBounds.Limit.X, tableBounds.Limit.Y); TableFooter.CalcSize(reportDocument, g, footerBounds); if ( TableFooter.Fits ) retvals.RequiredSize = new SizeF(retvals.RequiredSize.Width, retvals.RequiredSize.Height + TableFooter.RequiredSize.Height); else { if (this.dataRowsFit >= (2 * this.MinDataRowsFit)) { this.dataRowsFit -= this.MinDataRowsFit; retvals.Continued = true; // should adjust RequiredSize. } else { retvals.Fits = false; } } } } } return retvals; }
/// <summary> /// Re-computes the line based on changed bounds /// </summary> /// <param name="originalBounds">Original bounds used for size</param> /// <param name="newBounds">New bounds</param> /// <returns>SectionSizeValues struct</returns> protected override SectionSizeValues BoundsChanged( Bounds originalBounds, Bounds newBounds) { SetLinePoints (newBounds); SectionSizeValues retvals = new SectionSizeValues(); retvals.Fits = true; retvals.Continued = false; retvals.RequiredSize = GetSizeF(); return retvals; }
SectionSizeValues DrawEditControl(Graphics g, Bounds bounds, bool sizeOnly) { SectionSizeValues retval = new SectionSizeValues(); retval.RequiredSize = new SizeF(0, 0); // draw the control by selecting the first character // of each word, and getting its font / color float xPos = bounds.Position.X; float yPos = bounds.Position.Y; int c; int length = richTextBox1.Text.Length; for (c = this.lastCharIndex; c < length; c++) { richTextBox1.Select(c, 1); char nextChar = richTextBox1.Text[c]; Debug.WriteIf(showchars, nextChar); Color theColor = richTextBox1.SelectionColor; Font theFont = richTextBox1.SelectionFont; if (theFont == null) { Debug.WriteLine("Null font, using a default"); theFont = new Font(FontFamily.GenericSansSerif, 12); } float fontHeight = theFont.GetHeight(g); if (nextChar == '\n') { retval.RequiredSize.Width = Math.Max(retval.RequiredSize.Width, xPos - bounds.Position.X); xPos = bounds.Position.X; yPos += (fontHeight * verticalSpacing); if (yPos > bounds.Limit.Y) { break; } } else if (nextChar == ' ') { xPos += fontHeight / 2; } else if (nextChar == '\t') { xPos += fontHeight * 2; } else { // match the words for same font / color Match m; StringBuilder nextWord = new StringBuilder(30); bool reduceAtEnd = false; m = wordSeparator.Match(nextChar.ToString()); if (m.Success) { reduceAtEnd = true; } else { nextWord.Append(nextChar); } while (m.Success) { nextWord.Append(nextChar); c++; if (c >= length) { break; } nextChar = richTextBox1.Text[c]; Debug.WriteIf(showchars, nextChar); m = wordSeparator.Match(nextChar.ToString()); } if (reduceAtEnd) { c--; } string word = nextWord.ToString(); PointF drawPoint = new PointF(xPos, yPos); SizeF drawSize = g.MeasureString(word, theFont, drawPoint, stringFormat); xPos += drawSize.Width; if (xPos > bounds.Limit.X) { yPos += (fontHeight * verticalSpacing); if (yPos > bounds.Limit.Y) { // need to undo changes to c break; } retval.RequiredSize.Width = Math.Max(retval.RequiredSize.Width, xPos - bounds.Position.X); xPos = bounds.Position.X + drawSize.Width; drawPoint.X = bounds.Position.X; drawPoint.Y = yPos; } if (!sizeOnly) { g.DrawString(word, theFont, new SolidBrush(theColor), drawPoint, stringFormat); } } } retval.Fits = c > this.lastCharIndex; retval.Continued = c < richTextBox1.Text.Length; if (!sizeOnly) { this.lastCharIndex = c; } return(retval); }
/// <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> protected override SectionSizeValues DoCalcSize( ReportDocument reportDocument, Graphics g, Bounds bounds ) { SetDefaultPen (reportDocument); SetLinePoints (bounds); SectionSizeValues retvals = new SectionSizeValues(); retvals.Fits = true; retvals.Continued = false; retvals.RequiredSize = GetSizeF(); return retvals; }
/// <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 ) { SectionSizeValues retval = new SectionSizeValues(); retval.Fits = true; int page = reportDocument.GetCurrentPage(); if (this.firstTimeCalled) { this.pageNumber = page; retval.Continued = this.pageBreak; retval.RequiredSize = bounds.GetSizeF(); this.firstTimeCalled = false; if (this.setOrientation) { reportDocument.SetPageOrientation (page + 1, this.newPageOrientation); } } else { if (this.pageBreak && (page == this.pageNumber)) { retval.Continued = true; retval.RequiredSize = bounds.GetSizeF(); } else { retval.Continued = false; retval.RequiredSize = new SizeF (0, 0); } } return retval; }
/// <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) { SectionSizeValues retval = new SectionSizeValues(); this.imageRect = GetImageRect(newBounds); retval.RequiredSize = this.imageRect.Size; retval.Fits = newBounds.SizeFits(retval.RequiredSize); retval.Continued = false; return retval; }
/// <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 ) { SectionSizeValues retval = new SectionSizeValues(); this.imageRect = GetImageRect(bounds); retval.RequiredSize = this.imageRect.Size; retval.Fits = bounds.SizeFits(retval.RequiredSize); retval.Continued = false; return retval; }
/// <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> /// 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> /// 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; }
SectionSizeValues DrawEditControl(Graphics g, Bounds bounds, bool sizeOnly) { SectionSizeValues retval = new SectionSizeValues(); retval.RequiredSize = new SizeF (0,0); // draw the control by selecting the first character // of each word, and getting its font / color float xPos = bounds.Position.X; float yPos = bounds.Position.Y; int c; int length = richTextBox1.Text.Length; for (c = this.lastCharIndex; c < length; c++) { richTextBox1.Select (c,1); char nextChar = richTextBox1.Text[c]; Debug.WriteIf (showchars, nextChar); Color theColor = richTextBox1.SelectionColor; Font theFont = richTextBox1.SelectionFont; if (theFont == null) { Debug.WriteLine ("Null font, using a default"); theFont = new Font (FontFamily.GenericSansSerif, 12); } float fontHeight = theFont.GetHeight(g); if (nextChar == '\n') { retval.RequiredSize.Width = Math.Max (retval.RequiredSize.Width, xPos - bounds.Position.X); xPos = bounds.Position.X; yPos += (fontHeight * verticalSpacing); if (yPos > bounds.Limit.Y) { break; } } else if (nextChar == ' ') { xPos += fontHeight / 2; } else if (nextChar == '\t') { xPos += fontHeight * 2; } else { // match the words for same font / color Match m; StringBuilder nextWord = new StringBuilder (30); bool reduceAtEnd = false; m = wordSeparator.Match(nextChar.ToString()); if (m.Success) { reduceAtEnd = true; } else { nextWord.Append (nextChar); } while (m.Success) { nextWord.Append (nextChar); c++; if (c >= length) break; nextChar = richTextBox1.Text[c]; Debug.WriteIf (showchars, nextChar); m = wordSeparator.Match (nextChar.ToString()); } if (reduceAtEnd) { c--; } string word = nextWord.ToString(); PointF drawPoint = new PointF (xPos, yPos); SizeF drawSize = g.MeasureString(word, theFont, drawPoint, stringFormat); xPos += drawSize.Width; if (xPos > bounds.Limit.X) { yPos += (fontHeight * verticalSpacing); if (yPos > bounds.Limit.Y) { // need to undo changes to c break; } retval.RequiredSize.Width = Math.Max (retval.RequiredSize.Width, xPos - bounds.Position.X); xPos = bounds.Position.X + drawSize.Width; drawPoint.X = bounds.Position.X; drawPoint.Y = yPos; } if (!sizeOnly) { g.DrawString(word, theFont, new SolidBrush(theColor), drawPoint, stringFormat); } } } retval.Fits = c > this.lastCharIndex; retval.Continued = c < richTextBox1.Text.Length; if (!sizeOnly) this.lastCharIndex = c; 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> /// Sizes all the sections that fit within a single row/column /// </summary> /// <param name="reportDocument">Parent ReportDocument</param> /// <param name="g">Graphics object for sizing / printing</param> /// <param name="bounds">The bounds the line must fit within</param> /// <param name="sizeOnly">Indicates that no printing should be done, /// just size the line</param> /// <param name="advanceSectionIndex">Advance the section index, /// so that it's ready for the next line</param> /// <returns>Size and flags for if it fits and if it's continued</returns> protected SectionSizeValues SizePrintLine( ReportDocument reportDocument, Graphics g, Bounds bounds, bool sizeOnly, bool advanceSectionIndex ) { SectionSizeValues retvals = new SectionSizeValues(); retvals.Fits = false; int savedSectionIndex = this.sectionIndex; // Debug.WriteLine("\nEntering " + Direction + " section, sizeonly = " + sizeOnly); // Debug.WriteLine(" Bounds: " + bounds); // The following loop sizes all sections that fit on one line // If it runs out of room within the current bounds, it returns // and will continue where it left off on the next call. while (this.sectionIndex < this.SectionCount) { CurrentSection.CalcSize (reportDocument, g, bounds); if (CurrentSection.Fits) { retvals.Fits = true; if (!sizeOnly) CurrentSection.Print (reportDocument, g, bounds); AdvancePointers(CurrentSection.Size, ref bounds, ref retvals.RequiredSize); if (CurrentSection.Continued) { break; } else { this.sectionIndex++; } } else // it doesn't fit { // reset size since we didn't print but need the size to be // refigured next time CurrentSection.ResetSize(); break; } } // while // Debug.WriteLine("Leaving " + Direction + " section"); // Debug.WriteLine(" Size: " + RequiredSize); retvals.Continued = this.sectionIndex < this.SectionCount; if (this.sectionIndex == savedSectionIndex && !retvals.Continued) retvals.Fits = true; if (!advanceSectionIndex) this.sectionIndex = savedSectionIndex; return retvals; }
/// <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; }
/// <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 ) { this.linesToPrint = new ArrayList (100); SectionSizeValues retval = new SectionSizeValues(); WordToPrint nextWord = null; int nextIndex; while (charIndex < this.richTextBox1.Text.Length) { LineToPrint line = LineToPrint.Get (charIndex, g, bounds.Position, bounds.Width, this.richTextBox1, ref nextWord, out nextIndex); if (line.Size.Height + bounds.Position.Y < bounds.Limit.Y) { linesToPrint.Add (line); charIndex = nextIndex; retval.RequiredSize.Width = Math.Max (retval.RequiredSize.Width, line.Size.Width); retval.RequiredSize.Height += line.Size.Height; bounds.Position.Y += line.Size.Height; } else { retval.Continued = true; break; } } retval.Fits = true; return retval; }
/// <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> /// 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 ) { SectionSizeValues retval = new SectionSizeValues(); retval.Fits = true; retval.RequiredSize = bounds.GetSizeF(); //DrawEditControl(g, bounds, true); return retval; }