// Token: 0x060068EA RID: 26858 RVA: 0x001D98EC File Offset: 0x001D7AEC
internal Size MeasureChild(InlineObjectRun inlineObject)
{
double height = this._paraClient.Paragraph.StructuralCache.CurrentFormatContext.DocumentPageSize.Height;
if (!this._paraClient.Paragraph.StructuralCache.CurrentFormatContext.FinitePage)
{
height = double.PositiveInfinity;
}
return(inlineObject.UIElementIsland.DoLayout(new Size(TextDpi.FromTextDpi(this._durTrack), height), true, true));
}
/// <summary>
/// SetCellHeight
/// </summary>
/// <param name="cellParaClient">Cell para client</param>
/// <param name="tableParaClient">Table para client</param>
/// <param name="subpageBreakRecord">Break record if cell is broken</param>
/// <param name="fBrokenHere">Cell broken on this page/column</param>
/// <param name="fswdirTable">Flow direction</param>
/// <param name="dvrActual">Actual height</param>
internal void SetCellHeight(
CellParaClient cellParaClient, // IN: cell object
TableParaClient tableParaClient, // table's para client
IntPtr subpageBreakRecord, // not NULL if cell broken from previous page/column
int fBrokenHere, // TRUE if cell broken on this page/column: no reformatting
uint fswdirTable,
int dvrActual)
{
cellParaClient.ArrangeHeight = TextDpi.FromTextDpi(dvrActual);
}
// Token: 0x060069EE RID: 27118 RVA: 0x001E2040 File Offset: 0x001E0240
internal IInputElement InputHitTest(Point p)
{
IInputElement result = null;
if (!this.IsEmpty)
{
PTS.FSPOINT pt = TextDpi.ToTextPoint(p);
result = this.InputHitTestPage(pt);
}
return(result);
}
internal override List <Rect> GetRectangles(ContentElement e, int start, int length)
{
List <Rect> rectangles = new List <Rect>();
if (Paragraph.Element as ContentElement == e)
{
// We have found the element. Return rectangles for this paragraph.
GetRectanglesForParagraphElement(out rectangles);
}
else
{
// Query subpage details
PTS.FSSUBPAGEDETAILS subpageDetails;
PTS.Validate(PTS.FsQuerySubpageDetails(PtsContext.Context, _paraHandle.Value, out subpageDetails));
// Check subpage content for element. Subpage content may be simple or complex -
// depending of set of features used in the content of the page.
// (1) simple subpage (contains only one track)
// (2) complex subpage (contains columns)
if (PTS.ToBoolean(subpageDetails.fSimple))
{
// (1) simple subpage (contains only one track)
rectangles = PtsHelper.GetRectanglesInTrack(PtsContext, e, start, length, ref subpageDetails.u.simple.trackdescr);
}
else
{
// (2) complex page (contains columns)
// cBasicColumns == 0, means that subpage content is empty
if (subpageDetails.u.complex.cBasicColumns != 0)
{
// Retrieve description for each column.
PTS.FSTRACKDESCRIPTION[] arrayColumnDesc;
PtsHelper.TrackListFromSubpage(PtsContext, _paraHandle.Value, ref subpageDetails, out arrayColumnDesc);
// Arrange each track
for (int index = 0; index < arrayColumnDesc.Length; index++)
{
List <Rect> trackRectangles = PtsHelper.GetRectanglesInTrack(PtsContext, e, start, length, ref arrayColumnDesc[index]);
Invariant.Assert(trackRectangles != null);
if (trackRectangles.Count != 0)
{
// Add rectangles found in this track to all rectangles
rectangles.AddRange(trackRectangles);
}
}
}
}
rectangles = PtsHelper.OffsetRectangleList(rectangles, TextDpi.FromTextDpi(ContentRect.u), TextDpi.FromTextDpi(ContentRect.v));
}
Invariant.Assert(rectangles != null);
return(rectangles);
}
// Token: 0x06006777 RID: 26487 RVA: 0x001CEE94 File Offset: 0x001CD094
internal CellInfo(TableParaClient tpc, CellParaClient cpc)
{
this._rectTable = new Rect(TextDpi.FromTextDpi(tpc.Rect.u), TextDpi.FromTextDpi(tpc.Rect.v), TextDpi.FromTextDpi(tpc.Rect.du), TextDpi.FromTextDpi(tpc.Rect.dv));
this._rectCell = new Rect(TextDpi.FromTextDpi(cpc.Rect.u), TextDpi.FromTextDpi(cpc.Rect.v), TextDpi.FromTextDpi(cpc.Rect.du), TextDpi.FromTextDpi(cpc.Rect.dv));
this._autofitWidth = tpc.AutofitWidth;
this._columnWidths = new double[tpc.CalculatedColumns.Length];
for (int i = 0; i < tpc.CalculatedColumns.Length; i++)
{
this._columnWidths[i] = tpc.CalculatedColumns[i].DurWidth;
}
this._cell = cpc.Cell;
}
/// <summary>
/// Measure child UIElement.
/// </summary>
/// <param name="inlineObject">
/// Element whose size we are measuring
/// </param>
/// <returns>
/// Size of the child UIElement
/// </returns>
internal Size MeasureChild(InlineObjectRun inlineObject)
{
// Always measure at infinity for bottomless, consistent constraint.
double pageHeight = _paraClient.Paragraph.StructuralCache.CurrentFormatContext.DocumentPageSize.Height;
if (!_paraClient.Paragraph.StructuralCache.CurrentFormatContext.FinitePage)
{
pageHeight = Double.PositiveInfinity;
}
return(inlineObject.UIElementIsland.DoLayout(new Size(TextDpi.FromTextDpi(_durTrack), pageHeight), true, true));
}
internal ColumnResult(FlowDocumentPage page, ref PTS.FSTRACKDESCRIPTION trackDesc, Vector contentOffset)
{
_page = page;
_columnHandle = trackDesc.pfstrack;
_layoutBox = new Rect(
TextDpi.FromTextDpi(trackDesc.fsrc.u), TextDpi.FromTextDpi(trackDesc.fsrc.v),
TextDpi.FromTextDpi(trackDesc.fsrc.du), TextDpi.FromTextDpi(trackDesc.fsrc.dv));
_layoutBox.X += contentOffset.X;
_layoutBox.Y += contentOffset.Y;
_columnOffset = new Vector(TextDpi.FromTextDpi(trackDesc.fsrc.u), TextDpi.FromTextDpi(trackDesc.fsrc.v));
_hasTextContent = false;
}
// Token: 0x06006B33 RID: 27443 RVA: 0x001EF62C File Offset: 0x001ED82C
internal void CalcLineAscentDescent(int dcp, ref int dvrAscent, ref int dvrDescent)
{
this.EnsureLineProperties();
int num = dvrAscent + dvrDescent;
int num2 = TextDpi.ToTextDpi(this._lineProperties.CalcLineAdvanceForTextParagraph(this, dcp, TextDpi.FromTextDpi(num)));
if (num != num2)
{
double num3 = 1.0 * (double)num2 / (1.0 * (double)num);
dvrAscent = (int)((double)dvrAscent * num3);
dvrDescent = (int)((double)dvrDescent * num3);
}
}
// Token: 0x06006A25 RID: 27173 RVA: 0x001E3A68 File Offset: 0x001E1C68
internal void GetRowHeight(out PTS.FSKROWHEIGHTRESTRICTION fskrowheight, out int dvrAboveBelow)
{
bool flag = this.Row.Index == this.Row.RowGroup.Rows.Count - 1;
if (this.Row.HasRealCells || (flag && this._spannedCells.Length != 0))
{
fskrowheight = PTS.FSKROWHEIGHTRESTRICTION.fskrowheightNatural;
dvrAboveBelow = TextDpi.ToTextDpi(this.Table.InternalCellSpacing / 2.0);
return;
}
fskrowheight = PTS.FSKROWHEIGHTRESTRICTION.fskrowheightExactNoBreak;
dvrAboveBelow = 0;
}
internal ColumnResult(BaseParaClient subpage, ref PTS.FSTRACKDESCRIPTION trackDesc, Vector contentOffset)
{
// Subpage must be figure, floater or subpage paraclient
Invariant.Assert(subpage is SubpageParaClient || subpage is FigureParaClient || subpage is FloaterParaClient);
_subpage = subpage;
_columnHandle = trackDesc.pfstrack;
_layoutBox = new Rect(
TextDpi.FromTextDpi(trackDesc.fsrc.u), TextDpi.FromTextDpi(trackDesc.fsrc.v),
TextDpi.FromTextDpi(trackDesc.fsrc.du), TextDpi.FromTextDpi(trackDesc.fsrc.dv));
_layoutBox.X += contentOffset.X;
_layoutBox.Y += contentOffset.Y;
_columnOffset = new Vector(TextDpi.FromTextDpi(trackDesc.fsrc.u), TextDpi.FromTextDpi(trackDesc.fsrc.v));
}
protected override void OnArrange()
{
base.OnArrange();
((SubpageParagraph)base.Paragraph).UpdateSegmentLastFormatPositions();
PTS.FSSUBPAGEDETAILS fssubpagedetails;
PTS.Validate(PTS.FsQuerySubpageDetails(base.PtsContext.Context, this._paraHandle.Value, out fssubpagedetails));
MbpInfo mbpInfo = MbpInfo.FromElement(base.Paragraph.Element, base.Paragraph.StructuralCache.TextFormatterHost.PixelsPerDip);
if (base.ThisFlowDirection != base.PageFlowDirection)
{
mbpInfo.MirrorBP();
}
if (!this.IsFirstChunk)
{
mbpInfo.Border = new Thickness(mbpInfo.Border.Left, 0.0, mbpInfo.Border.Right, mbpInfo.Border.Bottom);
mbpInfo.Padding = new Thickness(mbpInfo.Padding.Left, 0.0, mbpInfo.Padding.Right, mbpInfo.Padding.Bottom);
}
if (!this.IsLastChunk)
{
mbpInfo.Border = new Thickness(mbpInfo.Border.Left, mbpInfo.Border.Top, mbpInfo.Border.Right, 0.0);
mbpInfo.Padding = new Thickness(mbpInfo.Padding.Left, mbpInfo.Padding.Top, mbpInfo.Padding.Right, 0.0);
}
this._contentRect.u = this._rect.u + mbpInfo.BPLeft;
this._contentRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), this._rect.du - mbpInfo.BPRight - mbpInfo.BPLeft);
this._contentRect.v = this._rect.v + mbpInfo.BPTop;
this._contentRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), this._rect.dv - mbpInfo.BPBottom - mbpInfo.BPTop);
this._paddingRect.u = this._rect.u + mbpInfo.BorderLeft;
this._paddingRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), this._rect.du - mbpInfo.BorderRight - mbpInfo.BorderLeft);
this._paddingRect.v = this._rect.v + mbpInfo.BorderTop;
this._paddingRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), this._rect.dv - mbpInfo.BorderBottom - mbpInfo.BorderTop);
if (PTS.ToBoolean(fssubpagedetails.fSimple))
{
this._pageContextOfThisPage.PageRect = new PTS.FSRECT(fssubpagedetails.u.simple.trackdescr.fsrc);
base.Paragraph.StructuralCache.CurrentArrangeContext.PushNewPageData(this._pageContextOfThisPage, fssubpagedetails.u.simple.trackdescr.fsrc, base.Paragraph.StructuralCache.CurrentArrangeContext.FinitePage);
PtsHelper.ArrangeTrack(base.PtsContext, ref fssubpagedetails.u.simple.trackdescr, fssubpagedetails.u.simple.fswdir);
base.Paragraph.StructuralCache.CurrentArrangeContext.PopPageData();
return;
}
this._pageContextOfThisPage.PageRect = new PTS.FSRECT(fssubpagedetails.u.complex.fsrc);
if (fssubpagedetails.u.complex.cBasicColumns != 0)
{
PTS.FSTRACKDESCRIPTION[] array;
PtsHelper.TrackListFromSubpage(base.PtsContext, this._paraHandle.Value, ref fssubpagedetails, out array);
for (int i = 0; i < array.Length; i++)
{
base.Paragraph.StructuralCache.CurrentArrangeContext.PushNewPageData(this._pageContextOfThisPage, array[i].fsrc, base.Paragraph.StructuralCache.CurrentArrangeContext.FinitePage);
PtsHelper.ArrangeTrack(base.PtsContext, ref array[i], fssubpagedetails.u.complex.fswdir);
base.Paragraph.StructuralCache.CurrentArrangeContext.PopPageData();
}
}
}
//------------------------------------------------------
//
// Public Methods
//
//------------------------------------------------------
#region Public Methods
#endregion Public Methods
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
/// <summary>
/// Arrange.
/// </summary>
/// <param name="du">U offset component of the cell's visual.</param>
/// <param name="dv">V offset component of the cell's visual.</param>
/// <param name="rcTable">Table's rectangle.. (in page flow dir)</param>
/// <param name="tableFlowDirection">Table's flow direction</param>
/// <param name="pageContext">Page context</param>
internal void Arrange(int du, int dv, PTS.FSRECT rcTable, FlowDirection tableFlowDirection, PageContext pageContext)
{
//
// Determine cell width based on column widths.
//
CalculatedColumn[] calculatedColumns = _tableParaClient.CalculatedColumns;
Debug.Assert(calculatedColumns != null &&
(Cell.ColumnIndex + Cell.ColumnSpan) <= calculatedColumns.Length);
double durCellSpacing = Table.InternalCellSpacing;
double durCellWidth = -durCellSpacing;
// find the width sum of all columns the cell spans
int i = Cell.ColumnIndex + Cell.ColumnSpan - 1;
do
{
durCellWidth += calculatedColumns[i].DurWidth + durCellSpacing;
} while (--i >= ColumnIndex);
if (tableFlowDirection != PageFlowDirection)
{
PTS.FSRECT pageRect = pageContext.PageRect;
PTS.Validate(PTS.FsTransformRectangle(PTS.FlowDirectionToFswdir(PageFlowDirection), ref pageRect, ref rcTable, PTS.FlowDirectionToFswdir(tableFlowDirection), out rcTable));
}
_rect.u = du + rcTable.u;
_rect.v = dv + rcTable.v;
_rect.du = TextDpi.ToTextDpi(durCellWidth);
_rect.dv = TextDpi.ToTextDpi(_arrangeHeight);
if (tableFlowDirection != PageFlowDirection)
{
PTS.FSRECT pageRect = pageContext.PageRect;
PTS.Validate(PTS.FsTransformRectangle(PTS.FlowDirectionToFswdir(tableFlowDirection), ref pageRect, ref _rect, PTS.FlowDirectionToFswdir(PageFlowDirection), out _rect));
}
_flowDirectionParent = tableFlowDirection;
_flowDirection = (FlowDirection)Paragraph.Element.GetValue(FrameworkElement.FlowDirectionProperty);
_pageContext = pageContext;
OnArrange();
if (_paraHandle.Value != IntPtr.Zero)
{
PTS.Validate(PTS.FsClearUpdateInfoInSubpage(PtsContext.Context, _paraHandle.Value), PtsContext);
}
}
// ------------------------------------------------------------------
// Determines what offset is required to convert a paragraph aligned figure into a column aligned figure.
// ------------------------------------------------------------------
private int CalculateParagraphToColumnOffset(FigureHorizontalAnchor horizontalAnchor, PTS.FSRECT fsrcInColumn)
{
Invariant.Assert(FigureHelper.IsHorizontalColumnAnchor(horizontalAnchor));
int uComparisonPoint;
// Depending on anchoring, only the anchored edge (center) is guaranteed to be inside of the column, so finding affected column
// requires us to compare against the anchored edge U position.
if (horizontalAnchor == FigureHorizontalAnchor.ColumnLeft)
{
uComparisonPoint = fsrcInColumn.u;
}
else if (horizontalAnchor == FigureHorizontalAnchor.ColumnRight)
{
uComparisonPoint = fsrcInColumn.u + fsrcInColumn.du - 1; // du is non-inclusive
}
else
{
uComparisonPoint = fsrcInColumn.u + (fsrcInColumn.du / 2) - 1; // du is non-inclusive
}
double columnWidth, gap, rule;
int cColumns;
FigureHelper.GetColumnMetrics(StructuralCache, out cColumns, out columnWidth, out gap, out rule);
Invariant.Assert(cColumns > 0);
int duColumnTotal = TextDpi.ToTextDpi(columnWidth + gap);
int affectedColumn = (uComparisonPoint - StructuralCache.CurrentFormatContext.PageMarginRect.u) / duColumnTotal;
int columnLeft = StructuralCache.CurrentFormatContext.PageMarginRect.u + affectedColumn * duColumnTotal;
int columnDU = TextDpi.ToTextDpi(columnWidth);
int totalMarginLeft = columnLeft - fsrcInColumn.u;
int totalMarginRight = (columnLeft + columnDU) - (fsrcInColumn.u + fsrcInColumn.du);
if (horizontalAnchor == FigureHorizontalAnchor.ColumnLeft)
{
return(totalMarginLeft);
}
else if (horizontalAnchor == FigureHorizontalAnchor.ColumnRight)
{
return(totalMarginRight);
}
else
{
return((totalMarginRight + totalMarginLeft) / 2);
}
}
// Token: 0x06006A2D RID: 27181 RVA: 0x001E3BB8 File Offset: 0x001E1DB8
public override TextEmbeddedObjectMetrics Format(double remainingParagraphWidth)
{
Size size = this._host.MeasureChild(this);
TextDpi.EnsureValidObjSize(ref size);
double baseline = size.Height;
double num = (double)this.UIElementIsland.Root.GetValue(TextBlock.BaselineOffsetProperty);
if (!DoubleUtil.IsNaN(num))
{
baseline = num;
}
return(new TextEmbeddedObjectMetrics(size.Width, size.Height, baseline));
}
internal unsafe void CalcHorizontalBBoxOfRow(int cCells, IntPtr *rgnmCell, IntPtr *rgpfsCell, out int urBBox, out int durBBox)
{
urBBox = 0;
durBBox = 0;
for (int i = 0; i < cCells; i++)
{
if (rgpfsCell[(IntPtr)i * (IntPtr)sizeof(IntPtr) / (IntPtr)sizeof(IntPtr)] != IntPtr.Zero)
{
CellParaClient cellParaClient = base.PtsContext.HandleToObject(rgpfsCell[(IntPtr)i * (IntPtr)sizeof(IntPtr) / (IntPtr)sizeof(IntPtr)]) as CellParaClient;
PTS.ValidateHandle(cellParaClient);
durBBox = TextDpi.ToTextDpi(cellParaClient.TableParaClient.TableDesiredWidth);
return;
}
}
}
// Token: 0x060068A0 RID: 26784 RVA: 0x001D8230 File Offset: 0x001D6430
internal void FormatAndDrawVisual(DrawingContext ctx, LineProperties lineProps, int ur, int vrBaseline)
{
bool flag = lineProps.FlowDirection == FlowDirection.RightToLeft;
this._host.Context = this;
try
{
TextLine textLine = this._host.TextFormatter.FormatLine(this._host, 0, 0.0, lineProps.FirstLineProps, null, new TextRunCache());
Point origin = new Point(TextDpi.FromTextDpi(ur), TextDpi.FromTextDpi(vrBaseline) - textLine.Baseline);
textLine.Draw(ctx, origin, flag ? InvertAxes.Horizontal : InvertAxes.None);
textLine.Dispose();
}
finally
{
this._host.Context = null;
}
}
// Token: 0x06006815 RID: 26645 RVA: 0x001D4A00 File Offset: 0x001D2C00
internal Geometry GetTightBoundingGeometryFromTextPositions(ReadOnlyCollection <ColumnResult> columns, ReadOnlyCollection <ParagraphResult> floatingElements, ITextPointer startPosition, ITextPointer endPosition, Rect visibleRect)
{
Geometry result = null;
Invariant.Assert(columns != null && columns.Count <= 1, "Columns collection is null.");
Invariant.Assert(floatingElements != null, "Floating element collection is null.");
ReadOnlyCollection <ParagraphResult> readOnlyCollection = (columns.Count > 0) ? columns[0].Paragraphs : new ReadOnlyCollection <ParagraphResult>(new List <ParagraphResult>(0));
if (readOnlyCollection.Count > 0 || floatingElements.Count > 0)
{
result = TextDocumentView.GetTightBoundingGeometryFromTextPositionsHelper(readOnlyCollection, floatingElements, startPosition, endPosition, TextDpi.FromTextDpi(this._dvrTopSpace), visibleRect);
Rect viewport = new Rect(0.0, 0.0, TextDpi.FromTextDpi(this._contentRect.du), TextDpi.FromTextDpi(this._contentRect.dv));
CaretElement.ClipGeometryByViewport(ref result, viewport);
}
return(result);
}
/// <summary>
/// Get inline object's measurement metrics.
/// </summary>
/// <param name="remainingParagraphWidth">Remaining paragraph width.</param>
/// <returns>Inline object metrics.</returns>
public override TextEmbeddedObjectMetrics Format(double remainingParagraphWidth)
{
Size desiredSize = _host.MeasureChild(this);
// Make sure that LS/PTS limitations are not exceeded for object's size.
TextDpi.EnsureValidObjSize(ref desiredSize);
double baseline = desiredSize.Height;
double baselineOffsetValue = (double)UIElementIsland.Root.GetValue(TextBlock.BaselineOffsetProperty);
if (!DoubleUtil.IsNaN(baselineOffsetValue))
{
baseline = baselineOffsetValue;
}
return(new TextEmbeddedObjectMetrics(desiredSize.Width, desiredSize.Height, baseline));
}
// Token: 0x0600686C RID: 26732 RVA: 0x001D739C File Offset: 0x001D559C
internal CharacterHit GetTextPositionFromDistance(int urDistance)
{
int num = this.CalculateUOffsetShift();
if (this._line.HasOverflowed && this.TextParagraph.Properties.TextTrimming != TextTrimming.None)
{
TextLine textLine = this._line.Collapse(new TextCollapsingProperties[]
{
this.GetCollapsingProps(this._wrappingWidth, this.TextParagraph.Properties)
});
Invariant.Assert(num == 0);
Invariant.Assert(textLine.HasCollapsed, "Line has not been collapsed");
return(textLine.GetCharacterHitFromDistance(TextDpi.FromTextDpi(urDistance)));
}
return(this._line.GetCharacterHitFromDistance(TextDpi.FromTextDpi(urDistance - num)));
}
// Token: 0x060067ED RID: 26605 RVA: 0x001D3304 File Offset: 0x001D1504
internal void CalcFigurePosition(FigureParaClient paraClient, uint fswdir, ref PTS.FSRECT fsrcPage, ref PTS.FSRECT fsrcMargin, ref PTS.FSRECT fsrcTrack, ref PTS.FSRECT fsrcFigurePreliminary, int fMustPosition, int fInTextLine, out int fPushToNextTrack, out PTS.FSRECT fsrcFlow, out PTS.FSRECT fsrcOverlap, out PTS.FSBBOX fsbbox, out PTS.FSRECT fsrcSearch)
{
Figure figure = (Figure)base.Element;
FigureHorizontalAnchor horizontalAnchor = figure.HorizontalAnchor;
FigureVerticalAnchor verticalAnchor = figure.VerticalAnchor;
fsrcSearch = this.CalculateSearchArea(horizontalAnchor, verticalAnchor, ref fsrcPage, ref fsrcMargin, ref fsrcTrack, ref fsrcFigurePreliminary);
if (verticalAnchor == FigureVerticalAnchor.ParagraphTop && fsrcFigurePreliminary.v != fsrcMargin.v && fsrcFigurePreliminary.v + fsrcFigurePreliminary.dv > fsrcTrack.v + fsrcTrack.dv && !PTS.ToBoolean(fMustPosition))
{
fPushToNextTrack = 1;
}
else
{
fPushToNextTrack = 0;
}
fsrcFlow = fsrcFigurePreliminary;
if (FigureHelper.IsHorizontalColumnAnchor(horizontalAnchor))
{
fsrcFlow.u += this.CalculateParagraphToColumnOffset(horizontalAnchor, fsrcFigurePreliminary);
}
fsrcFlow.u += TextDpi.ToTextDpi(figure.HorizontalOffset);
fsrcFlow.v += TextDpi.ToTextDpi(figure.VerticalOffset);
fsrcOverlap = fsrcFlow;
if (!FigureHelper.IsHorizontalPageAnchor(horizontalAnchor) && horizontalAnchor != FigureHorizontalAnchor.ColumnCenter && horizontalAnchor != FigureHorizontalAnchor.ContentCenter)
{
int num;
double d;
double d2;
double num2;
FigureHelper.GetColumnMetrics(base.StructuralCache, out num, out d, out d2, out num2);
int num3 = TextDpi.ToTextDpi(d);
int num4 = TextDpi.ToTextDpi(d2);
int num5 = num3 + num4;
int num6 = fsrcOverlap.du / num5;
int du = (num6 + 1) * num5 - num4;
fsrcOverlap.du = du;
if (horizontalAnchor == FigureHorizontalAnchor.ContentRight || horizontalAnchor == FigureHorizontalAnchor.ColumnRight)
{
fsrcOverlap.u = fsrcFlow.u + fsrcFlow.du + num4 - fsrcOverlap.du;
}
fsrcSearch.u = fsrcOverlap.u;
fsrcSearch.du = fsrcOverlap.du;
}
fsbbox = default(PTS.FSBBOX);
fsbbox.fDefined = 1;
fsbbox.fsrc = fsrcFlow;
}
/// <summary>
/// FormatCellBottomless
/// </summary>
/// <param name="fswdir">Text Direction</param>
/// <param name="width">Width of cell (height is specified by row props)</param>
/// <param name="fmtrbl">bottomless format result</param>
/// <param name="dvrUsed">dvr Used</param>
internal void FormatCellBottomless(uint fswdir, double width, out PTS.FSFMTRBL fmtrbl, out int dvrUsed)
{
IntPtr pfspara;
PTS.FSBBOX fsbbox;
IntPtr pmcsclientOut;
PTS.FSKCLEAR fskclearOut;
int dvrTopSpace;
int fPageBecomesUninterruptable;
PTS.FSPAP fspap;
if (CellParagraph.StructuralCache.DtrList != null)
{
CellParagraph.InvalidateStructure(TextContainerHelper.GetCPFromElement(CellParagraph.StructuralCache.TextContainer, CellParagraph.Element, ElementEdge.BeforeStart));
}
fspap = new PTS.FSPAP();
CellParagraph.GetParaProperties(ref fspap);
CellParagraph.FormatParaBottomless(this, PTS.FromBoolean(false),
fswdir, 0, TextDpi.ToTextDpi(width),
0, null, PTS.FSKCLEAR.fskclearNone,
PTS.FromBoolean(true),
out fmtrbl,
out pfspara,
out dvrUsed,
out fsbbox,
out pmcsclientOut,
out fskclearOut,
out dvrTopSpace,
out fPageBecomesUninterruptable);
if (pmcsclientOut != IntPtr.Zero)
{
MarginCollapsingState mcs = PtsContext.HandleToObject(pmcsclientOut) as MarginCollapsingState;
PTS.ValidateHandle(mcs);
dvrUsed += mcs.Margin;
mcs.Dispose();
pmcsclientOut = IntPtr.Zero;
}
_paraHandle.Value = pfspara;
}
/// <summary>
/// Returns row height for this row, depending on cell content (Real/Foreign/Etc)
/// </summary>
internal void GetRowHeight(out PTS.FSKROWHEIGHTRESTRICTION fskrowheight, out int dvrAboveBelow)
{
bool isLastRowOfRowGroup = (Row.Index == Row.RowGroup.Rows.Count - 1);
if (Row.HasRealCells ||
(isLastRowOfRowGroup && _spannedCells.Length > 0))
{
// Use current format context's page height to limit vertical cell spacing
fskrowheight = PTS.FSKROWHEIGHTRESTRICTION.fskrowheightNatural;
dvrAboveBelow = TextDpi.ToTextDpi(Table.InternalCellSpacing / 2.0);
}
else
{
fskrowheight = PTS.FSKROWHEIGHTRESTRICTION.fskrowheightExactNoBreak;
dvrAboveBelow = 0;
}
}
// Token: 0x06006A3E RID: 27198 RVA: 0x001E3D28 File Offset: 0x001E1F28
internal void GetPageDimensions(out uint fswdir, out int fHeaderFooterAtTopBottom, out int durPage, out int dvrPage, ref PTS.FSRECT fsrcMargin)
{
Size pageSize = this._structuralCache.CurrentFormatContext.PageSize;
durPage = TextDpi.ToTextDpi(pageSize.Width);
dvrPage = TextDpi.ToTextDpi(pageSize.Height);
Thickness pageMargin = this._structuralCache.CurrentFormatContext.PageMargin;
TextDpi.EnsureValidPageMargin(ref pageMargin, pageSize);
fsrcMargin.u = TextDpi.ToTextDpi(pageMargin.Left);
fsrcMargin.v = TextDpi.ToTextDpi(pageMargin.Top);
fsrcMargin.du = durPage - TextDpi.ToTextDpi(pageMargin.Left + pageMargin.Right);
fsrcMargin.dv = dvrPage - TextDpi.ToTextDpi(pageMargin.Top + pageMargin.Bottom);
this.StructuralCache.PageFlowDirection = (FlowDirection)this._structuralCache.PropertyOwner.GetValue(FrameworkElement.FlowDirectionProperty);
fswdir = PTS.FlowDirectionToFswdir(this.StructuralCache.PageFlowDirection);
fHeaderFooterAtTopBottom = 0;
}
private unsafe void CreateSubpageFiniteHelper(
PtsContext ptsContext, // IN: ptr to FS context
IntPtr brParaIn, // IN: break record---use if !NULL
int fFromPreviousPage, // IN: break record was created on previous page
IntPtr nSeg, // IN: name of the segment to start from-if pointer to break rec is NULL
IntPtr pFtnRej, // IN: pftnrej
int fEmptyOk, // IN: fEmptyOK
int fSuppressTopSpace, // IN: fSuppressTopSpace
uint fswdir, // IN: fswdir
int lWidth, // IN: width of subpage
int lHeight, // IN: height of subpage
ref PTS.FSRECT rcMargin, // IN: rectangle within subpage margins
int cColumns, // IN: number of columns
PTS.FSCOLUMNINFO[] columnInfoCollection, // IN: array of column info
int fApplyColumnBalancing, // IN: apply column balancing?
PTS.FSKSUPPRESSHARDBREAKBEFOREFIRSTPARA fsksuppresshardbreakbeforefirstparaIn,
// IN: suppress breaks at track start?
out PTS.FSFMTR fsfmtr, // OUT: why formatting was stopped
out IntPtr pSubPage, // OUT: ptr to the subpage
out IntPtr brParaOut, // OUT: break record of the subpage
out int dvrUsed, // OUT: dvrUsed
out PTS.FSBBOX fsBBox, // OUT: subpage bbox
out IntPtr pfsMcsClient, // OUT: margin collapsing state at the bottom
out int topSpace) // OUT: top space due to collapsed margins
{
// Exceptions don't need to pop, as the top level measure context will be nulled out if thrown.
StructuralCache.CurrentFormatContext.PushNewPageData(new Size(TextDpi.FromTextDpi(lWidth), TextDpi.FromTextDpi(lHeight)),
new Thickness(),
false,
true);
fixed(PTS.FSCOLUMNINFO *rgColumnInfo = columnInfoCollection)
{
PTS.Validate(PTS.FsCreateSubpageFinite(ptsContext.Context, brParaIn, fFromPreviousPage, nSeg,
pFtnRej, fEmptyOk, fSuppressTopSpace, fswdir, lWidth, lHeight,
ref rcMargin, cColumns, rgColumnInfo, PTS.False,
0, null, null, 0, null, null, PTS.False,
fsksuppresshardbreakbeforefirstparaIn,
out fsfmtr, out pSubPage, out brParaOut, out dvrUsed, out fsBBox, out pfsMcsClient, out topSpace), ptsContext);
}
StructuralCache.CurrentFormatContext.PopPageData();
}
protected override void OnArrange()
{
base.OnArrange();
PTS.FSFLOATERDETAILS fsfloaterdetails;
PTS.Validate(PTS.FsQueryFloaterDetails(base.PtsContext.Context, this._paraHandle.Value, out fsfloaterdetails));
this._rect = fsfloaterdetails.fsrcFloater;
MbpInfo mbpInfo = MbpInfo.FromElement(base.Paragraph.Element, base.Paragraph.StructuralCache.TextFormatterHost.PixelsPerDip);
if (base.ParentFlowDirection != base.PageFlowDirection)
{
mbpInfo.MirrorMargin();
PTS.FSRECT pageRect = this._pageContext.PageRect;
PTS.Validate(PTS.FsTransformRectangle(PTS.FlowDirectionToFswdir(base.ParentFlowDirection), ref pageRect, ref this._rect, PTS.FlowDirectionToFswdir(base.PageFlowDirection), out this._rect));
}
this._rect.u = this._rect.u + mbpInfo.MarginLeft;
this._rect.du = this._rect.du - (mbpInfo.MarginLeft + mbpInfo.MarginRight);
this._rect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), this._rect.du);
this._rect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), this._rect.dv);
}
// Token: 0x06006B64 RID: 27492 RVA: 0x001F04C4 File Offset: 0x001EE6C4
private void FormatUIElement(int durAvailable, out PTS.FSBBOX fsbbox)
{
MbpInfo mbpInfo = MbpInfo.FromElement(base.Element, base.StructuralCache.TextFormatterHost.PixelsPerDip);
double width = TextDpi.FromTextDpi(Math.Max(1, durAvailable - (mbpInfo.MBPLeft + mbpInfo.MBPRight)));
double num;
if (this.SizeToFigureParent)
{
if (base.StructuralCache.CurrentFormatContext.FinitePage)
{
num = base.StructuralCache.CurrentFormatContext.PageHeight;
}
else
{
Figure figure = (Figure)((BlockUIContainer)base.Element).Parent;
Invariant.Assert(figure.Height.IsAbsolute);
num = figure.Height.Value;
}
num = Math.Max(TextDpi.FromTextDpi(1), num - TextDpi.FromTextDpi(mbpInfo.MBPTop + mbpInfo.MBPBottom));
this.UIElementIsland.DoLayout(new Size(width, num), false, false);
fsbbox.fsrc = default(PTS.FSRECT);
fsbbox.fsrc.du = durAvailable;
fsbbox.fsrc.dv = TextDpi.ToTextDpi(num) + mbpInfo.BPTop + mbpInfo.BPBottom;
fsbbox.fDefined = 1;
return;
}
if (base.StructuralCache.CurrentFormatContext.FinitePage)
{
Thickness documentPageMargin = base.StructuralCache.CurrentFormatContext.DocumentPageMargin;
num = base.StructuralCache.CurrentFormatContext.DocumentPageSize.Height - documentPageMargin.Top - documentPageMargin.Bottom - TextDpi.FromTextDpi(mbpInfo.MBPTop + mbpInfo.MBPBottom);
num = Math.Max(TextDpi.FromTextDpi(1), num);
}
else
{
num = double.PositiveInfinity;
}
Size size = this.UIElementIsland.DoLayout(new Size(width, num), false, true);
fsbbox.fsrc = default(PTS.FSRECT);
fsbbox.fsrc.du = durAvailable;
fsbbox.fsrc.dv = TextDpi.ToTextDpi(size.Height) + mbpInfo.BPTop + mbpInfo.BPBottom;
fsbbox.fDefined = 1;
}
// ------------------------------------------------------------------
// Arrange floater
//
// rcFloater - rectangle of the floater
// rcHostPara - rectangle of the host text paragraph.
// ------------------------------------------------------------------
internal override void ArrangeFloater(PTS.FSRECT rcFloater, PTS.FSRECT rcHostPara, uint fswdirParent, PageContext pageContext)
{
// If alignment is set to Stretch and floater width is less than para width, center it
if (IsFloaterHorizontallyCentered(rcFloater, rcHostPara))
{
rcFloater.u = rcHostPara.u + (rcHostPara.du - rcFloater.du) / 2;
}
// Set paragraph rectangle (relative to the page)
_rect = rcFloater;
// Adjust rect to account for margins
// Add margin values to rect offsets and subtract them from rect widths
MbpInfo mbp = MbpInfo.FromElement(Paragraph.Element, Paragraph.StructuralCache.TextFormatterHost.PixelsPerDip);
_rect.v += mbp.MarginTop;
_rect.dv -= mbp.MarginTop + mbp.MarginBottom;
_rect.u += mbp.MarginLeft;
_rect.du -= mbp.MarginLeft + mbp.MarginRight;
_flowDirectionParent = PTS.FswdirToFlowDirection(fswdirParent);
_flowDirection = (FlowDirection)Paragraph.Element.GetValue(FrameworkElement.FlowDirectionProperty);
_pageContext = pageContext;
if (ThisFlowDirection != PageFlowDirection)
{
mbp.MirrorBP();
}
_contentRect.u = _rect.u + mbp.BPLeft;
_contentRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du - mbp.BPRight - mbp.BPLeft);
_contentRect.v = _rect.v + mbp.BPTop;
_contentRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv - mbp.BPBottom - mbp.BPTop);
_paddingRect.u = _rect.u + mbp.BorderLeft;
_paddingRect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du - mbp.BorderRight - mbp.BorderLeft);
_paddingRect.v = _rect.v + mbp.BorderTop;
_paddingRect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv - mbp.BorderBottom - mbp.BorderTop);
// Do paragraph specifc arrange
OnArrange();
}
internal unsafe static void GetColumnsInfo(ColumnPropertiesGroup columnProperties, double lineHeight, double pageWidth, double pageFontSize, FontFamily pageFontFamily, int cColumns, PTS.FSCOLUMNINFO *pfscolinfo, bool enableColumns)
{
double columnRuleWidth = columnProperties.ColumnRuleWidth;
double num;
double num2;
double num3;
PtsHelper.GetColumnMetrics(columnProperties, pageWidth, pageFontSize, pageFontFamily, enableColumns, cColumns, ref lineHeight, out num, out num2, out num3);
if (!columnProperties.IsColumnWidthFlexible)
{
for (int i = 0; i < cColumns; i++)
{
pfscolinfo[i].durBefore = TextDpi.ToTextDpi((i == 0) ? 0.0 : num3);
pfscolinfo[i].durWidth = TextDpi.ToTextDpi(num);
pfscolinfo[i].durBefore = Math.Max(0, pfscolinfo[i].durBefore);
pfscolinfo[i].durWidth = Math.Max(1, pfscolinfo[i].durWidth);
}
return;
}
for (int j = 0; j < cColumns; j++)
{
if (columnProperties.ColumnSpaceDistribution == ColumnSpaceDistribution.Right)
{
pfscolinfo[j].durWidth = TextDpi.ToTextDpi((j == cColumns - 1) ? (num + num2) : num);
}
else if (columnProperties.ColumnSpaceDistribution == ColumnSpaceDistribution.Left)
{
pfscolinfo[j].durWidth = TextDpi.ToTextDpi((j == 0) ? (num + num2) : num);
}
else
{
pfscolinfo[j].durWidth = TextDpi.ToTextDpi(num + num2 / (double)cColumns);
}
if (pfscolinfo[j].durWidth > TextDpi.ToTextDpi(pageWidth))
{
pfscolinfo[j].durWidth = TextDpi.ToTextDpi(pageWidth);
}
pfscolinfo[j].durBefore = TextDpi.ToTextDpi((j == 0) ? 0.0 : num3);
pfscolinfo[j].durBefore = Math.Max(0, pfscolinfo[j].durBefore);
pfscolinfo[j].durWidth = Math.Max(1, pfscolinfo[j].durWidth);
}
}
/// <summary>
/// Returns tight bounding path geometry.
/// </summary>
internal Geometry GetTightBoundingGeometryFromTextPositions(ReadOnlyCollection <ColumnResult> columns, ReadOnlyCollection <ParagraphResult> floatingElements, ITextPointer startPosition, ITextPointer endPosition, Rect visibleRect)
{
Geometry geometry = null;
// Floater always has one column, so we can skip getting a column from the text position range
Invariant.Assert(columns != null && columns.Count <= 1, "Columns collection is null.");
Invariant.Assert(floatingElements != null, "Floating element collection is null.");
ReadOnlyCollection <ParagraphResult> paragraphs = (columns.Count > 0) ? columns[0].Paragraphs : new ReadOnlyCollection <ParagraphResult>(new List <ParagraphResult>(0));
if (paragraphs.Count > 0 || floatingElements.Count > 0)
{
geometry = TextDocumentView.GetTightBoundingGeometryFromTextPositionsHelper(paragraphs, floatingElements, startPosition, endPosition, TextDpi.FromTextDpi(_dvrTopSpace), visibleRect);
// restrict geometry to the floater's content rect boundary.
// because of end-of-line / end-of-para simulation calculated geometry could be larger.
Rect viewport = new Rect(0, 0, TextDpi.FromTextDpi(_contentRect.du), TextDpi.FromTextDpi(_contentRect.dv));
CaretElement.ClipGeometryByViewport(ref geometry, viewport);
}
return(geometry);
}
// Token: 0x06006828 RID: 26664 RVA: 0x001D5528 File Offset: 0x001D3728
private void AdjustDurAvailable(double specifiedWidth, ref int durAvailable, out int subpageWidth)
{
MbpInfo mbpInfo = MbpInfo.FromElement(base.Element, base.StructuralCache.TextFormatterHost.PixelsPerDip);
if (double.IsNaN(specifiedWidth))
{
subpageWidth = Math.Max(1, durAvailable - (mbpInfo.MBPLeft + mbpInfo.MBPRight));
return;
}
TextDpi.EnsureValidPageWidth(ref specifiedWidth);
int num = TextDpi.ToTextDpi(specifiedWidth);
if (num + mbpInfo.MarginRight + mbpInfo.MarginLeft <= durAvailable)
{
durAvailable = num + mbpInfo.MarginLeft + mbpInfo.MarginRight;
subpageWidth = Math.Max(1, num - (mbpInfo.BPLeft + mbpInfo.BPRight));
return;
}
subpageWidth = Math.Max(1, durAvailable - (mbpInfo.MBPLeft + mbpInfo.MBPRight));
}
