internal ReadOnlyCollection <ParagraphResult> GetChildrenParagraphResults(out bool hasTextContent)
{
#if TEXTPANELLAYOUTDEBUG
TextPanelDebug.IncrementCounter("ContainerPara.GetParagraphs", TextPanelDebug.Category.TextView);
#endif
// Query paragraph details
PTS.FSSUBTRACKDETAILS subtrackDetails;
PTS.Validate(PTS.FsQuerySubtrackDetails(PtsContext.Context, _paraHandle.Value, out subtrackDetails));
// hasTextContent is set to true if any of the children paragraphs has text content, not just attached objects
hasTextContent = false;
if (subtrackDetails.cParas == 0)
{
return(new ReadOnlyCollection <ParagraphResult>(new List <ParagraphResult>(0)));
}
// Get list of paragraphs
PTS.FSPARADESCRIPTION [] arrayParaDesc;
PtsHelper.ParaListFromSubtrack(PtsContext, _paraHandle.Value, ref subtrackDetails, out arrayParaDesc);
List <ParagraphResult> paragraphResults = new List <ParagraphResult>(arrayParaDesc.Length);
for (int i = 0; i < arrayParaDesc.Length; i++)
{
BaseParaClient paraClient = PtsContext.HandleToObject(arrayParaDesc[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
ParagraphResult paragraphResult = paraClient.CreateParagraphResult();
if (paragraphResult.HasTextContent)
{
hasTextContent = true;
}
paragraphResults.Add(paragraphResult);
}
return(new ReadOnlyCollection <ParagraphResult>(paragraphResults));
}
// ------------------------------------------------------------------
// Returns a collection of ParagraphResults for the column's paragraphs.
//
// pfstrack - Pointer to PTS track representing a column.
// parentOffset - Parent offset from the top of the page.
// hasTextContent - true if any of the children paras has text content
// ------------------------------------------------------------------
internal ReadOnlyCollection <ParagraphResult> GetParagraphResultsFromColumn(IntPtr pfstrack, Vector parentOffset, out bool hasTextContent)
{
// Get track details
PTS.FSTRACKDETAILS trackDetails;
PTS.Validate(PTS.FsQueryTrackDetails(PtsContext.Context, pfstrack, out trackDetails));
hasTextContent = false;
if (trackDetails.cParas == 0)
{
return(null);
}
PTS.FSPARADESCRIPTION[] arrayParaDesc;
PtsHelper.ParaListFromTrack(PtsContext, pfstrack, ref trackDetails, out arrayParaDesc);
List <ParagraphResult> paragraphResults = new List <ParagraphResult>(arrayParaDesc.Length);
for (int i = 0; i < arrayParaDesc.Length; i++)
{
BaseParaClient paraClient = PtsContext.HandleToObject(arrayParaDesc[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
ParagraphResult paragraphResult = paraClient.CreateParagraphResult();
if (paragraphResult.HasTextContent)
{
hasTextContent = true;
}
paragraphResults.Add(paragraphResult);
}
return(new ReadOnlyCollection <ParagraphResult>(paragraphResults));
}
// ------------------------------------------------------------------
// Returns ArrayList of rectangles for the ContentElement e within the
// list of paragraphs. If the element is not found, returns empty list.
// start: int representing start offset of e
// length: int representing number of positions occupied by e
// ------------------------------------------------------------------
internal static List <Rect> GetRectanglesInParaList(
PtsContext ptsContext,
ContentElement e,
int start,
int length,
PTS.FSPARADESCRIPTION[] arrayParaDesc)
{
List <Rect> rectangles = new List <Rect>();
for (int index = 0; index < arrayParaDesc.Length; index++)
{
BaseParaClient paraClient = ptsContext.HandleToObject(arrayParaDesc[index].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
if (start < paraClient.Paragraph.ParagraphEndCharacterPosition)
{
// Element lies within the paraClient boundaries.
rectangles = paraClient.GetRectangles(e, start, length);
// Rectangles collection should not be null for consistency
Invariant.Assert(rectangles != null);
if (rectangles.Count != 0)
{
// Element cannot span more than one para client in the same track, so we stop
// if the element is found and the rectangles are calculated
break;
}
}
}
return(rectangles);
}
internal static TextContentRange TextContentRangeFromTrack(
PtsContext ptsContext,
IntPtr pfstrack)
{
// Get track details
PTS.FSTRACKDETAILS trackDetails;
PTS.Validate(PTS.FsQueryTrackDetails(ptsContext.Context, pfstrack, out trackDetails));
// Combine ranges from all nested paragraphs.
TextContentRange textContentRange = new TextContentRange();
if (trackDetails.cParas != 0)
{
PTS.FSPARADESCRIPTION[] arrayParaDesc;
PtsHelper.ParaListFromTrack(ptsContext, pfstrack, ref trackDetails, out arrayParaDesc);
// Merge TextContentRanges for all paragraphs
BaseParaClient paraClient;
for (int i = 0; i < arrayParaDesc.Length; i++)
{
paraClient = ptsContext.HandleToObject(arrayParaDesc[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
textContentRange.Merge(paraClient.GetTextContentRange());
}
}
return(textContentRange);
}
internal static void ArrangeParaList(PtsContext ptsContext, PTS.FSRECT rcTrackContent, PTS.FSPARADESCRIPTION[] arrayParaDesc, uint fswdirTrack)
{
int num = 0;
for (int i = 0; i < arrayParaDesc.Length; i++)
{
BaseParaClient baseParaClient = ptsContext.HandleToObject(arrayParaDesc[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(baseParaClient);
if (i == 0)
{
uint num2 = PTS.FlowDirectionToFswdir(baseParaClient.PageFlowDirection);
if (fswdirTrack != num2)
{
PTS.FSRECT pageRect = baseParaClient.Paragraph.StructuralCache.CurrentArrangeContext.PageContext.PageRect;
PTS.Validate(PTS.FsTransformRectangle(fswdirTrack, ref pageRect, ref rcTrackContent, num2, out rcTrackContent));
}
}
int dvrTopSpace = arrayParaDesc[i].dvrTopSpace;
PTS.FSRECT rcPara = rcTrackContent;
rcPara.v += num + dvrTopSpace;
rcPara.dv = arrayParaDesc[i].dvrUsed - dvrTopSpace;
baseParaClient.Arrange(arrayParaDesc[i].pfspara, rcPara, dvrTopSpace, fswdirTrack);
num += arrayParaDesc[i].dvrUsed;
}
}
// ------------------------------------------------------------------
// Update visuals for list of paragraphs.
// ------------------------------------------------------------------
internal static void UpdateParaListVisuals(
PtsContext ptsContext,
VisualCollection visualCollection,
PTS.FSKUPDATE fskupdInherited,
PTS.FSPARADESCRIPTION [] arrayParaDesc)
{
// For each paragraph, do following:
// (1) Retrieve ParaClient object
// (3) Update visual, if necessary
for (int index = 0; index < arrayParaDesc.Length; index++)
{
// (1) Retrieve ParaClient object
BaseParaClient paraClient = ptsContext.HandleToObject(arrayParaDesc[index].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
// (2) Update visual, if necessary
PTS.FSKUPDATE fskupd = arrayParaDesc[index].fsupdinf.fskupd;
if (fskupd == PTS.FSKUPDATE.fskupdInherited)
{
fskupd = fskupdInherited;
}
if (fskupd == PTS.FSKUPDATE.fskupdNew)
{
// Disconnect visual from its old parent, if necessary.
Visual currentParent = VisualTreeHelper.GetParent(paraClient.Visual) as Visual;
if (currentParent != null)
{
ContainerVisual parent = currentParent as ContainerVisual;
Invariant.Assert(parent != null, "parent should always derives from ContainerVisual");
parent.Children.Remove(paraClient.Visual);
}
// New paragraph - insert new visual node
visualCollection.Insert(index, paraClient.Visual);
paraClient.ValidateVisual(fskupd);
}
else
{
// Remove visuals for non-existing paragraphs
while (visualCollection[index] != paraClient.Visual)
{
visualCollection.RemoveAt(index);
Invariant.Assert(index < visualCollection.Count);
}
if (fskupd == PTS.FSKUPDATE.fskupdChangeInside || fskupd == PTS.FSKUPDATE.fskupdShifted)
{
paraClient.ValidateVisual(fskupd);
}
}
}
// Remove obsolete visuals
if (arrayParaDesc.Length < visualCollection.Count)
{
visualCollection.RemoveRange(arrayParaDesc.Length, visualCollection.Count - arrayParaDesc.Length);
}
}
// Token: 0x06006932 RID: 26930 RVA: 0x001DC738 File Offset: 0x001DA938
internal static void UpdateViewportParaList(PtsContext ptsContext, PTS.FSPARADESCRIPTION[] arrayParaDesc, ref PTS.FSRECT viewport)
{
for (int i = 0; i < arrayParaDesc.Length; i++)
{
BaseParaClient baseParaClient = ptsContext.HandleToObject(arrayParaDesc[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(baseParaClient);
baseParaClient.UpdateViewport(ref viewport);
}
}
// ------------------------------------------------------------------
// Update viewport for para list
// ------------------------------------------------------------------
internal static void UpdateViewportParaList(
PtsContext ptsContext,
PTS.FSPARADESCRIPTION [] arrayParaDesc,
ref PTS.FSRECT viewport)
{
for (int index = 0; index < arrayParaDesc.Length; index++)
{
// (1) Retrieve ParaClient object
BaseParaClient paraClient = ptsContext.HandleToObject(arrayParaDesc[index].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
paraClient.UpdateViewport(ref viewport);
}
}
// Token: 0x06006934 RID: 26932 RVA: 0x001DC7DC File Offset: 0x001DA9DC
internal static IInputElement InputHitTestParaList(PtsContext ptsContext, PTS.FSPOINT pt, ref PTS.FSRECT rcTrack, PTS.FSPARADESCRIPTION[] arrayParaDesc)
{
IInputElement inputElement = null;
int num = 0;
while (num < arrayParaDesc.Length && inputElement == null)
{
BaseParaClient baseParaClient = ptsContext.HandleToObject(arrayParaDesc[num].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(baseParaClient);
if (baseParaClient.Rect.Contains(pt))
{
inputElement = baseParaClient.InputHitTest(pt);
}
num++;
}
return(inputElement);
}
/// <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;
}
internal static TextContentRange TextContentRangeFromTrack(PtsContext ptsContext, IntPtr pfstrack)
{
PTS.FSTRACKDETAILS fstrackdetails;
PTS.Validate(PTS.FsQueryTrackDetails(ptsContext.Context, pfstrack, out fstrackdetails));
TextContentRange textContentRange = new TextContentRange();
if (fstrackdetails.cParas != 0)
{
PTS.FSPARADESCRIPTION[] array;
PtsHelper.ParaListFromTrack(ptsContext, pfstrack, ref fstrackdetails, out array);
for (int i = 0; i < array.Length; i++)
{
BaseParaClient baseParaClient = ptsContext.HandleToObject(array[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(baseParaClient);
textContentRange.Merge(baseParaClient.GetTextContentRange());
}
}
return(textContentRange);
}
// Token: 0x06006936 RID: 26934 RVA: 0x001DC89C File Offset: 0x001DAA9C
internal static List <Rect> GetRectanglesInParaList(PtsContext ptsContext, ContentElement e, int start, int length, PTS.FSPARADESCRIPTION[] arrayParaDesc)
{
List <Rect> list = new List <Rect>();
for (int i = 0; i < arrayParaDesc.Length; i++)
{
BaseParaClient baseParaClient = ptsContext.HandleToObject(arrayParaDesc[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(baseParaClient);
if (start < baseParaClient.Paragraph.ParagraphEndCharacterPosition)
{
list = baseParaClient.GetRectangles(e, start, length);
Invariant.Assert(list != null);
if (list.Count != 0)
{
break;
}
}
}
return(list);
}
// ------------------------------------------------------------------
// Hit tests to the correct IInputElement within the list of
// paragraphs that the mouse is over.
// ------------------------------------------------------------------
internal static IInputElement InputHitTestParaList(
PtsContext ptsContext,
PTS.FSPOINT pt,
ref PTS.FSRECT rcTrack, // track's rectangle
PTS.FSPARADESCRIPTION [] arrayParaDesc)
{
IInputElement ie = null;
for (int index = 0; index < arrayParaDesc.Length && ie == null; index++)
{
BaseParaClient paraClient = ptsContext.HandleToObject(arrayParaDesc[index].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
if (paraClient.Rect.Contains(pt))
{
ie = paraClient.InputHitTest(pt);
}
}
return(ie);
}
internal override int GetFirstTextLineBaseline()
{
PTS.FSSUBTRACKDETAILS subtrackDetails;
PTS.Validate(PTS.FsQuerySubtrackDetails(PtsContext.Context, _paraHandle.Value, out subtrackDetails));
if (subtrackDetails.cParas == 0)
{
return(_rect.v);
}
// Get list of paragraphs
PTS.FSPARADESCRIPTION [] arrayParaDesc;
PtsHelper.ParaListFromSubtrack(PtsContext, _paraHandle.Value, ref subtrackDetails, out arrayParaDesc);
BaseParaClient paraClient = PtsContext.HandleToObject(arrayParaDesc[0].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
return(paraClient.GetFirstTextLineBaseline());
}
// Token: 0x06006930 RID: 26928 RVA: 0x001DC5E0 File Offset: 0x001DA7E0
internal static void UpdateParaListVisuals(PtsContext ptsContext, VisualCollection visualCollection, PTS.FSKUPDATE fskupdInherited, PTS.FSPARADESCRIPTION[] arrayParaDesc)
{
for (int i = 0; i < arrayParaDesc.Length; i++)
{
BaseParaClient baseParaClient = ptsContext.HandleToObject(arrayParaDesc[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(baseParaClient);
PTS.FSKUPDATE fskupdate = arrayParaDesc[i].fsupdinf.fskupd;
if (fskupdate == PTS.FSKUPDATE.fskupdInherited)
{
fskupdate = fskupdInherited;
}
if (fskupdate == PTS.FSKUPDATE.fskupdNew)
{
Visual visual = VisualTreeHelper.GetParent(baseParaClient.Visual) as Visual;
if (visual != null)
{
ContainerVisual containerVisual = visual as ContainerVisual;
Invariant.Assert(containerVisual != null, "parent should always derives from ContainerVisual");
containerVisual.Children.Remove(baseParaClient.Visual);
}
visualCollection.Insert(i, baseParaClient.Visual);
baseParaClient.ValidateVisual(fskupdate);
}
else
{
while (visualCollection[i] != baseParaClient.Visual)
{
visualCollection.RemoveAt(i);
Invariant.Assert(i < visualCollection.Count);
}
if (fskupdate == PTS.FSKUPDATE.fskupdChangeInside || fskupdate == PTS.FSKUPDATE.fskupdShifted)
{
baseParaClient.ValidateVisual(fskupdate);
}
}
}
if (arrayParaDesc.Length < visualCollection.Count)
{
visualCollection.RemoveRange(arrayParaDesc.Length, visualCollection.Count - arrayParaDesc.Length);
}
}
internal static void ArrangeParaList(
PtsContext ptsContext,
PTS.FSRECT rcTrackContent,
PTS.FSPARADESCRIPTION [] arrayParaDesc,
uint fswdirTrack)
{
// For each paragraph, do following:
// (1) Retrieve ParaClient object
// (2) Arrange and update paragraph metrics
int dvrPara = 0;
for (int index = 0; index < arrayParaDesc.Length; index++)
{
// (1) Retrieve ParaClient object
BaseParaClient paraClient = ptsContext.HandleToObject(arrayParaDesc[index].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
// Convert to appropriate page coordinates.
if (index == 0)
{
uint fswdirPage = PTS.FlowDirectionToFswdir(paraClient.PageFlowDirection);
if (fswdirTrack != fswdirPage)
{
PTS.FSRECT pageRect = paraClient.Paragraph.StructuralCache.CurrentArrangeContext.PageContext.PageRect;
PTS.Validate(PTS.FsTransformRectangle(fswdirTrack, ref pageRect, ref rcTrackContent, fswdirPage, out rcTrackContent));
}
}
// (2) Arrange and update paragraph metrics
int dvrTopSpace = arrayParaDesc[index].dvrTopSpace;
PTS.FSRECT rcPara = rcTrackContent;
rcPara.v += dvrPara + dvrTopSpace;
rcPara.dv = arrayParaDesc[index].dvrUsed - dvrTopSpace;
paraClient.Arrange(arrayParaDesc[index].pfspara, rcPara, dvrTopSpace, fswdirTrack);
dvrPara += arrayParaDesc[index].dvrUsed;
}
}
/// <summary>
/// GetMCSClientAfterTable
/// </summary>
/// <param name="fswdirTrack">Direction of Track</param>
/// <param name="pmcsclientIn">Margin collapsing state</param>
/// <param name="ppmcsclientOut">Margin collapsing state</param>
internal void GetMCSClientAfterTable(
uint fswdirTrack,
IntPtr pmcsclientIn,
out IntPtr ppmcsclientOut)
{
ppmcsclientOut = IntPtr.Zero;
MbpInfo mbp = MbpInfo.FromElement(Table, StructuralCache.TextFormatterHost.PixelsPerDip);
MarginCollapsingState mcs = null;
if (pmcsclientIn != IntPtr.Zero)
{
mcs = PtsContext.HandleToObject(pmcsclientIn) as MarginCollapsingState;
}
MarginCollapsingState mcsNew = null;
int margin;
MarginCollapsingState.CollapseBottomMargin(PtsContext, mbp, mcs, out mcsNew, out margin);
if (mcsNew != null)
{
ppmcsclientOut = mcsNew.Handle;
}
}
/// <summary>
/// UpdateBottomlessCell
/// </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 UpdateBottomlessCell(uint fswdir, double width, out PTS.FSFMTRBL fmtrbl, out int dvrUsed)
{
IntPtr pmcsclientOut;
PTS.FSKCLEAR fskclearOut;
PTS.FSBBOX fsbbox;
int dvrTopSpace;
int fPageBecomesUninterruptable;
PTS.FSPAP fspap;
fspap = new PTS.FSPAP();
CellParagraph.GetParaProperties(ref fspap);
CellParagraph.UpdateBottomlessPara(_paraHandle.Value, this,
PTS.FromBoolean(false),
fswdir, 0,
TextDpi.ToTextDpi(width),
0, null,
PTS.FSKCLEAR.fskclearNone,
PTS.FromBoolean(true),
out fmtrbl,
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;
}
}
internal unsafe void CalcHorizontalBBoxOfRow(
int cCells,
IntPtr *rgnmCell,
IntPtr *rgpfsCell,
out int urBBox,
out int durBBox)
{
Debug.Assert(cCells == Row.FormatCellCount);
urBBox = 0;
durBBox = 0;
for (int index = 0; index < cCells; index++)
{
if (rgpfsCell[index] != IntPtr.Zero)
{
CellParaClient cellParaClient = PtsContext.HandleToObject(rgpfsCell[index]) as CellParaClient;
PTS.ValidateHandle(cellParaClient);
durBBox = TextDpi.ToTextDpi(cellParaClient.TableParaClient.TableDesiredWidth);
break;
}
}
}
/// <summary>
/// FormatCellFinite - Calls same apis that PTS does for formatting
/// </summary>
/// <param name="subpageSize">Subpage size.</param>
/// <param name="breakRecordIn">Subpage break record.</param>
/// <param name="isEmptyOk">Is an empty cell ok?</param>
/// <param name="fswdir">Text Direction</param>
/// <param name="fsksuppresshardbreakbeforefirstparaIn">Suppress hard break before first para</param>
/// <param name="fsfmtr">Format result</param>
/// <param name="dvrUsed">dvr Used</param>
/// <param name="breakRecordOut">Resultant break record for end of page</param>
internal void FormatCellFinite(Size subpageSize, IntPtr breakRecordIn, bool isEmptyOk, uint fswdir,
PTS.FSKSUPPRESSHARDBREAKBEFOREFIRSTPARA fsksuppresshardbreakbeforefirstparaIn,
out PTS.FSFMTR fsfmtr, out int dvrUsed, out IntPtr breakRecordOut)
{
IntPtr pfspara;
PTS.FSBBOX fsbbox;
IntPtr pmcsclientOut;
PTS.FSKCLEAR fskclearOut;
int dvrTopSpace;
PTS.FSPAP fspap;
if (CellParagraph.StructuralCache.DtrList != null && breakRecordIn != IntPtr.Zero)
{
CellParagraph.InvalidateStructure(TextContainerHelper.GetCPFromElement(CellParagraph.StructuralCache.TextContainer, CellParagraph.Element, ElementEdge.BeforeStart));
}
// Ensures segment is created for paragraph
fspap = new PTS.FSPAP();
CellParagraph.GetParaProperties(ref fspap);
PTS.FSRECT rectCell;
rectCell = new PTS.FSRECT();
rectCell.u = rectCell.v = 0;
rectCell.du = TextDpi.ToTextDpi(subpageSize.Width);
rectCell.dv = TextDpi.ToTextDpi(subpageSize.Height);
// Suppress top space if cell is broken, but not otherwise
bool suppressTopSpace = (breakRecordIn != IntPtr.Zero) ? true : false;
CellParagraph.FormatParaFinite(this, breakRecordIn,
PTS.FromBoolean(true),
IntPtr.Zero,
PTS.FromBoolean(isEmptyOk),
PTS.FromBoolean(suppressTopSpace),
fswdir,
ref rectCell,
null,
PTS.FSKCLEAR.fskclearNone,
fsksuppresshardbreakbeforefirstparaIn,
out fsfmtr,
out pfspara,
out breakRecordOut,
out dvrUsed,
out fsbbox,
out pmcsclientOut,
out fskclearOut,
out dvrTopSpace);
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;
}
internal unsafe void FormatParaFinite(
SubpageParaClient paraClient, // IN:
IntPtr pbrkrecIn, // IN: break record---use if !NULL
int fBRFromPreviousPage, // IN: break record was created on previous page
IntPtr footnoteRejector, // IN:
int fEmptyOk, // IN: is it OK not to add anything?
int fSuppressTopSpace, // IN: suppress empty space at the top of the page
uint fswdir, // IN: current direction
ref PTS.FSRECT fsrcToFill, // IN: rectangle to fill
MarginCollapsingState mcs, // IN: input margin collapsing state
PTS.FSKCLEAR fskclearIn, // IN: clear property that must be satisfied
PTS.FSKSUPPRESSHARDBREAKBEFOREFIRSTPARA fsksuppresshardbreakbeforefirstparaIn,
// IN: suppress breaks at track start?
out PTS.FSFMTR fsfmtr, // OUT: result of formatting the paragraph
out IntPtr pfspara, // OUT: pointer to the para data
out IntPtr pbrkrecOut, // OUT: pointer to the para break record
out int dvrUsed, // OUT: vertical space used by the para
out PTS.FSBBOX fsbbox, // OUT: para BBox
out IntPtr pmcsclientOut, // OUT: margin collapsing state at the bottom
out PTS.FSKCLEAR fskclearOut, // OUT: ClearIn for the next paragraph
out int dvrTopSpace) // OUT: top space due to collapsed margin
{
uint fswdirSubpage = PTS.FlowDirectionToFswdir(((FlowDirection)Element.GetValue(FrameworkElement.FlowDirectionProperty)));
int subpageWidth, subpageHeight;
int cColumns;
int marginTop, marginBottom;
MbpInfo mbp;
MarginCollapsingState mcsSubpage, mcsBottom;
PTS.FSRECT fsrcSubpageMargin;
PTS.FSCOLUMNINFO [] columnInfoCollection;
// Currently it is possible to get MCS and BR in following situation:
// At the end of the page there is a paragraph with delayed figure, so the figure
// gets delayed to the next page. But part of the next paragraph fits in the page,
// so it gets broken. PTS creates BR with delayed figure and broken para.
// PTS will format the next page starting from delayed figure, which can produce MCS.
// So when the next paragraph is continued from BR, it has MCS.
// This problem is currently investigated by PTS team: PTSLS bug 915.
// For now, MCS gets ignored here.
//Debug.Assert(pbrkrecIn == IntPtr.Zero || mcs == null, "Broken paragraph cannot have margin collapsing state.");
if (mcs != null && pbrkrecIn != IntPtr.Zero)
{
mcs = null;
}
// Initialize the subpage size and its margin.
fsrcSubpageMargin = new PTS.FSRECT();
subpageWidth = fsrcToFill.du;
subpageHeight = fsrcToFill.dv;
// Set clear property
Invariant.Assert(Element is TableCell || Element is AnchoredBlock);
fskclearIn = PTS.WrapDirectionToFskclear((WrapDirection)Element.GetValue(Block.ClearFloatersProperty));
// Take into account MBPs and modify subpage metrics,
// and make sure that subpage is at least 1 unit wide (cannot measure at width <= 0)
marginTop = 0;
mcsSubpage = null;
// Get MBP info. Since subpage height and width must be at least 1, the max size for MBP is subpage dimensions less 1
mbp = MbpInfo.FromElement(Element, StructuralCache.TextFormatterHost.PixelsPerDip);
if (fswdirSubpage != fswdir)
{
PTS.FSRECT pageRect = StructuralCache.CurrentFormatContext.PageRect;
PTS.Validate(PTS.FsTransformRectangle(fswdir, ref pageRect, ref fsrcToFill, fswdirSubpage, out fsrcToFill));
mbp.MirrorMargin();
}
subpageWidth = Math.Max(1, subpageWidth - (mbp.MBPLeft + mbp.MBPRight));
if (pbrkrecIn == IntPtr.Zero)
{
// Top margin collapsing. If suppresing top space, top margin is always 0.
MarginCollapsingState.CollapseTopMargin(PtsContext, mbp, mcs, out mcsSubpage, out marginTop);
if (PTS.ToBoolean(fSuppressTopSpace))
{
marginTop = 0;
}
subpageHeight = Math.Max(1, subpageHeight - (marginTop + mbp.BPTop));
// Destroy top margin collapsing state (not needed anymore).
if (mcsSubpage != null)
{
mcsSubpage.Dispose();
mcsSubpage = null;
}
}
else
{
Debug.Assert(fSuppressTopSpace == 1, "Top space should be always suppressed at the top of broken paragraph.");
}
fsrcSubpageMargin.du = subpageWidth;
fsrcSubpageMargin.dv = subpageHeight;
// Initialize column info
ColumnPropertiesGroup columnProperties = new ColumnPropertiesGroup(_element);
double lineHeight = DynamicPropertyReader.GetLineHeightValue(_element);
double pageFontSize = (double)_structuralCache.PropertyOwner.GetValue(Block.FontSizeProperty);
FontFamily pageFontFamily = (FontFamily)_structuralCache.PropertyOwner.GetValue(Block.FontFamilyProperty);
// Get columns info, setting ownerIsFlowDocument flag to false. A flow document should not be formatted as a subpage and we
// do not want default column widths to be set on TableCells and floaters
cColumns = PtsHelper.CalculateColumnCount(columnProperties, lineHeight, TextDpi.FromTextDpi(subpageWidth), pageFontSize, pageFontFamily, false);
columnInfoCollection = new PTS.FSCOLUMNINFO[cColumns];
fixed(PTS.FSCOLUMNINFO *rgColumnInfo = columnInfoCollection)
{
PtsHelper.GetColumnsInfo(columnProperties, lineHeight, TextDpi.FromTextDpi(subpageWidth), pageFontSize, pageFontFamily, cColumns, rgColumnInfo, false);
}
// Format subpage
StructuralCache.CurrentFormatContext.PushNewPageData(new Size(TextDpi.FromTextDpi(subpageWidth), TextDpi.FromTextDpi(subpageHeight)),
new Thickness(),
false,
true);
fixed(PTS.FSCOLUMNINFO *rgColumnInfo = columnInfoCollection)
{
PTS.Validate(PTS.FsCreateSubpageFinite(PtsContext.Context, pbrkrecIn, fBRFromPreviousPage, _mainTextSegment.Handle,
footnoteRejector, fEmptyOk, fSuppressTopSpace, fswdir, subpageWidth, subpageHeight,
ref fsrcSubpageMargin, cColumns, rgColumnInfo, PTS.False,
0, null, null, 0, null, null, PTS.FromBoolean(false),
fsksuppresshardbreakbeforefirstparaIn,
out fsfmtr, out pfspara, out pbrkrecOut, out dvrUsed, out fsbbox, out pmcsclientOut, out dvrTopSpace), PtsContext);
}
StructuralCache.CurrentFormatContext.PopPageData();
fskclearOut = PTS.FSKCLEAR.fskclearNone;
if (PTS.ToBoolean(fsbbox.fDefined))
{
// Workaround for PTS bug 860: get max of the page rect and
// bounding box of the page.
dvrUsed = Math.Max(dvrUsed, fsbbox.fsrc.dv + fsbbox.fsrc.v);
fsrcToFill.du = Math.Max(fsrcToFill.du, fsbbox.fsrc.du + fsbbox.fsrc.u);
}
if (pbrkrecIn == IntPtr.Zero) // if first chunk
{
// Take into account MBPs and modify subpage metrics
dvrTopSpace = (mbp.BPTop != 0) ? marginTop : dvrTopSpace;
dvrUsed += (marginTop + mbp.BPTop);
}
if (pmcsclientOut != IntPtr.Zero)
{
mcsSubpage = PtsContext.HandleToObject(pmcsclientOut) as MarginCollapsingState;
PTS.ValidateHandle(mcsSubpage);
pmcsclientOut = IntPtr.Zero;
}
// Initialize subpage metrics
if (fsfmtr.kstop >= PTS.FSFMTRKSTOP.fmtrNoProgressOutOfSpace) // No progress or collision
{
dvrUsed = dvrTopSpace = 0;
//pbrkrecOut = IntPtr.Zero;
//pfspara = IntPtr.Zero;
//pmcsclientOut = IntPtr.Zero;
}
else
{
if (fsfmtr.kstop == PTS.FSFMTRKSTOP.fmtrGoalReached)
{
// Bottom margin collapsing:
// (a) retrieve mcs from the subpage
// (b) do margin collapsing; create a new margin collapsing state
// There is no bottom margin collapsing if paragraph will be continued (output break record is not null).
MarginCollapsingState.CollapseBottomMargin(PtsContext, mbp, mcsSubpage, out mcsBottom, out marginBottom);
pmcsclientOut = (mcsBottom != null) ? mcsBottom.Handle : IntPtr.Zero;
if (pmcsclientOut == IntPtr.Zero) // if last chunk
{
dvrUsed += marginBottom + mbp.BPBottom;
}
}
// Update bounding box
fsbbox.fsrc.u = fsrcToFill.u + mbp.MarginLeft;
fsbbox.fsrc.v = fsrcToFill.v + dvrTopSpace;
fsbbox.fsrc.du = Math.Max(fsrcToFill.du - (mbp.MarginLeft + mbp.MarginRight), 0);
fsbbox.fsrc.dv = Math.Max(dvrUsed - dvrTopSpace, 0);
}
if (fswdirSubpage != fswdir)
{
PTS.FSRECT pageRect = StructuralCache.CurrentFormatContext.PageRect;
PTS.Validate(PTS.FsTransformBbox(fswdirSubpage, ref pageRect, ref fsbbox, fswdir, out fsbbox));
}
// Since MCS returned by PTS is never passed back, destroy MCS provided by PTS.
// If necessary, new MCS is created and passed back to PTS (see above).
if (mcsSubpage != null)
{
mcsSubpage.Dispose();
mcsSubpage = null;
}
// Update information about first/last chunk
paraClient.SetChunkInfo(pbrkrecIn == IntPtr.Zero, pbrkrecOut == IntPtr.Zero);
}
internal override void FormatFloaterContentFinite(
FloaterBaseParaClient paraClient, // IN:
IntPtr pbrkrecIn, // IN: break record---use if !IntPtr.Zero
int fBRFromPreviousPage, // IN: break record was created on previous page
IntPtr footnoteRejector, // IN:
int fEmptyOk, // IN: is it OK not to add anything?
int fSuppressTopSpace, // IN: suppress empty space at the top of the page
uint fswdir, // IN: direction of Track
int fAtMaxWidth, // IN: formating is at full width of column
int durAvailable, // IN: width of available space
int dvrAvailable, // IN: height of available space
PTS.FSKSUPPRESSHARDBREAKBEFOREFIRSTPARA fsksuppresshardbreakbeforefirstparaIn,
// IN: suppress breaks at track start?
out PTS.FSFMTR fsfmtr, // OUT: result of formatting
out IntPtr pfsFloatContent, // OUT: opaque for PTS pointer pointer to formatted content
out IntPtr pbrkrecOut, // OUT: pointer to the floater content break record
out int durFloaterWidth, // OUT: floater width
out int dvrFloaterHeight, // OUT: floater height
out PTS.FSBBOX fsbbox, // OUT: floater bbox
out int cPolygons, // OUT: number of polygons
out int cVertices) // OUT: total number of vertices in all polygons
{
uint fswdirPara = PTS.FlowDirectionToFswdir(((FlowDirection)Element.GetValue(FrameworkElement.FlowDirectionProperty)));
int subpageWidth, subpageHeight;
int dvrTopSpace;
int cColumns;
PTS.FSRECT fsrcSubpageMargin;
PTS.FSCOLUMNINFO[] columnInfoCollection;
IntPtr pmcsclientOut;
double specifiedWidth;
MbpInfo mbp;
Invariant.Assert(paraClient is FloaterParaClient);
// If horizontal alignment is Stretch and we are not formatting at max width,
// we cannot proceed.
if (IsFloaterRejected(PTS.ToBoolean(fAtMaxWidth), TextDpi.FromTextDpi(durAvailable)))
{
durFloaterWidth = dvrFloaterHeight = 0;
cPolygons = cVertices = 0;
fsfmtr = new PTS.FSFMTR();
fsfmtr.kstop = PTS.FSFMTRKSTOP.fmtrNoProgressOutOfSpace;
fsfmtr.fContainsItemThatStoppedBeforeFootnote = PTS.False;
fsfmtr.fForcedProgress = PTS.False;
fsbbox = new PTS.FSBBOX();
fsbbox.fDefined = PTS.False;
pbrkrecOut = IntPtr.Zero;
pfsFloatContent = IntPtr.Zero;
}
else
{
// When formatting bottomless page, PTS may format paragraphs as finite. This happens
// in case of multiple columns. In this case make sure that height is not too big.
if (!StructuralCache.CurrentFormatContext.FinitePage)
{
if (Double.IsInfinity(StructuralCache.CurrentFormatContext.PageHeight))
{
if (dvrAvailable > PTS.dvBottomUndefined / 2)
{
dvrAvailable = Math.Min(dvrAvailable, PTS.dvBottomUndefined / 2);
fEmptyOk = PTS.False;
}
}
else
{
dvrAvailable = Math.Min(dvrAvailable, TextDpi.ToTextDpi(StructuralCache.CurrentFormatContext.PageHeight));
}
}
// Initialize the subpage size. PTS subpage margin is always set to 0 for Floaters.
// If width on floater is specified, use the specified value.
// Margin, border and padding of the floater is extracted from available subpage height
mbp = MbpInfo.FromElement(Element, StructuralCache.TextFormatterHost.PixelsPerDip);
// We do not mirror margin as it's used to dist text left and right, and is unnecessary.
// Clip Floater.Width to available width
specifiedWidth = CalculateWidth(TextDpi.FromTextDpi(durAvailable));
AdjustDurAvailable(specifiedWidth, ref durAvailable, out subpageWidth);
subpageHeight = Math.Max(1, dvrAvailable - (mbp.MBPTop + mbp.MBPBottom));
fsrcSubpageMargin = new PTS.FSRECT();
fsrcSubpageMargin.du = subpageWidth;
fsrcSubpageMargin.dv = subpageHeight;
// Initialize column info. Floater always has just 1 column.
cColumns = 1;
columnInfoCollection = new PTS.FSCOLUMNINFO[cColumns];
columnInfoCollection[0].durBefore = 0;
columnInfoCollection[0].durWidth = subpageWidth;
// Format subpage
CreateSubpageFiniteHelper(PtsContext, pbrkrecIn, fBRFromPreviousPage, _mainTextSegment.Handle,
footnoteRejector, fEmptyOk, PTS.True, fswdir, subpageWidth, subpageHeight,
ref fsrcSubpageMargin, cColumns, columnInfoCollection, PTS.False, fsksuppresshardbreakbeforefirstparaIn,
out fsfmtr, out pfsFloatContent,
out pbrkrecOut, out dvrFloaterHeight, out fsbbox, out pmcsclientOut, out dvrTopSpace);
// Initialize subpage metrics
if (fsfmtr.kstop >= PTS.FSFMTRKSTOP.fmtrNoProgressOutOfSpace) // No progress or collision
{
Debug.Assert(pmcsclientOut == IntPtr.Zero);
durFloaterWidth = dvrFloaterHeight = 0;
cPolygons = cVertices = 0;
//pbrkrecpara = IntPtr.Zero;
}
else
{
// PTS subpage does not support autosizing, but Floater needs to autosize to its
// content. To workaround this problem, second format of subpage is performed, if
// necessary. It means that if the width of bounding box is smaller than subpage's
// width, second formatting is performed.
// However, if HorizontalAlignment is set to Stretch we should not reformat because floater
// should be at max width
if (PTS.ToBoolean(fsbbox.fDefined))
{
if (fsbbox.fsrc.du < subpageWidth && Double.IsNaN(specifiedWidth) && HorizontalAlignment != HorizontalAlignment.Stretch)
{
// There is a need to reformat PTS subpage, so destroy any resourcces allocated by PTS
// during previous formatting.
if (pfsFloatContent != IntPtr.Zero)
{
PTS.Validate(PTS.FsDestroySubpage(PtsContext.Context, pfsFloatContent), PtsContext);
pfsFloatContent = IntPtr.Zero;
}
if (pbrkrecOut != IntPtr.Zero)
{
PTS.Validate(PTS.FsDestroySubpageBreakRecord(PtsContext.Context, pbrkrecOut), PtsContext);
pbrkrecOut = IntPtr.Zero;
}
if (pmcsclientOut != IntPtr.Zero)
{
MarginCollapsingState mcs = PtsContext.HandleToObject(pmcsclientOut) as MarginCollapsingState;
PTS.ValidateHandle(mcs);
mcs.Dispose();
pmcsclientOut = IntPtr.Zero;
}
// Create subpage with new width.
subpageWidth = fsbbox.fsrc.du + 1; // add 1/300px to avoid rounding errors
fsrcSubpageMargin.du = subpageWidth;
fsrcSubpageMargin.dv = subpageHeight;
columnInfoCollection[0].durWidth = subpageWidth;
CreateSubpageFiniteHelper(PtsContext, pbrkrecIn, fBRFromPreviousPage, _mainTextSegment.Handle,
footnoteRejector, fEmptyOk, PTS.True, fswdir, subpageWidth, subpageHeight,
ref fsrcSubpageMargin, cColumns, columnInfoCollection, PTS.False, fsksuppresshardbreakbeforefirstparaIn,
out fsfmtr, out pfsFloatContent,
out pbrkrecOut, out dvrFloaterHeight, out fsbbox, out pmcsclientOut, out dvrTopSpace);
}
}
else
{
subpageWidth = TextDpi.ToTextDpi(TextDpi.MinWidth);
}
// Destroy objects created by PTS, but not used here.
if (pmcsclientOut != IntPtr.Zero)
{
MarginCollapsingState mcs = PtsContext.HandleToObject(pmcsclientOut) as MarginCollapsingState;
PTS.ValidateHandle(mcs);
mcs.Dispose();
pmcsclientOut = IntPtr.Zero;
}
// Get the size of the floater. For height PTS already reports calculated value.
// But width is the same as subpage width. Add margin values here since we do not use
// distance to text anymore
durFloaterWidth = subpageWidth + mbp.MBPLeft + mbp.MBPRight;
// Add back all MBP values since we do not use dist to text
dvrFloaterHeight += mbp.MBPTop + mbp.MBPBottom;
// Check if floater width fits in available width. It may exceed available width because borders and
// padding are added.
fsbbox.fsrc.u = 0;
fsbbox.fsrc.v = 0;
fsbbox.fsrc.du = durFloaterWidth;
fsbbox.fsrc.dv = dvrFloaterHeight;
fsbbox.fDefined = PTS.True;
// Tight wrap is disabled for now.
cPolygons = cVertices = 0;
if (durFloaterWidth > durAvailable || dvrFloaterHeight > dvrAvailable)
{
if (PTS.ToBoolean(fEmptyOk))
{
// Get rid of any previous formatting
if (pfsFloatContent != IntPtr.Zero)
{
PTS.Validate(PTS.FsDestroySubpage(PtsContext.Context, pfsFloatContent), PtsContext);
pfsFloatContent = IntPtr.Zero;
}
if (pbrkrecOut != IntPtr.Zero)
{
PTS.Validate(PTS.FsDestroySubpageBreakRecord(PtsContext.Context, pbrkrecOut), PtsContext);
pbrkrecOut = IntPtr.Zero;
}
cPolygons = cVertices = 0;
fsfmtr.kstop = PTS.FSFMTRKSTOP.fmtrNoProgressOutOfSpace;
}
else
{
fsfmtr.fForcedProgress = PTS.True;
}
}
}
}
// Update handle to PTS subpage.
((FloaterParaClient)paraClient).SubpageHandle = pfsFloatContent;
}
internal override void ValidateVisual(PTS.FSKUPDATE fskupdInherited)
{
// Query paragraph details
PTS.FSSUBTRACKDETAILS subtrackDetails;
PTS.Validate(PTS.FsQuerySubtrackDetails(PtsContext.Context, _paraHandle.Value, out subtrackDetails));
// Draw border and background info.
MbpInfo mbp = MbpInfo.FromElement(Paragraph.Element, Paragraph.StructuralCache.TextFormatterHost.PixelsPerDip);
if (ThisFlowDirection != PageFlowDirection)
{
mbp.MirrorBP();
}
uint fswdir = PTS.FlowDirectionToFswdir((FlowDirection)Paragraph.Element.GetValue(FrameworkElement.FlowDirectionProperty));
Brush backgroundBrush = (Brush)Paragraph.Element.GetValue(TextElement.BackgroundProperty);
// This textProperties object is eventually used in creation of LineProperties, which leads to creation of a TextMarkerSource. TextMarkerSource relies on PixelsPerDip
// from TextProperties, therefore it must be set here properly.
TextProperties textProperties = new TextProperties(Paragraph.Element, StaticTextPointer.Null, false /* inline objects */, false /* get background */,
Paragraph.StructuralCache.TextFormatterHost.PixelsPerDip);
// There might be possibility to get empty sub-track, skip the sub-track in such case.
if (subtrackDetails.cParas != 0)
{
PTS.FSPARADESCRIPTION [] arrayParaDesc;
PtsHelper.ParaListFromSubtrack(PtsContext, _paraHandle.Value, ref subtrackDetails, out arrayParaDesc);
using (DrawingContext ctx = _visual.RenderOpen())
{
_visual.DrawBackgroundAndBorderIntoContext(ctx, backgroundBrush, mbp.BorderBrush, mbp.Border, _rect.FromTextDpi(), IsFirstChunk, IsLastChunk);
// Get list of paragraphs
ListMarkerLine listMarkerLine = new ListMarkerLine(Paragraph.StructuralCache.TextFormatterHost, this);
int indexFirstParaInSubtrack = 0;
for (int index = 0; index < subtrackDetails.cParas; index++)
{
List list = Paragraph.Element as List;
BaseParaClient listItemParaClient = PtsContext.HandleToObject(arrayParaDesc[index].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(listItemParaClient);
if (index == 0)
{
indexFirstParaInSubtrack = list.GetListItemIndex(listItemParaClient.Paragraph.Element as ListItem);
}
if (listItemParaClient.IsFirstChunk)
{
int dvBaseline = listItemParaClient.GetFirstTextLineBaseline();
if (PageFlowDirection != ThisFlowDirection)
{
ctx.PushTransform(new MatrixTransform(-1.0, 0.0, 0.0, 1.0, TextDpi.FromTextDpi(2 * listItemParaClient.Rect.u + listItemParaClient.Rect.du), 0.0));
}
int adjustedIndex;
if (int.MaxValue - index < indexFirstParaInSubtrack)
{
adjustedIndex = int.MaxValue;
}
else
{
adjustedIndex = indexFirstParaInSubtrack + index;
}
LineProperties lineProps = new LineProperties(Paragraph.Element, Paragraph.StructuralCache.FormattingOwner, textProperties, new MarkerProperties(list, adjustedIndex));
listMarkerLine.FormatAndDrawVisual(ctx, lineProps, listItemParaClient.Rect.u, dvBaseline);
if (PageFlowDirection != ThisFlowDirection)
{
ctx.Pop();
}
}
}
listMarkerLine.Dispose();
}
// Render list of paragraphs
PtsHelper.UpdateParaListVisuals(PtsContext, _visual.Children, fskupdInherited, arrayParaDesc);
}
else
{
_visual.Children.Clear();
}
}
// ------------------------------------------------------------------
// Update viewport for para list
// ------------------------------------------------------------------
internal static void UpdateViewportParaList(
PtsContext ptsContext,
PTS.FSPARADESCRIPTION [] arrayParaDesc,
ref PTS.FSRECT viewport)
{
for (int index = 0; index < arrayParaDesc.Length; index++)
{
// (1) Retrieve ParaClient object
BaseParaClient paraClient = ptsContext.HandleToObject(arrayParaDesc[index].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
paraClient.UpdateViewport(ref viewport);
}
}
private ReadOnlyCollection <ParagraphResult> GetChildrenParagraphResults(out bool hasTextContent)
{
List <ParagraphResult> paragraphResults;
// Query subpage details
PTS.FSSUBPAGEDETAILS subpageDetails;
PTS.Validate(PTS.FsQuerySubpageDetails(PtsContext.Context, _paraHandle.Value, out subpageDetails));
// hasTextContent is set to true if any of the children paragraphs has text content, not just attached objects
hasTextContent = false;
// 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)
// Get track details
PTS.FSTRACKDETAILS trackDetails;
PTS.Validate(PTS.FsQueryTrackDetails(PtsContext.Context, subpageDetails.u.simple.trackdescr.pfstrack, out trackDetails));
hasTextContent = true;
if (trackDetails.cParas == 0)
{
return(new ReadOnlyCollection <ParagraphResult>(new List <ParagraphResult>(0)));
}
// Get list of paragraphs
PTS.FSPARADESCRIPTION[] arrayParaDesc;
PtsHelper.ParaListFromTrack(PtsContext, subpageDetails.u.simple.trackdescr.pfstrack, ref trackDetails, out arrayParaDesc);
paragraphResults = new List <ParagraphResult>(arrayParaDesc.Length);
for (int i = 0; i < arrayParaDesc.Length; i++)
{
BaseParaClient paraClient = PtsContext.HandleToObject(arrayParaDesc[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
ParagraphResult paragraphResult = paraClient.CreateParagraphResult();
if (paragraphResult.HasTextContent)
{
hasTextContent = true;
}
paragraphResults.Add(paragraphResult);
}
}
else
{
// (2) complex page (contains columns)
// cBasicColumns == 0, means that subpage content is empty
if (subpageDetails.u.complex.cBasicColumns == 0)
{
return(new ReadOnlyCollection <ParagraphResult>(new List <ParagraphResult>(0)));
}
// Retrieve description for each column.
PTS.FSTRACKDESCRIPTION[] arrayColumnDesc;
PtsHelper.TrackListFromSubpage(PtsContext, _paraHandle.Value, ref subpageDetails, out arrayColumnDesc);
Debug.Assert(arrayColumnDesc.Length == 1);
// Get track details
PTS.FSTRACKDETAILS trackDetails;
PTS.Validate(PTS.FsQueryTrackDetails(PtsContext.Context, arrayColumnDesc[0].pfstrack, out trackDetails));
if (trackDetails.cParas == 0)
{
return(new ReadOnlyCollection <ParagraphResult>(new List <ParagraphResult>(0)));
}
// Get list of paragraphs
PTS.FSPARADESCRIPTION[] arrayParaDesc;
PtsHelper.ParaListFromTrack(PtsContext, arrayColumnDesc[0].pfstrack, ref trackDetails, out arrayParaDesc);
paragraphResults = new List <ParagraphResult>(arrayParaDesc.Length);
for (int i = 0; i < arrayParaDesc.Length; i++)
{
BaseParaClient paraClient = PtsContext.HandleToObject(arrayParaDesc[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
ParagraphResult paragraphResult = paraClient.CreateParagraphResult();
if (paragraphResult.HasTextContent)
{
hasTextContent = true;
}
paragraphResults.Add(paragraphResult);
}
}
return(new ReadOnlyCollection <ParagraphResult>(paragraphResults));
}
internal static TextContentRange TextContentRangeFromTrack(
PtsContext ptsContext,
IntPtr pfstrack)
{
// Get track details
PTS.FSTRACKDETAILS trackDetails;
PTS.Validate(PTS.FsQueryTrackDetails(ptsContext.Context, pfstrack, out trackDetails));
// Combine ranges from all nested paragraphs.
TextContentRange textContentRange = new TextContentRange();
if (trackDetails.cParas != 0)
{
PTS.FSPARADESCRIPTION[] arrayParaDesc;
PtsHelper.ParaListFromTrack(ptsContext, pfstrack, ref trackDetails, out arrayParaDesc);
// Merge TextContentRanges for all paragraphs
BaseParaClient paraClient;
for (int i = 0; i < arrayParaDesc.Length; i++)
{
paraClient = ptsContext.HandleToObject(arrayParaDesc[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
textContentRange.Merge(paraClient.GetTextContentRange());
}
}
return textContentRange;
}
// ------------------------------------------------------------------
// Returns ArrayList of rectangles for the ContentElement e within the
// list of paragraphs. If the element is not found, returns empty list.
// start: int representing start offset of e
// length: int representing number of positions occupied by e
// ------------------------------------------------------------------
internal static List<Rect> GetRectanglesInParaList(
PtsContext ptsContext,
ContentElement e,
int start,
int length,
PTS.FSPARADESCRIPTION[] arrayParaDesc)
{
List<Rect> rectangles = new List<Rect>();
for (int index = 0; index < arrayParaDesc.Length; index++)
{
BaseParaClient paraClient = ptsContext.HandleToObject(arrayParaDesc[index].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
if (start < paraClient.Paragraph.ParagraphEndCharacterPosition)
{
// Element lies within the paraClient boundaries.
rectangles = paraClient.GetRectangles(e, start, length);
// Rectangles collection should not be null for consistency
Invariant.Assert(rectangles != null);
if (rectangles.Count != 0)
{
// Element cannot span more than one para client in the same track, so we stop
// if the element is found and the rectangles are calculated
break;
}
}
}
return rectangles;
}
// ------------------------------------------------------------------
// Hit tests to the correct IInputElement within the list of
// paragraphs that the mouse is over.
// ------------------------------------------------------------------
internal static IInputElement InputHitTestParaList(
PtsContext ptsContext,
PTS.FSPOINT pt,
ref PTS.FSRECT rcTrack, // track's rectangle
PTS.FSPARADESCRIPTION [] arrayParaDesc)
{
IInputElement ie = null;
for (int index = 0; index < arrayParaDesc.Length && ie == null; index++)
{
BaseParaClient paraClient = ptsContext.HandleToObject(arrayParaDesc[index].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
if(paraClient.Rect.Contains(pt))
{
ie = paraClient.InputHitTest(pt);
}
}
return ie;
}
internal unsafe void UpdateBottomlessPara(
IntPtr pfspara, // IN: pointer to the para data
SubpageParaClient paraClient, // IN:
int fSuppressTopSpace, // IN: suppress empty space at the top of the page
uint fswdir, // IN: current direction
int urTrack, // IN: u of bootomless rectangle to fill
int durTrack, // IN: du of bootomless rectangle to fill
int vrTrack, // IN: v of bootomless rectangle to fill
MarginCollapsingState mcs, // IN: input margin collapsing state
PTS.FSKCLEAR fskclearIn, // IN: clear property that must be satisfied
int fInterruptable, // IN: formatting can be interrupted
out PTS.FSFMTRBL fsfmtrbl, // OUT: result of formatting the paragraph
out int dvrUsed, // OUT: vertical space used by the para
out PTS.FSBBOX fsbbox, // OUT: para BBox
out IntPtr pmcsclientOut, // OUT: margin collapsing state at the bottom
out PTS.FSKCLEAR fskclearOut, // OUT: ClearIn for the next paragraph
out int dvrTopSpace, // OUT: top space due to collapsed margin
out int fPageBecomesUninterruptable) // OUT: interruption is prohibited from now on
{
int subpageWidth, urSubpageMargin, durSubpageMargin, vrSubpageMargin;
int cColumns;
int marginTop, marginBottom;
MbpInfo mbp;
MarginCollapsingState mcsSubpage, mcsBottom;
PTS.FSCOLUMNINFO[] columnInfoCollection;
uint fswdirSubpage = PTS.FlowDirectionToFswdir(((FlowDirection)Element.GetValue(FrameworkElement.FlowDirectionProperty)));
// Initialize the subpage size and its margin.
subpageWidth = durTrack;
urSubpageMargin = vrSubpageMargin = 0;
// Set clear property
Invariant.Assert(Element is TableCell || Element is AnchoredBlock);
fskclearIn = PTS.WrapDirectionToFskclear((WrapDirection)Element.GetValue(Block.ClearFloatersProperty));
// Take into account MBPs and modify subpage metrics,
// and make sure that subpage is at least 1 unit wide (cannot measure at width <= 0)
// NOTE: Do not suppress top space for bottomles pages.
mbp = MbpInfo.FromElement(Element, StructuralCache.TextFormatterHost.PixelsPerDip);
if (fswdirSubpage != fswdir)
{
PTS.FSRECT fsrcToFillSubpage = new PTS.FSRECT(urTrack, 0, durTrack, 0);
PTS.FSRECT pageRect = StructuralCache.CurrentFormatContext.PageRect;
PTS.Validate(PTS.FsTransformRectangle(fswdir, ref pageRect, ref fsrcToFillSubpage, fswdirSubpage, out fsrcToFillSubpage));
urTrack = fsrcToFillSubpage.u;
durTrack = fsrcToFillSubpage.du;
mbp.MirrorMargin();
}
subpageWidth = Math.Max(1, subpageWidth - (mbp.MBPLeft + mbp.MBPRight));
MarginCollapsingState.CollapseTopMargin(PtsContext, mbp, mcs, out mcsSubpage, out marginTop);
// Destroy top margin collapsing state (not needed anymore).
if (mcsSubpage != null)
{
mcsSubpage.Dispose();
mcsSubpage = null;
}
durSubpageMargin = subpageWidth;
// Initialize column info
// For bottomles spara, limit line height to the height of the current format context in structural cache.
ColumnPropertiesGroup columnProperties = new ColumnPropertiesGroup(_element);
double lineHeight = DynamicPropertyReader.GetLineHeightValue(_element);
double pageFontSize = (double)_structuralCache.PropertyOwner.GetValue(Block.FontSizeProperty);
FontFamily pageFontFamily = (FontFamily)_structuralCache.PropertyOwner.GetValue(Block.FontFamilyProperty);
// Get columns info, setting ownerIsFlowDocument flag to false. A flow document should not be formatted as a subpage and we
// do not want default column widths to be set on TableCells and floaters
cColumns = PtsHelper.CalculateColumnCount(columnProperties, lineHeight, TextDpi.FromTextDpi(subpageWidth), pageFontSize, pageFontFamily, false);
columnInfoCollection = new PTS.FSCOLUMNINFO[cColumns];
fixed(PTS.FSCOLUMNINFO *rgColumnInfo = columnInfoCollection)
{
PtsHelper.GetColumnsInfo(columnProperties, lineHeight, TextDpi.FromTextDpi(subpageWidth), pageFontSize, pageFontFamily, cColumns, rgColumnInfo, false);
}
StructuralCache.CurrentFormatContext.PushNewPageData(new Size(TextDpi.FromTextDpi(subpageWidth), TextDpi.MaxWidth),
new Thickness(),
true,
false);
// Create subpage
fixed(PTS.FSCOLUMNINFO *rgColumnInfo = columnInfoCollection)
{
PTS.Validate(PTS.FsUpdateBottomlessSubpage(PtsContext.Context, pfspara, _mainTextSegment.Handle, fSuppressTopSpace,
fswdir, subpageWidth, urSubpageMargin, durSubpageMargin, vrSubpageMargin,
cColumns, rgColumnInfo, 0, null, null, 0, null, null, PTS.FromBoolean(true),
out fsfmtrbl, out dvrUsed, out fsbbox, out pmcsclientOut, out dvrTopSpace,
out fPageBecomesUninterruptable), PtsContext);
}
StructuralCache.CurrentFormatContext.PopPageData();
fskclearOut = PTS.FSKCLEAR.fskclearNone;
if (fsfmtrbl != PTS.FSFMTRBL.fmtrblCollision)
{
// Bottom margin collapsing:
// (1) retrieve mcs from the subtrack
// (2) do margin collapsing; create a new margin collapsing state
if (pmcsclientOut != IntPtr.Zero)
{
mcsSubpage = PtsContext.HandleToObject(pmcsclientOut) as MarginCollapsingState;
PTS.ValidateHandle(mcsSubpage);
pmcsclientOut = IntPtr.Zero;
}
MarginCollapsingState.CollapseBottomMargin(PtsContext, mbp, mcsSubpage, out mcsBottom, out marginBottom);
pmcsclientOut = (mcsBottom != null) ? mcsBottom.Handle : IntPtr.Zero;
// Since MCS returned by PTS is never passed back, destroy MCS provided by PTS.
// If necessary, new MCS is created and passed back to PTS.
if (mcsSubpage != null)
{
mcsSubpage.Dispose();
mcsSubpage = null;
}
if (PTS.ToBoolean(fsbbox.fDefined))
{
// Workaround for PTS bug 860: get max of the page rect and
// bounding box of the page.
dvrUsed = Math.Max(dvrUsed, fsbbox.fsrc.dv + fsbbox.fsrc.v);
durTrack = Math.Max(durTrack, fsbbox.fsrc.du + fsbbox.fsrc.u);
}
// Take into account MBPs and modify subtrack metrics
dvrTopSpace = (mbp.BPTop != 0) ? marginTop : dvrTopSpace;
dvrUsed += (marginTop + mbp.BPTop) + (marginBottom + mbp.BPBottom);
// Update bounding box
fsbbox.fsrc.u = urTrack + mbp.MarginLeft;
fsbbox.fsrc.v = vrTrack + dvrTopSpace;
fsbbox.fsrc.du = Math.Max(durTrack - (mbp.MarginLeft + mbp.MarginRight), 0);
fsbbox.fsrc.dv = Math.Max(dvrUsed - dvrTopSpace, 0);
}
else
{
Debug.Assert(pmcsclientOut == IntPtr.Zero);
pfspara = IntPtr.Zero;
dvrUsed = dvrTopSpace = 0;
}
if (fswdirSubpage != fswdir)
{
PTS.FSRECT pageRect = StructuralCache.CurrentFormatContext.PageRect;
PTS.Validate(PTS.FsTransformBbox(fswdirSubpage, ref pageRect, ref fsbbox, fswdir, out fsbbox));
}
// Update information about first/last chunk. In bottomless scenario
// paragraph is not broken, so there is only one chunk.
paraClient.SetChunkInfo(true, true);
}
internal static void ArrangeParaList(
PtsContext ptsContext,
PTS.FSRECT rcTrackContent,
PTS.FSPARADESCRIPTION [] arrayParaDesc,
uint fswdirTrack)
{
// For each paragraph, do following:
// (1) Retrieve ParaClient object
// (2) Arrange and update paragraph metrics
int dvrPara = 0;
for (int index = 0; index < arrayParaDesc.Length; index++)
{
// (1) Retrieve ParaClient object
BaseParaClient paraClient = ptsContext.HandleToObject(arrayParaDesc[index].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
// Convert to appropriate page coordinates.
if(index == 0)
{
uint fswdirPage = PTS.FlowDirectionToFswdir(paraClient.PageFlowDirection);
if(fswdirTrack != fswdirPage)
{
PTS.FSRECT pageRect = paraClient.Paragraph.StructuralCache.CurrentArrangeContext.PageContext.PageRect;
PTS.Validate(PTS.FsTransformRectangle(fswdirTrack, ref pageRect, ref rcTrackContent, fswdirPage, out rcTrackContent));
}
}
// (2) Arrange and update paragraph metrics
int dvrTopSpace = arrayParaDesc[index].dvrTopSpace;
PTS.FSRECT rcPara = rcTrackContent;
rcPara.v += dvrPara + dvrTopSpace;
rcPara.dv = arrayParaDesc[index].dvrUsed - dvrTopSpace;
paraClient.Arrange(arrayParaDesc[index].pfspara, rcPara, dvrTopSpace, fswdirTrack);
dvrPara += arrayParaDesc[index].dvrUsed;
}
}
/// <summary>
/// GetNextRow
/// </summary>
/// <param name="nmRow">Previous body row name</param>
/// <param name="fFound">Indication that body row is found</param>
/// <param name="pnmNextRow">Body row name</param>
internal void GetNextRow(
IntPtr nmRow,
out int fFound,
out IntPtr pnmNextRow)
{
Debug.Assert(Table.RowGroups.Count > 0);
BaseParagraph prevParagraph = ((RowParagraph)PtsContext.HandleToObject(nmRow));
BaseParagraph nextParagraph = prevParagraph.Next;
if (nextParagraph == null)
{
TableRow currentRow = ((RowParagraph)prevParagraph).Row;
TableRowGroup currentRowGroup = currentRow.RowGroup;
TableRow tableRow = null;
int nextRowIndex = currentRow.Index + 1;
int nextRowGroupIndex = currentRowGroup.Index + 1;
if (nextRowIndex < currentRowGroup.Rows.Count)
{
Debug.Assert(currentRowGroup.Rows[nextRowIndex].Index != -1,
"Row is not in a table");
tableRow = currentRowGroup.Rows[nextRowIndex];
}
while (tableRow == null)
{
if (nextRowGroupIndex == Table.RowGroups.Count)
{
break;
}
TableRowCollection Rows = Table.RowGroups[nextRowGroupIndex].Rows;
if (Rows.Count > 0)
{
Debug.Assert(Rows[0].Index != -1,
"Row is not in a table");
tableRow = Rows[0];
}
nextRowGroupIndex++;
}
if (tableRow != null)
{
nextParagraph = new RowParagraph(tableRow, StructuralCache);
prevParagraph.Next = nextParagraph;
nextParagraph.Previous = prevParagraph;
((RowParagraph)nextParagraph).CalculateRowSpans();
}
}
if (nextParagraph != null)
{
fFound = PTS.True;
pnmNextRow = nextParagraph.Handle;
}
else
{
fFound = PTS.False;
pnmNextRow = IntPtr.Zero;
}
}
// ------------------------------------------------------------------
// Update visuals for list of paragraphs.
// ------------------------------------------------------------------
internal static void UpdateParaListVisuals(
PtsContext ptsContext,
VisualCollection visualCollection,
PTS.FSKUPDATE fskupdInherited,
PTS.FSPARADESCRIPTION [] arrayParaDesc)
{
// For each paragraph, do following:
// (1) Retrieve ParaClient object
// (3) Update visual, if necessary
for (int index = 0; index < arrayParaDesc.Length; index++)
{
// (1) Retrieve ParaClient object
BaseParaClient paraClient = ptsContext.HandleToObject(arrayParaDesc[index].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
// (2) Update visual, if necessary
PTS.FSKUPDATE fskupd = arrayParaDesc[index].fsupdinf.fskupd;
if (fskupd == PTS.FSKUPDATE.fskupdInherited)
{
fskupd = fskupdInherited;
}
if (fskupd == PTS.FSKUPDATE.fskupdNew)
{
// Disconnect visual from its old parent, if necessary.
Visual currentParent = VisualTreeHelper.GetParent(paraClient.Visual) as Visual;
if(currentParent != null)
{
ContainerVisual parent = currentParent as ContainerVisual;
Invariant.Assert(parent != null, "parent should always derives from ContainerVisual");
parent.Children.Remove(paraClient.Visual);
}
// New paragraph - insert new visual node
visualCollection.Insert(index, paraClient.Visual);
paraClient.ValidateVisual(fskupd);
}
else
{
// Remove visuals for non-existing paragraphs
while (visualCollection[index] != paraClient.Visual)
{
visualCollection.RemoveAt(index);
Invariant.Assert(index < visualCollection.Count);
}
if(fskupd == PTS.FSKUPDATE.fskupdChangeInside || fskupd == PTS.FSKUPDATE.fskupdShifted)
{
paraClient.ValidateVisual(fskupd);
}
}
}
// Remove obsolete visuals
if (arrayParaDesc.Length < visualCollection.Count)
{
visualCollection.RemoveRange(arrayParaDesc.Length, visualCollection.Count - arrayParaDesc.Length);
}
}
internal override void FormatFloaterContentBottomless(
FloaterBaseParaClient paraClient, // IN:
int fSuppressTopSpace, // IN: suppress empty space at the top of the page
uint fswdir, // IN: direction of track
int fAtMaxWidth, // IN: formating is at full width of column
int durAvailable, // IN: width of available space
int dvrAvailable, // IN: height of available space
out PTS.FSFMTRBL fsfmtrbl, // OUT: result of formatting
out IntPtr pfsFloatContent, // OUT: opaque for PTS pointer pointer to formatted content
out int durFloaterWidth, // OUT: floater width
out int dvrFloaterHeight, // OUT: floater height
out PTS.FSBBOX fsbbox, // OUT: floater bbox
out int cPolygons, // OUT: number of polygons
out int cVertices) // OUT: total number of vertices in all polygons
{
uint fswdirPara = PTS.FlowDirectionToFswdir(((FlowDirection)Element.GetValue(FrameworkElement.FlowDirectionProperty)));
Invariant.Assert(paraClient is FloaterParaClient);
int subpageWidth, urSubpageMargin, durSubpageMargin, vrSubpageMargin;
int dvrTopSpace, fPageBecomesUninterruptable;
int cColumns;
PTS.FSCOLUMNINFO[] columnInfoCollection;
IntPtr pmcsclientOut;
MbpInfo mbp;
double specifiedWidth;
// If horizontal alignment is Stretch and we are not formatting at max width,
// we cannot proceed.
if (IsFloaterRejected(PTS.ToBoolean(fAtMaxWidth), TextDpi.FromTextDpi(durAvailable)))
{
// Set foater width, height to be greater than available values to signal to PTS that floater does not fit in the space
durFloaterWidth = durAvailable + 1;
dvrFloaterHeight = dvrAvailable + 1;
cPolygons = cVertices = 0;
fsfmtrbl = PTS.FSFMTRBL.fmtrblInterrupted;
fsbbox = new PTS.FSBBOX();
fsbbox.fDefined = PTS.False;
pfsFloatContent = IntPtr.Zero;
}
else
{
// Initialize the subpage size. PTS subpage margin is always set to 0 for Floaters.
// If width on floater is specified, use the specified value.
// Margin, border and padding of the floater is extracted from available subpage width.
mbp = MbpInfo.FromElement(Element, StructuralCache.TextFormatterHost.PixelsPerDip);
specifiedWidth = CalculateWidth(TextDpi.FromTextDpi(durAvailable));
AdjustDurAvailable(specifiedWidth, ref durAvailable, out subpageWidth);
durSubpageMargin = subpageWidth;
urSubpageMargin = vrSubpageMargin = 0;
// Initialize column info. Floater always has just 1 column.
cColumns = 1;
columnInfoCollection = new PTS.FSCOLUMNINFO[cColumns];
columnInfoCollection[0].durBefore = 0;
columnInfoCollection[0].durWidth = subpageWidth;
// Create subpage
InvalidateMainTextSegment();
CreateSubpageBottomlessHelper(PtsContext, _mainTextSegment.Handle, PTS.True,
fswdir, subpageWidth, urSubpageMargin, durSubpageMargin, vrSubpageMargin,
cColumns, columnInfoCollection,
out fsfmtrbl, out pfsFloatContent, out dvrFloaterHeight, out fsbbox, out pmcsclientOut,
out dvrTopSpace, out fPageBecomesUninterruptable);
if (fsfmtrbl != PTS.FSFMTRBL.fmtrblCollision)
{
// PTS subpage does not support autosizing, but Floater needs to autosize to its
// content. To workaround this problem, second format of subpage is performed, if
// necessary. It means that if the width of bounding box is smaller than subpage's
// width, second formatting is performed.
// However, if HorizontalAlignment is set to Stretch we should not reformat because
// floater should be at full column width
if (PTS.ToBoolean(fsbbox.fDefined))
{
if (fsbbox.fsrc.du < subpageWidth && Double.IsNaN(specifiedWidth) && HorizontalAlignment != HorizontalAlignment.Stretch)
{
// There is a need to reformat PTS subpage, so destroy any resourcces allocated by PTS
// during previous formatting.
if (pfsFloatContent != IntPtr.Zero)
{
PTS.Validate(PTS.FsDestroySubpage(PtsContext.Context, pfsFloatContent), PtsContext);
}
if (pmcsclientOut != IntPtr.Zero)
{
MarginCollapsingState mcs = PtsContext.HandleToObject(pmcsclientOut) as MarginCollapsingState;
PTS.ValidateHandle(mcs);
mcs.Dispose();
pmcsclientOut = IntPtr.Zero;
}
// Create subpage with new width.
subpageWidth = durSubpageMargin = fsbbox.fsrc.du + 1; // add 1/300px to avoid rounding errors
columnInfoCollection[0].durWidth = subpageWidth;
CreateSubpageBottomlessHelper(PtsContext, _mainTextSegment.Handle, PTS.True,
fswdir, subpageWidth, urSubpageMargin, durSubpageMargin, vrSubpageMargin,
cColumns, columnInfoCollection,
out fsfmtrbl, out pfsFloatContent, out dvrFloaterHeight, out fsbbox, out pmcsclientOut,
out dvrTopSpace, out fPageBecomesUninterruptable);
}
}
else
{
subpageWidth = TextDpi.ToTextDpi(TextDpi.MinWidth);
}
// Destroy objects created by PTS, but not used here.
if (pmcsclientOut != IntPtr.Zero)
{
MarginCollapsingState mcs = PtsContext.HandleToObject(pmcsclientOut) as MarginCollapsingState;
PTS.ValidateHandle(mcs);
mcs.Dispose();
pmcsclientOut = IntPtr.Zero;
}
// Get the size of the floater. For height PTS already reports calculated value.
// But width is the same as subpage width.
durFloaterWidth = subpageWidth + mbp.MBPLeft + mbp.MBPRight;
dvrFloaterHeight += mbp.MBPTop + mbp.MBPBottom;
// Check if floater width fits in available width. It may exceed available width because borders
// and padding are added.
if (dvrFloaterHeight > dvrAvailable ||
(durFloaterWidth > durAvailable && !PTS.ToBoolean(fAtMaxWidth))
)
{
// Get rid of any previous formatting
if (pfsFloatContent != IntPtr.Zero)
{
PTS.Validate(PTS.FsDestroySubpage(PtsContext.Context, pfsFloatContent), PtsContext);
}
Debug.Assert(pmcsclientOut == IntPtr.Zero);
cPolygons = cVertices = 0;
pfsFloatContent = IntPtr.Zero;
}
else
{
// Width and height are OK, format floater
// Adjust bounding box to cover entire floater.
fsbbox.fsrc.u = 0;
fsbbox.fsrc.v = 0;
fsbbox.fsrc.du = durFloaterWidth;
fsbbox.fsrc.dv = dvrFloaterHeight;
// Tight wrap is disabled for now.
cPolygons = cVertices = 0;
}
}
else
{
Debug.Assert(pmcsclientOut == IntPtr.Zero);
durFloaterWidth = dvrFloaterHeight = 0;
cPolygons = cVertices = 0;
pfsFloatContent = IntPtr.Zero;
}
}
// Update handle to PTS subpage.
((FloaterParaClient)paraClient).SubpageHandle = pfsFloatContent;
}
internal void GetFigureProperties(
FigureParaClient paraClient, // IN:
int fInTextLine, // IN: it is attached to text line
uint fswdir, // IN: current direction
int fBottomUndefined, // IN: bottom of page is not defined
out int dur, // OUT: width of figure
out int dvr, // OUT: height of figure
out PTS.FSFIGUREPROPS fsfigprops, // OUT: figure attributes
out int cPolygons, // OUT: number of polygons
out int cVertices, // OUT: total number of vertices in all polygons
out int durDistTextLeft, // OUT: distance to text from MinU side
out int durDistTextRight, // OUT: distance to text from MaxU side
out int dvrDistTextTop, // OUT: distance to text from MinV side
out int dvrDistTextBottom) // OUT: distance to text from MaxV side
{
Invariant.Assert(StructuralCache.CurrentFormatContext.FinitePage);
uint fswdirPara = PTS.FlowDirectionToFswdir(((FlowDirection)Element.GetValue(FrameworkElement.FlowDirectionProperty)));
IntPtr pfsFigureContent;
PTS.FSBBOX fsbbox;
int cColumns;
int dvrTopSpace;
PTS.FSCOLUMNINFO[] columnInfoCollection;
IntPtr pmcsclientOut;
MbpInfo mbp;
Figure element = (Figure)Element;
// Initialize the subpage size. PTS subpage margin is always set to 0 for Figures.
// If width on figure is specified, use the specified value.
// Border and padding of the figure is extracted from available subpage width.
// We use StructuralCache.CurrentFormatContext's page dimensions as limiting values for figure MBP
mbp = MbpInfo.FromElement(Element);
// We do not mirror margin as it's used to dist text left and right, and is unnecessary.
durDistTextLeft = durDistTextRight = dvrDistTextTop = dvrDistTextBottom = 0;
// Calculate specified width. IsAuto flag is needed because Auto is formatted the same way as column and will
// not return Double.NaN.
bool isWidthAuto;
double specifiedWidth = FigureHelper.CalculateFigureWidth(StructuralCache, element,
element.Width,
out isWidthAuto);
double anchorLimitedWidth = LimitTotalWidthFromAnchor(specifiedWidth, TextDpi.FromTextDpi(mbp.MarginLeft + mbp.MarginRight));
int subpageWidth = Math.Max(1, TextDpi.ToTextDpi(anchorLimitedWidth) - (mbp.BPLeft + mbp.BPRight));
// Calculate figure height, IsAuto flag is used as specifiedHeight will never be NaN.
bool isHeightAuto;
double specifiedHeight = FigureHelper.CalculateFigureHeight(StructuralCache, element,
element.Height,
out isHeightAuto);
double anchorLimitedHeight = LimitTotalHeightFromAnchor(specifiedHeight, TextDpi.FromTextDpi(mbp.MarginTop + mbp.MarginBottom));
int subpageHeight = Math.Max(1, TextDpi.ToTextDpi(anchorLimitedHeight) - (mbp.BPTop + mbp.BPBottom));
// Initialize column info. Figure always has just 1 column.
cColumns = 1;
columnInfoCollection = new PTS.FSCOLUMNINFO[cColumns];
columnInfoCollection[0].durBefore = 0;
columnInfoCollection[0].durWidth = subpageWidth;
// Create subpage
{
PTS.FSFMTR fsfmtr;
IntPtr brParaOut;
PTS.FSRECT marginRect = new PTS.FSRECT(0, 0, subpageWidth, subpageHeight);
CreateSubpageFiniteHelper(PtsContext, IntPtr.Zero, PTS.False, _mainTextSegment.Handle, IntPtr.Zero, PTS.False, PTS.True,
fswdir, subpageWidth, subpageHeight, ref marginRect,
cColumns, columnInfoCollection, PTS.False,
out fsfmtr, out pfsFigureContent, out brParaOut, out dvr, out fsbbox, out pmcsclientOut,
out dvrTopSpace);
if (brParaOut != IntPtr.Zero)
{
PTS.Validate(PTS.FsDestroySubpageBreakRecord(PtsContext.Context, brParaOut));
}
}
// PTS subpage does not support autosizing, but Figure needs to autosize to its
// content. To workaround this problem, second format of subpage is performed, if
// necessary. It means that if the width of bounding box is smaller than subpage's
// width, second formatting is performed.
if (PTS.ToBoolean(fsbbox.fDefined))
{
if (fsbbox.fsrc.du < subpageWidth && isWidthAuto)
{
// There is a need to reformat PTS subpage, so destroy any resourcces allocated by PTS
// during previous formatting.
if (pfsFigureContent != IntPtr.Zero)
{
PTS.Validate(PTS.FsDestroySubpage(PtsContext.Context, pfsFigureContent), PtsContext);
}
if (pmcsclientOut != IntPtr.Zero)
{
MarginCollapsingState mcs = PtsContext.HandleToObject(pmcsclientOut) as MarginCollapsingState;
PTS.ValidateHandle(mcs);
mcs.Dispose();
pmcsclientOut = IntPtr.Zero;
}
// Create subpage with new width.
subpageWidth = fsbbox.fsrc.du + 1; // add 1/300px to avoid rounding errors
columnInfoCollection[0].durWidth = subpageWidth;
// Create subpage
PTS.FSFMTR fsfmtr;
IntPtr brParaOut;
PTS.FSRECT marginRect = new PTS.FSRECT(0, 0, subpageWidth, subpageHeight);
CreateSubpageFiniteHelper(PtsContext, IntPtr.Zero, PTS.False, _mainTextSegment.Handle, IntPtr.Zero, PTS.False, PTS.True,
fswdir, subpageWidth, subpageHeight, ref marginRect,
cColumns, columnInfoCollection, PTS.False,
out fsfmtr, out pfsFigureContent, out brParaOut, out dvr, out fsbbox, out pmcsclientOut,
out dvrTopSpace);
if (brParaOut != IntPtr.Zero)
{
PTS.Validate(PTS.FsDestroySubpageBreakRecord(PtsContext.Context, brParaOut));
}
}
}
else
{
subpageWidth = TextDpi.ToTextDpi(TextDpi.MinWidth);
}
// Get the size of the figure. For height PTS already reports calculated value.
// But width is the same as subpage width. Include margins in dur since we are not using
// distance to text anymore.
dur = subpageWidth + mbp.MBPLeft + mbp.MBPRight;
// Destroy objects created by PTS, but not used here.
if (pmcsclientOut != IntPtr.Zero)
{
MarginCollapsingState mcs = PtsContext.HandleToObject(pmcsclientOut) as MarginCollapsingState;
PTS.ValidateHandle(mcs);
mcs.Dispose();
pmcsclientOut = IntPtr.Zero;
}
dvr += mbp.MBPTop + mbp.MBPBottom;
if (!isHeightAuto)
{
// Replace height with explicit height if specified, adding margins in addition to height
// Border and padding are included in specified height but margins are external
dvr = TextDpi.ToTextDpi(anchorLimitedHeight) + mbp.MarginTop + mbp.MarginBottom;
}
FigureHorizontalAnchor horzAnchor = element.HorizontalAnchor;
FigureVerticalAnchor vertAnchor = element.VerticalAnchor;
fsfigprops.fskrefU = (PTS.FSKREF)(((int)horzAnchor) / 3);
fsfigprops.fskrefV = (PTS.FSKREF)(((int)vertAnchor) / 3);
fsfigprops.fskalfU = (PTS.FSKALIGNFIG)(((int)horzAnchor) % 3);
fsfigprops.fskalfV = (PTS.FSKALIGNFIG)(((int)vertAnchor) % 3);
// PTS does not allow to anchor delayed figures to 'Character'
if (!PTS.ToBoolean(fInTextLine))
{
if (fsfigprops.fskrefU == PTS.FSKREF.fskrefChar)
{
fsfigprops.fskrefU = PTS.FSKREF.fskrefMargin;
fsfigprops.fskalfU = PTS.FSKALIGNFIG.fskalfMin;
}
if (fsfigprops.fskrefV == PTS.FSKREF.fskrefChar)
{
fsfigprops.fskrefV = PTS.FSKREF.fskrefMargin;
fsfigprops.fskalfV = PTS.FSKALIGNFIG.fskalfMin;
}
}
// Always wrap text on both sides of the floater.
fsfigprops.fskwrap = PTS.WrapDirectionToFskwrap(element.WrapDirection);
fsfigprops.fNonTextPlane = PTS.False;
fsfigprops.fAllowOverlap = PTS.False;
fsfigprops.fDelayable = PTS.FromBoolean(element.CanDelayPlacement);
// Tight wrap is disabled for now.
cPolygons = cVertices = 0;
// Update handle to PTS subpage.
((FigureParaClient)paraClient).SubpageHandle = pfsFigureContent;
}
