/// <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> /// 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> /// Sizes rows and figures out how many will fit in the given bounds. /// </summary> /// <param name="g">Graphics object used for measuring</param> /// <param name="bounds">Maximum bounds allowed for table</param> /// <returns>The number of data rows that will fit</returns> int FindDataRowsFit(Graphics g, ref Bounds bounds) { int rowsThatFit = 0; int index = this.rowIndex; rowHeights = new ArrayList(); // Find the rows that fit... while (index < this.TotalRows) { bool includeRowLine = index < TotalRows - 1; float rowHeight = SizePrintRow(g, index, bounds.Position.X, bounds.Position.Y, bounds.Width, this.MaxDetailRowHeight, true, includeRowLine); if (bounds.SizeFits(new SizeF(GetPageInfo().Width, rowHeight))) { Debug.Assert(rowHeights.Count == rowsThatFit, "rowHeights.Count is not equal to index"); rowHeights.Add(rowHeight); bounds.Position.Y += rowHeight; index++; rowsThatFit++; } else { if (rowHeights.Count > 0) { // oops, it doesn't fit.. we'll resize // the last row without the line. rowHeight = SizePrintRow(g, index - 1, bounds.Position.X, bounds.Position.Y, bounds.Width, this.MaxDetailRowHeight, true, false); bounds.Position.Y -= ((float)rowHeights[rowHeights.Count - 1]); bounds.Position.Y += rowHeight; rowHeights[rowHeights.Count - 1] = rowHeight; } break; } } return(rowsThatFit); }
/// <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> /// 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> /// 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> /// Sizes rows and figures out how many will fit in the given bounds. /// </summary> /// <param name="g">Graphics object used for measuring</param> /// <param name="bounds">Maximum bounds allowed for table</param> /// <returns>The number of data rows that will fit</returns> int FindDataRowsFit(Graphics g, ref Bounds bounds) { int rowsThatFit = 0; int index = this.rowIndex; rowHeights = new ArrayList(); // Find the rows that fit... while (index < this.TotalRows) { bool includeRowLine = index < TotalRows - 1; float rowHeight = SizePrintRow (g, index, bounds.Position.X, bounds.Position.Y, bounds.Width, this.MaxDetailRowHeight, true, includeRowLine); if (bounds.SizeFits(new SizeF (GetPageInfo().Width, rowHeight))) { Debug.Assert (rowHeights.Count == rowsThatFit, "rowHeights.Count is not equal to index"); rowHeights.Add (rowHeight); bounds.Position.Y += rowHeight; index++; rowsThatFit++; } else { if (rowHeights.Count > 0) { // oops, it doesn't fit.. we'll resize // the last row without the line. rowHeight = SizePrintRow (g, index - 1, bounds.Position.X, bounds.Position.Y, bounds.Width, this.MaxDetailRowHeight, true, false); bounds.Position.Y -= ((float)rowHeights[rowHeights.Count - 1]); bounds.Position.Y += rowHeight; rowHeights[rowHeights.Count - 1] = rowHeight; } break; } } return rowsThatFit; }
/// <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> /// 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> /// Sizes rows and figures out how many will fit in the given bounds. /// </summary> /// <param name="g">Graphics object used for measuring</param> /// <param name="bounds">Maximum bounds allowed for table</param> /// <returns>The number of data rows that will fit</returns> int FindDataRowsFit(Graphics g, ref Bounds bounds) { int rowsThatFit = 0; int index = this.rowIndex; rowHeights = new ArrayList(); // Find the rows that fit... while (index < this.TotalRows) { bool includeRowLine = index < TotalRows - 1; float rowHeight = SizePrintRow (g, index, bounds.Position.X, bounds.Position.Y, bounds.Width, this.MaxDetailRowHeight, true, includeRowLine); if (bounds.SizeFits(new SizeF (GetPageInfo().Width, rowHeight))) { Debug.Assert (rowHeights.Count == rowsThatFit, "rowHeights.Count is not equal to index"); rowHeights.Add (rowHeight); bounds.Position.Y += rowHeight; index++; rowsThatFit++; } else { if (rowHeights.Count > 0) { // oops, it doesn't fit.. we'll resize // the last row without the line. rowHeight = SizePrintRow (g, index - 1, bounds.Position.X, bounds.Position.Y, bounds.Width, this.MaxDetailRowHeight, true, false); bounds.Position.Y -= ((float)rowHeights[rowHeights.Count - 1]); bounds.Position.Y += rowHeight; rowHeights[rowHeights.Count - 1] = rowHeight; } break; } } if (minDataRowsFit != 0 && index < this.TotalRows) { if (rowsThatFit < minDataRowsFit) rowsThatFit = 0; else // make sure at least minDataRowsFit rows are left for the next page { int rowsLeft = this.TotalRows - index - ((this.ShowSummaryRow) ? 1 : 0); if (rowsLeft + rowsThatFit < (2 * minDataRowsFit)) rowsThatFit = 0; // Force all onto next page else if(minDataRowsFit > rowsLeft) rowsThatFit -= (minDataRowsFit - rowsLeft); // Leave enough for next page. } } return rowsThatFit; }