private void RenderPhotoRow(PhotoRowLayout layout, ITableRow row) { // In the design we represent a photo row as a pair of table rows // without a table: one row for the photos, and the other for the // captions. This design is useful for PDF, and requires special // handling of borders to make the vertical pairs of cells (photo // cell and caption cell) appear as a single cell. But it's not // necessary in Word because we can just add the photo and caption // as two paragraphs in a single cell. So deconstruct the photo // row into its pairs of cells and then render each pair as a // single cell. for (int x = 0; x < layout.NumPhotos; ++x) { PhotoLayout photoCell = (PhotoLayout)layout.PhotoRow.GetSubLayoutAtIndex(x).GetSubLayoutAtIndex(0); TextLayout captionCell = (TextLayout)layout.CaptionRow.GetSubLayoutAtIndex(x).GetSubLayoutAtIndex(0); s.TableCellStyle cellStyle = null; if (layout.Style != null) { s.PhotoStyle photoStyle = (s.PhotoStyle)layout.Style; cellStyle = new s.TableCellStyle { Padding = photoStyle.Padding }; } ITableCell cell = row.AddCell(1, cellStyle, layout.TrackingInfo); RenderPhoto(photoCell, cell); RenderText(captionCell, cell); } }
/// <summary> /// Copy constructor used during page break handling. /// </summary> public PhotoRowLayout(PhotoRowLayout src) : base(src) { _numCells = src._numCells; _numPhotos = src._numPhotos; _cellWidth = src._cellWidth; }
public override Layout DoPageBreak() { using (new TraceContextPusher(_generator, _traceContext)) { // We never split a photo row, so on a page break we always move all // of our content into a copy of ourself, and return that copy. This // leaves ourself empty, and the base class implementation will then // remove us from our container. PhotoRowLayout copy = new PhotoRowLayout(this); copy._photoRow = this._photoRow; copy._captionRow = this._captionRow; this.RemoveSubLayout(_photoRow); this.RemoveSubLayout(_captionRow); copy.AddSubLayout(_photoRow); copy.AddSubLayout(_captionRow); // Empty ourself _subLayouts.Clear(); _photoRow = null; _captionRow = null; return(copy); } }
private void RenderPhotoRowLayout(PhotoRowLayout layout, Page page) { for (int x = 0; x < layout.NumPhotos; ++x) { // There's always a photo... PhotoLayout photoCell = (PhotoLayout)layout.PhotoRow.GetSubLayoutAtIndex(x).GetSubLayoutAtIndex(0); RenderPhotoLayout(photoCell, page); // but not always a caption TableCellLayout captionCell = (TableCellLayout)layout.CaptionRow.GetSubLayoutAtIndex(x); if (captionCell.NumSubLayouts > 0) { TextLayout caption = (TextLayout)captionCell.GetSubLayoutAtIndex(0); RenderTextLayout(caption, page); } } }
public override Position Draft(Rectangle bounds) { if (!_staticConditionsSatisfied) { return(bounds.BottomLeft); } using (new TraceContextPusher(_generator, _traceContext)) { Trace("start bounds={0}", bounds); // A photo table is implemented like this: Create one or more photo // row layouts and add them all as normal sequential sublayouts of // the table. Assign photos to the rows, where the number of photos // in each row is defined by the table's _columns property. The last // row will have fewer photos if the number of photos is not an even // multiple of the number of columns. // // A photo row is implemented as a normal table with two normal // rows, one for the photos and the other for the captions. A photo // row cannot be split across a page break, but the photo table // can be split in the normal way by moving some photo rows onto // the next page. // If we have no photo content then don't draw ourself at all. We know // that _columns is greater than zero because we checked it during load. if (_photos.Count == 0) { return(bounds.BottomLeft); } // Work out the column width. All photo cells will have the same width. // We don't apply padding to the table or to the row, because the table // is just structural and isn't part of the designed layout. When we // get down to the photo layout we'll apply padding there. _columnWidth = bounds.Width / _columns; // Work out the photo size from the column width if (_columnWidth < _maxPhotoSize.Width) { double scale = (double)_columnWidth / (double)_maxPhotoSize.Width; int scaledWidth = (int)(_maxPhotoSize.Width * scale); int scaledHeight = (int)(_maxPhotoSize.Height * scale); _maxPhotoSize = new Size(scaledWidth, scaledHeight); } for (int photoIndex = 0; photoIndex < _photos.Count;) // will be incremented inside the inner loop { PhotoRowLayout row = new PhotoRowLayout( _columns, _generator, _trackingInfo.LineNumber, _trackingInfo.LinePosition); AddSubLayout(row); while (row.NumPhotos < _columns) { if (photoIndex >= _photos.Count) { break; } CompositePhotoLayout photo = _photos[photoIndex++]; row.AddPhoto(photo.PhotoLayout, photo.CaptionLayout); } } // Pass the column width on to the rows foreach (PhotoRowLayout row in _subLayouts) { row.SetColumnWidth(_columnWidth); } Trace("end _bounds={0}", _bounds); return(base.Draft(bounds)); } }