// Token: 0x060067F4 RID: 26612 RVA: 0x001D36C0 File Offset: 0x001D18C0
private double LimitTotalWidthFromAnchor(double width, double elementMarginWidth)
{
Figure figure = (Figure)base.Element;
FigureHorizontalAnchor horizontalAnchor = figure.HorizontalAnchor;
double num;
if (FigureHelper.IsHorizontalPageAnchor(horizontalAnchor))
{
num = base.StructuralCache.CurrentFormatContext.PageWidth;
}
else if (FigureHelper.IsHorizontalContentAnchor(horizontalAnchor))
{
Thickness pageMargin = base.StructuralCache.CurrentFormatContext.PageMargin;
num = base.StructuralCache.CurrentFormatContext.PageWidth - pageMargin.Left - pageMargin.Right;
}
else
{
int num2;
double num3;
double num4;
double num5;
FigureHelper.GetColumnMetrics(base.StructuralCache, out num2, out num3, out num4, out num5);
num = num3;
}
if (width + elementMarginWidth > num)
{
width = Math.Max(TextDpi.MinWidth, num - elementMarginWidth);
}
return(width);
}
// ------------------------------------------------------------------
// Determines the max total width for this figure element, subtracts the element margins to determine the maximum size the
// Subpage can be formatted at.
// ------------------------------------------------------------------
private double LimitTotalWidthFromAnchor(double width, double elementMarginWidth)
{
Figure element = (Figure)Element;
FigureHorizontalAnchor horizAnchor = element.HorizontalAnchor;
double maxTotalWidth = 0.0;
// Value is in pixels. Now we limit value to max out depending on anchoring.
if (FigureHelper.IsHorizontalPageAnchor(horizAnchor))
{
maxTotalWidth = StructuralCache.CurrentFormatContext.PageWidth;
}
else if (FigureHelper.IsHorizontalContentAnchor(horizAnchor))
{
Thickness pageMargin = StructuralCache.CurrentFormatContext.PageMargin;
maxTotalWidth = StructuralCache.CurrentFormatContext.PageWidth - pageMargin.Left - pageMargin.Right;
}
else
{
double columnWidth, gap, rule;
int cColumns;
FigureHelper.GetColumnMetrics(StructuralCache, out cColumns, out columnWidth, out gap, out rule);
maxTotalWidth = columnWidth;
}
if ((width + elementMarginWidth) > maxTotalWidth)
{
width = Math.Max(TextDpi.MinWidth, maxTotalWidth - elementMarginWidth);
}
return(width);
}
// Token: 0x060067D1 RID: 26577 RVA: 0x001D1984 File Offset: 0x001CFB84
internal static double CalculateFigureHeight(StructuralCache structuralCache, Figure figure, FigureLength figureLength, out bool isHeightAuto)
{
double num;
if (figureLength.IsPage)
{
num = structuralCache.CurrentFormatContext.PageHeight * figureLength.Value;
}
else if (figureLength.IsContent)
{
Thickness pageMargin = structuralCache.CurrentFormatContext.PageMargin;
num = (structuralCache.CurrentFormatContext.PageHeight - pageMargin.Top - pageMargin.Bottom) * figureLength.Value;
}
else if (figureLength.IsColumn)
{
int num2;
double num3;
double num4;
double num5;
FigureHelper.GetColumnMetrics(structuralCache, out num2, out num3, out num4, out num5);
double num6 = figureLength.Value;
if (num6 > (double)num2)
{
num6 = (double)num2;
}
int num7 = (int)num6;
if ((double)num7 == num6 && num7 > 0)
{
num7--;
}
num = num3 * num6 + num4 * (double)num7;
}
else
{
num = FigureHelper.CalculateFigureCommon(figureLength);
}
if (!DoubleUtil.IsNaN(num))
{
FigureVerticalAnchor verticalAnchor = figure.VerticalAnchor;
if (FigureHelper.IsVerticalPageAnchor(verticalAnchor))
{
num = Math.Max(1.0, Math.Min(num, structuralCache.CurrentFormatContext.PageHeight));
}
else
{
Thickness pageMargin2 = structuralCache.CurrentFormatContext.PageMargin;
num = Math.Max(1.0, Math.Min(num, structuralCache.CurrentFormatContext.PageHeight - pageMargin2.Top - pageMargin2.Bottom));
}
TextDpi.EnsureValidPageWidth(ref num);
isHeightAuto = false;
}
else
{
num = structuralCache.CurrentFormatContext.PageHeight;
isHeightAuto = true;
}
return(num);
}
// ------------------------------------------------------------------
// 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: 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;
}
// Token: 0x060067F3 RID: 26611 RVA: 0x001D35D4 File Offset: 0x001D17D4
private int CalculateParagraphToColumnOffset(FigureHorizontalAnchor horizontalAnchor, PTS.FSRECT fsrcInColumn)
{
Invariant.Assert(FigureHelper.IsHorizontalColumnAnchor(horizontalAnchor));
int num;
if (horizontalAnchor == FigureHorizontalAnchor.ColumnLeft)
{
num = fsrcInColumn.u;
}
else if (horizontalAnchor == FigureHorizontalAnchor.ColumnRight)
{
num = fsrcInColumn.u + fsrcInColumn.du - 1;
}
else
{
num = fsrcInColumn.u + fsrcInColumn.du / 2 - 1;
}
int num2;
double num3;
double num4;
double num5;
FigureHelper.GetColumnMetrics(base.StructuralCache, out num2, out num3, out num4, out num5);
Invariant.Assert(num2 > 0);
int num6 = TextDpi.ToTextDpi(num3 + num4);
int num7 = (num - base.StructuralCache.CurrentFormatContext.PageMarginRect.u) / num6;
int num8 = base.StructuralCache.CurrentFormatContext.PageMarginRect.u + num7 * num6;
int num9 = TextDpi.ToTextDpi(num3);
int num10 = num8 - fsrcInColumn.u;
int num11 = num8 + num9 - (fsrcInColumn.u + fsrcInColumn.du);
if (horizontalAnchor == FigureHorizontalAnchor.ColumnLeft)
{
return(num10);
}
if (horizontalAnchor == FigureHorizontalAnchor.ColumnRight)
{
return(num11);
}
return((num11 + num10) / 2);
}
// Token: 0x060067D0 RID: 26576 RVA: 0x001D18A4 File Offset: 0x001CFAA4
internal static double CalculateFigureWidth(StructuralCache structuralCache, Figure figure, FigureLength figureLength, out bool isWidthAuto)
{
isWidthAuto = figureLength.IsAuto;
FigureHorizontalAnchor horizontalAnchor = figure.HorizontalAnchor;
double num;
if (figureLength.IsPage || (figureLength.IsAuto && FigureHelper.IsHorizontalPageAnchor(horizontalAnchor)))
{
num = structuralCache.CurrentFormatContext.PageWidth * figureLength.Value;
}
else if (figureLength.IsAbsolute)
{
num = FigureHelper.CalculateFigureCommon(figureLength);
}
else
{
int num2;
double num3;
double num4;
double num5;
FigureHelper.GetColumnMetrics(structuralCache, out num2, out num3, out num4, out num5);
if (figureLength.IsContent || (figureLength.IsAuto && FigureHelper.IsHorizontalContentAnchor(horizontalAnchor)))
{
num = (num3 * (double)num2 + num4 * (double)(num2 - 1)) * figureLength.Value;
}
else
{
double value = figureLength.Value;
int num6 = (int)value;
if ((double)num6 == value && num6 > 0)
{
num6--;
}
num = num3 * value + num4 * (double)num6;
}
}
Invariant.Assert(!DoubleUtil.IsNaN(num));
return(num);
}
// ------------------------------------------------------------------
// Height figure size calculation
// ------------------------------------------------------------------
internal static double CalculateFigureHeight(StructuralCache structuralCache, Figure figure, FigureLength figureLength, out bool isHeightAuto)
{
double value;
if (figureLength.IsPage)
{
value = (structuralCache.CurrentFormatContext.PageHeight) * figureLength.Value;
}
else if (figureLength.IsContent) // Column to be treated same as content
{
Thickness pageMargin = structuralCache.CurrentFormatContext.PageMargin;
value = (structuralCache.CurrentFormatContext.PageHeight - pageMargin.Top - pageMargin.Bottom) * figureLength.Value;
}
else if (figureLength.IsColumn)
{
// Height is calculated based on column width, since column height is the same as content. Per spec.
// Retrieve all column metrics for current page
int cColumns;
double columnWidth;
double gap;
double rule;
FigureHelper.GetColumnMetrics(structuralCache, out cColumns, out columnWidth, out gap, out rule);
// We do this to prevent a 2.0 columns from spanning 2.0 + gap, so we just check for edge
double lengthValue = figureLength.Value;
if (lengthValue > cColumns)
{
lengthValue = cColumns;
}
int columnGapsSpanned = (int)lengthValue;
if (columnGapsSpanned == lengthValue && columnGapsSpanned > 0)
{
columnGapsSpanned -= 1;
}
value = (columnWidth * lengthValue) + gap * columnGapsSpanned;
}
else
{
value = FigureHelper.CalculateFigureCommon(figureLength);
}
if (!double.IsNaN(value))
{
FigureVerticalAnchor verticalAnchor = figure.VerticalAnchor;
// Value is in pixels. Now we limit value to max out depending on anchoring.
if (FigureHelper.IsVerticalPageAnchor(verticalAnchor))
{
value = Math.Max(1, Math.Min(value, structuralCache.CurrentFormatContext.PageHeight));
}
else // Column and paragraph anchoring still max out at content height
{
Thickness pageMargin = structuralCache.CurrentFormatContext.PageMargin;
value = Math.Max(1, Math.Min(value, structuralCache.CurrentFormatContext.PageHeight - pageMargin.Top - pageMargin.Bottom));
}
TextDpi.EnsureValidPageWidth(ref value);
isHeightAuto = false;
}
else
{
value = structuralCache.CurrentFormatContext.PageHeight;
isHeightAuto = true;
}
return(value);
}
//-------------------------------------------------------------------
// CalcFigurePosition
//-------------------------------------------------------------------
internal void CalcFigurePosition(
FigureParaClient paraClient, // IN:
uint fswdir, // IN: current direction
ref PTS.FSRECT fsrcPage, // IN: page rectangle
ref PTS.FSRECT fsrcMargin, // IN: rectangle within page margins
ref PTS.FSRECT fsrcTrack, // IN: track rectangle
ref PTS.FSRECT fsrcFigurePreliminary, // IN: prelim figure rect calculated from figure props
int fMustPosition, // IN: must find position in this track?
int fInTextLine, // IN: it is attached to text line
out int fPushToNextTrack, // OUT: push to next track?
out PTS.FSRECT fsrcFlow, // OUT: FlowAround rectangle
out PTS.FSRECT fsrcOverlap, // OUT: Overlap rectangle
out PTS.FSBBOX fsbbox, // OUT: bbox
out PTS.FSRECT fsrcSearch) // OUT: search area for overlap
{
Figure element = (Figure)Element;
// If overlapping happens, let PTS find another position withing
// the track rectangle.
FigureHorizontalAnchor horizAnchor = element.HorizontalAnchor;
FigureVerticalAnchor vertAnchor = element.VerticalAnchor;
fsrcSearch = CalculateSearchArea(horizAnchor, vertAnchor, ref fsrcPage, ref fsrcMargin, ref fsrcTrack, ref fsrcFigurePreliminary);
if (vertAnchor == FigureVerticalAnchor.ParagraphTop &&
fsrcFigurePreliminary.v != fsrcMargin.v && // If we're not at the top of the column
((fsrcFigurePreliminary.v + fsrcFigurePreliminary.dv) > (fsrcTrack.v + fsrcTrack.dv)) && // And we exceed column height
!PTS.ToBoolean(fMustPosition)) // Can delay placement is handled by figure properties.
{
fPushToNextTrack = PTS.True;
}
else
{
fPushToNextTrack = PTS.False;
}
// Use rectangle proposed by PTS and make sure that figure fits completely in the page.
fsrcFlow = fsrcFigurePreliminary;
if (FigureHelper.IsHorizontalColumnAnchor(horizAnchor))
{
fsrcFlow.u += CalculateParagraphToColumnOffset(horizAnchor, fsrcFigurePreliminary);
}
// Apply horizontal and vertical offsets. Offsets are limited by page height and width
fsrcFlow.u += TextDpi.ToTextDpi(element.HorizontalOffset);
fsrcFlow.v += TextDpi.ToTextDpi(element.VerticalOffset);
// Overlap rectangle is the same as flow around rect
fsrcOverlap = fsrcFlow;
/* If we're anchored to column/content left or right, inflate our overlap width to prevent from aligning two figures right next to one another
* by incorporating column gap information */
if (!FigureHelper.IsHorizontalPageAnchor(horizAnchor) &&
horizAnchor != FigureHorizontalAnchor.ColumnCenter &&
horizAnchor != FigureHorizontalAnchor.ContentCenter)
{
double columnWidth, gap, rule;
int cColumns;
FigureHelper.GetColumnMetrics(StructuralCache, out cColumns, out columnWidth, out gap, out rule);
int duColumnWidth = TextDpi.ToTextDpi(columnWidth);
int duGapWidth = TextDpi.ToTextDpi(gap);
int duColumnWidthWithGap = duColumnWidth + duGapWidth;
int fullColumns = (fsrcOverlap.du / duColumnWidthWithGap);
int duRoundedToNearestColumn = ((fullColumns + 1) * duColumnWidthWithGap) - duGapWidth;
fsrcOverlap.du = duRoundedToNearestColumn; // Round overlap rect to nearest column
if (horizAnchor == FigureHorizontalAnchor.ContentRight ||
horizAnchor == FigureHorizontalAnchor.ColumnRight)
{
fsrcOverlap.u = (fsrcFlow.u + fsrcFlow.du + duGapWidth) - fsrcOverlap.du;
}
// Force search rect to only work vertically within overlap space.
fsrcSearch.u = fsrcOverlap.u;
fsrcSearch.du = fsrcOverlap.du;
}
// Bounding box is equal to actual size of the figure.
fsbbox = new PTS.FSBBOX();
fsbbox.fDefined = PTS.True;
fsbbox.fsrc = fsrcFlow;
}
