// Token: 0x06006B6E RID: 27502 RVA: 0x001F0978 File Offset: 0x001EEB78
internal override void ValidateVisual(PTS.FSKUPDATE fskupdInherited)
{
MbpInfo mbpInfo = MbpInfo.FromElement(base.Paragraph.Element, base.Paragraph.StructuralCache.TextFormatterHost.PixelsPerDip);
PtsHelper.UpdateMirroringTransform(base.PageFlowDirection, base.ThisFlowDirection, this._visual, TextDpi.FromTextDpi(2 * this._rect.u + this._rect.du));
UIElementIsland uielementIsland = ((UIElementParagraph)base.Paragraph).UIElementIsland;
if (uielementIsland != null)
{
if (this._visual.Children.Count != 1 || this._visual.Children[0] != uielementIsland)
{
Visual visual = VisualTreeHelper.GetParent(uielementIsland) as Visual;
if (visual != null)
{
ContainerVisual containerVisual = visual as ContainerVisual;
Invariant.Assert(containerVisual != null, "Parent should always derives from ContainerVisual.");
containerVisual.Children.Remove(uielementIsland);
}
this._visual.Children.Clear();
this._visual.Children.Add(uielementIsland);
}
uielementIsland.Offset = new PTS.FSVECTOR(this._rect.u + mbpInfo.BPLeft, this._rect.v + mbpInfo.BPTop).FromTextDpi();
}
else
{
this._visual.Children.Clear();
}
Brush backgroundBrush = (Brush)base.Paragraph.Element.GetValue(TextElement.BackgroundProperty);
this._visual.DrawBackgroundAndBorder(backgroundBrush, mbpInfo.BorderBrush, mbpInfo.Border, this._rect.FromTextDpi(), this.IsFirstChunk, this.IsLastChunk);
}
internal ReadOnlyCollection <ParagraphResult> GetChildrenParagraphResults(out bool hasTextContent)
{
PTS.FSSUBTRACKDETAILS fssubtrackdetails;
PTS.Validate(PTS.FsQuerySubtrackDetails(base.PtsContext.Context, this._paraHandle.Value, out fssubtrackdetails));
hasTextContent = false;
if (fssubtrackdetails.cParas == 0)
{
return(new ReadOnlyCollection <ParagraphResult>(new List <ParagraphResult>(0)));
}
PTS.FSPARADESCRIPTION[] array;
PtsHelper.ParaListFromSubtrack(base.PtsContext, this._paraHandle.Value, ref fssubtrackdetails, out array);
List <ParagraphResult> list = new List <ParagraphResult>(array.Length);
for (int i = 0; i < array.Length; i++)
{
BaseParaClient baseParaClient = base.PtsContext.HandleToObject(array[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(baseParaClient);
ParagraphResult paragraphResult = baseParaClient.CreateParagraphResult();
if (paragraphResult.HasTextContent)
{
hasTextContent = true;
}
list.Add(paragraphResult);
}
return(new ReadOnlyCollection <ParagraphResult>(list));
}
// ------------------------------------------------------------------
// Calculates a page margin adjustment to eliminate free space if column width is not flexible
// ------------------------------------------------------------------
internal static double CalculatePageMarginAdjustment(StructuralCache structuralCache, double pageMarginWidth)
{
double pageMarginAdjustment = 0.0;
DependencyObject o = structuralCache.Section.Element;
if (o is FlowDocument)
{
ColumnPropertiesGroup columnProperties = new ColumnPropertiesGroup(o);
if (!columnProperties.IsColumnWidthFlexible)
{
double lineHeight = DynamicPropertyReader.GetLineHeightValue(o);
double pageFontSize = (double)structuralCache.PropertyOwner.GetValue(Block.FontSizeProperty);
FontFamily pageFontFamily = (FontFamily)structuralCache.PropertyOwner.GetValue(Block.FontFamilyProperty);
int ccol = PtsHelper.CalculateColumnCount(columnProperties, lineHeight, pageMarginWidth, pageFontSize, pageFontFamily, true);
double columnWidth;
double freeSpace;
double gap;
GetColumnMetrics(columnProperties, pageMarginWidth,
pageFontSize, pageFontFamily, true, ccol,
ref lineHeight, out columnWidth, out freeSpace, out gap);
pageMarginAdjustment = freeSpace;
}
}
return(pageMarginAdjustment);
}
internal void ArrangePage()
{
if (this.IsEmpty)
{
return;
}
this._section.UpdateSegmentLastFormatPositions();
PTS.FSPAGEDETAILS fspagedetails;
PTS.Validate(PTS.FsQueryPageDetails(this.PtsContext.Context, this._ptsPage.Value, out fspagedetails));
if (PTS.ToBoolean(fspagedetails.fSimple))
{
this._section.StructuralCache.CurrentArrangeContext.PushNewPageData(this._pageContextOfThisPage, fspagedetails.u.simple.trackdescr.fsrc, this._finitePage);
PtsHelper.ArrangeTrack(this.PtsContext, ref fspagedetails.u.simple.trackdescr, PTS.FlowDirectionToFswdir(this._section.StructuralCache.PageFlowDirection));
this._section.StructuralCache.CurrentArrangeContext.PopPageData();
return;
}
ErrorHandler.Assert(fspagedetails.u.complex.cFootnoteColumns == 0, ErrorHandler.NotSupportedFootnotes);
if (fspagedetails.u.complex.cSections != 0)
{
PTS.FSSECTIONDESCRIPTION[] array;
PtsHelper.SectionListFromPage(this.PtsContext, this._ptsPage.Value, ref fspagedetails, out array);
for (int i = 0; i < array.Length; i++)
{
this.ArrangeSection(ref array[i]);
}
}
}
// Token: 0x06006835 RID: 26677 RVA: 0x001D5B40 File Offset: 0x001D3D40
internal PageBreakRecord FormatFinite(Size pageSize, Thickness pageMargin, PageBreakRecord breakRecord)
{
Invariant.Assert(!this.IsDisposed);
this._formattedLinesCount = 0;
TextDpi.EnsureValidPageSize(ref pageSize);
TextDpi.EnsureValidPageMargin(ref pageMargin, pageSize);
double num = PtsHelper.CalculatePageMarginAdjustment(this._structuralCache, pageSize.Width - (pageMargin.Left + pageMargin.Right));
if (!DoubleUtil.IsZero(num))
{
pageMargin.Right += num - num / 100.0;
}
this._pageMargin = pageMargin;
base.SetSize(pageSize);
base.SetContentBox(new Rect(pageMargin.Left, pageMargin.Top, pageSize.Width - (pageMargin.Left + pageMargin.Right), pageSize.Height - (pageMargin.Top + pageMargin.Bottom)));
using (this._structuralCache.SetDocumentFormatContext(this))
{
this.OnBeforeFormatPage();
if (this._ptsPage.PrepareForFiniteUpdate(breakRecord))
{
this._structuralCache.CurrentFormatContext.PushNewPageData(pageSize, this._pageMargin, true, true);
this._ptsPage.UpdateFinitePage(breakRecord);
}
else
{
this._structuralCache.CurrentFormatContext.PushNewPageData(pageSize, this._pageMargin, false, true);
this._ptsPage.CreateFinitePage(breakRecord);
}
this._structuralCache.CurrentFormatContext.PopPageData();
this.OnAfterFormatPage();
this._structuralCache.DetectInvalidOperation();
}
return(this._ptsPage.BreakRecord);
}
private void ArrangeSection(ref PTS.FSSECTIONDESCRIPTION sectionDesc)
{
PTS.FSSECTIONDETAILS fssectiondetails;
PTS.Validate(PTS.FsQuerySectionDetails(this.PtsContext.Context, sectionDesc.pfssection, out fssectiondetails));
if (PTS.ToBoolean(fssectiondetails.fFootnotesAsPagenotes))
{
ErrorHandler.Assert(fssectiondetails.u.withpagenotes.cEndnoteColumns == 0, ErrorHandler.NotSupportedFootnotes);
if (fssectiondetails.u.withpagenotes.cBasicColumns != 0)
{
PTS.FSTRACKDESCRIPTION[] array;
PtsHelper.TrackListFromSection(this.PtsContext, sectionDesc.pfssection, ref fssectiondetails, out array);
for (int i = 0; i < array.Length; i++)
{
this._section.StructuralCache.CurrentArrangeContext.PushNewPageData(this._pageContextOfThisPage, array[i].fsrc, this._finitePage);
PtsHelper.ArrangeTrack(this.PtsContext, ref array[i], fssectiondetails.u.withpagenotes.fswdir);
this._section.StructuralCache.CurrentArrangeContext.PopPageData();
}
return;
}
}
else
{
ErrorHandler.Assert(false, ErrorHandler.NotSupportedCompositeColumns);
}
}
// Token: 0x06006852 RID: 26706 RVA: 0x001D6628 File Offset: 0x001D4828
private void UpdateVisual()
{
if (this.PageVisual == null)
{
base.SetVisual(new PageVisual(this));
}
if (this._visualNeedsUpdate)
{
this.PageVisual.DrawBackground((Brush)this._structuralCache.PropertyOwner.GetValue(FlowDocument.BackgroundProperty), new Rect(this._partitionSize));
ContainerVisual containerVisual = null;
using (this._structuralCache.SetDocumentVisualValidationContext(this))
{
containerVisual = this._ptsPage.GetPageVisual();
this._structuralCache.DetectInvalidOperation();
}
this.PageVisual.Child = containerVisual;
FlowDirection childFD = (FlowDirection)this._structuralCache.PropertyOwner.GetValue(FlowDocument.FlowDirectionProperty);
PtsHelper.UpdateMirroringTransform(FlowDirection.LeftToRight, childFD, containerVisual, this.Size.Width);
using (this._structuralCache.SetDocumentVisualValidationContext(this))
{
this._ptsPage.ClearUpdateInfo();
this._structuralCache.DetectInvalidOperation();
}
this._visualNeedsUpdate = false;
}
}
internal override List <Rect> GetRectangles(ContentElement e, int start, int length)
{
List <Rect> list = new List <Rect>();
if (base.Paragraph.Element as ContentElement == e)
{
this.GetRectanglesForParagraphElement(out list);
}
else
{
PTS.FSSUBTRACKDETAILS fssubtrackdetails;
PTS.Validate(PTS.FsQuerySubtrackDetails(base.PtsContext.Context, this._paraHandle.Value, out fssubtrackdetails));
if (fssubtrackdetails.cParas != 0)
{
PTS.FSPARADESCRIPTION[] arrayParaDesc;
PtsHelper.ParaListFromSubtrack(base.PtsContext, this._paraHandle.Value, ref fssubtrackdetails, out arrayParaDesc);
list = PtsHelper.GetRectanglesInParaList(base.PtsContext, e, start, length, arrayParaDesc);
}
else
{
list = new List <Rect>();
}
}
Invariant.Assert(list != null);
return(list);
}
internal override TextContentRange GetTextContentRange()
{
PTS.FSSUBPAGEDETAILS fssubpagedetails;
PTS.Validate(PTS.FsQuerySubpageDetails(base.PtsContext.Context, this._paraHandle.Value, out fssubpagedetails));
TextContentRange textContentRange;
if (PTS.ToBoolean(fssubpagedetails.fSimple))
{
textContentRange = PtsHelper.TextContentRangeFromTrack(base.PtsContext, fssubpagedetails.u.simple.trackdescr.pfstrack);
}
else
{
textContentRange = new TextContentRange();
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++)
{
textContentRange.Merge(PtsHelper.TextContentRangeFromTrack(base.PtsContext, array[i].pfstrack));
}
}
}
if (this.IsFirstChunk)
{
textContentRange.Merge(TextContainerHelper.GetTextContentRangeForTextElementEdge(base.Paragraph.Element as TextElement, ElementEdge.BeforeStart));
}
if (this.IsLastChunk)
{
textContentRange.Merge(TextContainerHelper.GetTextContentRangeForTextElementEdge(base.Paragraph.Element as TextElement, ElementEdge.AfterEnd));
}
return(textContentRange);
}
internal static void UpdateTrackVisuals(PtsContext ptsContext, VisualCollection visualCollection, PTS.FSKUPDATE fskupdInherited, ref PTS.FSTRACKDESCRIPTION trackDesc)
{
PTS.FSKUPDATE fskupdate = trackDesc.fsupdinf.fskupd;
if (trackDesc.fsupdinf.fskupd == PTS.FSKUPDATE.fskupdInherited)
{
fskupdate = fskupdInherited;
}
if (fskupdate == PTS.FSKUPDATE.fskupdNoChange)
{
return;
}
ErrorHandler.Assert(fskupdate != PTS.FSKUPDATE.fskupdShifted, ErrorHandler.UpdateShiftedNotValid);
bool flag = trackDesc.pfstrack == IntPtr.Zero;
if (!flag)
{
PTS.FSTRACKDETAILS fstrackdetails;
PTS.Validate(PTS.FsQueryTrackDetails(ptsContext.Context, trackDesc.pfstrack, out fstrackdetails));
flag = (fstrackdetails.cParas == 0);
if (!flag)
{
PTS.FSPARADESCRIPTION[] arrayParaDesc;
PtsHelper.ParaListFromTrack(ptsContext, trackDesc.pfstrack, ref fstrackdetails, out arrayParaDesc);
PtsHelper.UpdateParaListVisuals(ptsContext, visualCollection, fskupdate, arrayParaDesc);
}
}
if (flag)
{
visualCollection.Clear();
}
}
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));
}
protected override void OnArrange()
{
base.OnArrange();
// Query paragraph details
PTS.FSSUBTRACKDETAILS subtrackDetails;
PTS.Validate(PTS.FsQuerySubtrackDetails(PtsContext.Context, _paraHandle.Value, out subtrackDetails));
// Adjust rectangle and offset to take into account MBPs
MbpInfo mbp = MbpInfo.FromElement(Paragraph.Element);
if (ParentFlowDirection != PageFlowDirection)
{
mbp.MirrorMargin();
}
_rect.u += mbp.MarginLeft;
_rect.du -= mbp.MarginLeft + mbp.MarginRight;
_rect.du = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.du);
_rect.dv = Math.Max(TextDpi.ToTextDpi(TextDpi.MinWidth), _rect.dv);
uint fswdirSubtrack = PTS.FlowDirectionToFswdir(_flowDirection);
// There is possibility to get empty track.
if (subtrackDetails.cParas != 0)
{
// Get list of paragraphs
PTS.FSPARADESCRIPTION [] arrayParaDesc;
PtsHelper.ParaListFromSubtrack(PtsContext, _paraHandle.Value, ref subtrackDetails, out arrayParaDesc);
PtsHelper.ArrangeParaList(PtsContext, subtrackDetails.fsrc, arrayParaDesc, fswdirSubtrack);
}
}
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.
// Adjust rectangle and offset to take into account MBPs
MbpInfo mbp = MbpInfo.FromElement(Paragraph.Element);
if (ThisFlowDirection != PageFlowDirection)
{
mbp.MirrorBP();
}
Brush backgroundBrush = (Brush)Paragraph.Element.GetValue(TextElement.BackgroundProperty);
_visual.DrawBackgroundAndBorder(backgroundBrush, mbp.BorderBrush, mbp.Border, _rect.FromTextDpi(), IsFirstChunk, IsLastChunk);
// There might be possibility to get empty sub-track, skip the sub-track in such case.
if (subtrackDetails.cParas != 0)
{
// Get list of paragraphs
PTS.FSPARADESCRIPTION [] arrayParaDesc;
PtsHelper.ParaListFromSubtrack(PtsContext, _paraHandle.Value, ref subtrackDetails, out arrayParaDesc);
// Render list of paragraphs
PtsHelper.UpdateParaListVisuals(PtsContext, _visual.Children, fskupdInherited, arrayParaDesc);
}
else
{
_visual.Children.Clear();
}
}
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 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));
}
private List <Rect> GetRectanglesInPage(ContentElement e, int start, int length)
{
List <Rect> list = new List <Rect>();
Invariant.Assert(!this.IsEmpty);
PTS.FSPAGEDETAILS fspagedetails;
PTS.Validate(PTS.FsQueryPageDetails(this.PtsContext.Context, this._ptsPage.Value, out fspagedetails));
if (PTS.ToBoolean(fspagedetails.fSimple))
{
list = PtsHelper.GetRectanglesInTrack(this.PtsContext, e, start, length, ref fspagedetails.u.simple.trackdescr);
}
else
{
ErrorHandler.Assert(fspagedetails.u.complex.cFootnoteColumns == 0, ErrorHandler.NotSupportedFootnotes);
if (fspagedetails.u.complex.cSections != 0)
{
PTS.FSSECTIONDESCRIPTION[] array;
PtsHelper.SectionListFromPage(this.PtsContext, this._ptsPage.Value, ref fspagedetails, out array);
for (int i = 0; i < array.Length; i++)
{
list = this.GetRectanglesInSection(e, start, length, ref array[i]);
Invariant.Assert(list != null);
if (list.Count != 0)
{
break;
}
}
}
else
{
list = new List <Rect>();
}
}
return(list);
}
internal ReadOnlyCollection <ParagraphResult> GetParagraphResultsFromColumn(IntPtr pfstrack, Vector parentOffset, out bool hasTextContent)
{
Invariant.Assert(!this.IsDisposed);
PTS.FSTRACKDETAILS fstrackdetails;
PTS.Validate(PTS.FsQueryTrackDetails(this.StructuralCache.PtsContext.Context, pfstrack, out fstrackdetails));
hasTextContent = false;
if (fstrackdetails.cParas == 0)
{
return(new ReadOnlyCollection <ParagraphResult>(new List <ParagraphResult>(0)));
}
PTS.FSPARADESCRIPTION[] array;
PtsHelper.ParaListFromTrack(this.StructuralCache.PtsContext, pfstrack, ref fstrackdetails, out array);
List <ParagraphResult> list = new List <ParagraphResult>(array.Length);
for (int i = 0; i < array.Length; i++)
{
BaseParaClient baseParaClient = this.StructuralCache.PtsContext.HandleToObject(array[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(baseParaClient);
ParagraphResult paragraphResult = baseParaClient.CreateParagraphResult();
if (paragraphResult.HasTextContent)
{
hasTextContent = true;
}
list.Add(paragraphResult);
}
return(new ReadOnlyCollection <ParagraphResult>(list));
}
internal override void UpdateViewport(ref PTS.FSRECT viewport)
{
PTS.FSSUBPAGEDETAILS fssubpagedetails;
PTS.Validate(PTS.FsQuerySubpageDetails(base.PtsContext.Context, this._paraHandle.Value, out fssubpagedetails));
PTS.FSRECT fsrect = default(PTS.FSRECT);
fsrect.u = viewport.u - this.ContentRect.u;
fsrect.v = viewport.v - this.ContentRect.v;
fsrect.du = viewport.du;
fsrect.dv = viewport.dv;
if (PTS.ToBoolean(fssubpagedetails.fSimple))
{
PtsHelper.UpdateViewportTrack(base.PtsContext, ref fssubpagedetails.u.simple.trackdescr, ref fsrect);
return;
}
if (fssubpagedetails.u.complex.cBasicColumns != 0)
{
PTS.FSTRACKDESCRIPTION[] array;
PtsHelper.TrackListFromSubpage(base.PtsContext, this._paraHandle.Value, ref fssubpagedetails, out array);
if (array.Length != 0)
{
for (int i = 0; i < array.Length; i++)
{
PtsHelper.UpdateViewportTrack(base.PtsContext, ref array[i], ref fsrect);
}
}
}
}
protected override void OnArrange()
{
base.OnArrange();
((FloaterParagraph)base.Paragraph).UpdateSegmentLastFormatPositions();
PTS.FSSUBPAGEDETAILS fssubpagedetails;
PTS.Validate(PTS.FsQuerySubpageDetails(base.PtsContext.Context, this._paraHandle.Value, out fssubpagedetails));
this._pageContext.AddFloatingParaClient(this);
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();
}
}
}
internal override List <Rect> GetRectangles(ContentElement e, int start, int length)
{
List <Rect> list = new List <Rect>();
if (base.Paragraph.Element as ContentElement == e)
{
this.GetRectanglesForParagraphElement(out list);
}
else
{
PTS.FSSUBPAGEDETAILS fssubpagedetails;
PTS.Validate(PTS.FsQuerySubpageDetails(base.PtsContext.Context, this._paraHandle.Value, out fssubpagedetails));
if (PTS.ToBoolean(fssubpagedetails.fSimple))
{
list = PtsHelper.GetRectanglesInTrack(base.PtsContext, e, start, length, ref fssubpagedetails.u.simple.trackdescr);
}
else 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++)
{
List <Rect> rectanglesInTrack = PtsHelper.GetRectanglesInTrack(base.PtsContext, e, start, length, ref array[i]);
Invariant.Assert(rectanglesInTrack != null);
if (rectanglesInTrack.Count != 0)
{
list.AddRange(rectanglesInTrack);
}
}
}
list = PtsHelper.OffsetRectangleList(list, TextDpi.FromTextDpi(this.ContentRect.u), TextDpi.FromTextDpi(this.ContentRect.v));
}
Invariant.Assert(list != null);
return(list);
}
private List <Rect> GetRectanglesInSection(ContentElement e, int start, int length, ref PTS.FSSECTIONDESCRIPTION sectionDesc)
{
PTS.FSSECTIONDETAILS fssectiondetails;
PTS.Validate(PTS.FsQuerySectionDetails(this.PtsContext.Context, sectionDesc.pfssection, out fssectiondetails));
List <Rect> list = new List <Rect>();
if (PTS.ToBoolean(fssectiondetails.fFootnotesAsPagenotes))
{
ErrorHandler.Assert(fssectiondetails.u.withpagenotes.cEndnoteColumns == 0, ErrorHandler.NotSupportedFootnotes);
if (fssectiondetails.u.withpagenotes.cBasicColumns != 0)
{
PTS.FSTRACKDESCRIPTION[] array;
PtsHelper.TrackListFromSection(this.PtsContext, sectionDesc.pfssection, ref fssectiondetails, out array);
for (int i = 0; i < array.Length; i++)
{
List <Rect> rectanglesInTrack = PtsHelper.GetRectanglesInTrack(this.PtsContext, e, start, length, ref array[i]);
Invariant.Assert(rectanglesInTrack != null);
if (rectanglesInTrack.Count != 0)
{
list.AddRange(rectanglesInTrack);
}
}
}
}
else
{
ErrorHandler.Assert(false, ErrorHandler.NotSupportedCompositeColumns);
}
return(list);
}
private IInputElement InputHitTestSection(PTS.FSPOINT pt, ref PTS.FSSECTIONDESCRIPTION sectionDesc)
{
IInputElement result = null;
PTS.FSSECTIONDETAILS fssectiondetails;
PTS.Validate(PTS.FsQuerySectionDetails(this.PtsContext.Context, sectionDesc.pfssection, out fssectiondetails));
if (PTS.ToBoolean(fssectiondetails.fFootnotesAsPagenotes))
{
ErrorHandler.Assert(fssectiondetails.u.withpagenotes.cEndnoteColumns == 0, ErrorHandler.NotSupportedFootnotes);
if (fssectiondetails.u.withpagenotes.cBasicColumns != 0)
{
PTS.FSTRACKDESCRIPTION[] array;
PtsHelper.TrackListFromSection(this.PtsContext, sectionDesc.pfssection, ref fssectiondetails, out array);
for (int i = 0; i < array.Length; i++)
{
if (array[i].fsrc.Contains(pt))
{
result = PtsHelper.InputHitTestTrack(this.PtsContext, pt, ref array[i]);
break;
}
}
}
}
else
{
ErrorHandler.Assert(false, ErrorHandler.NotSupportedCompositeColumns);
}
return(result);
}
// ------------------------------------------------------------------
// Returns calculated column information - count, width, gap and rule.
// ------------------------------------------------------------------
internal static void GetColumnMetrics(StructuralCache structuralCache, out int cColumns, out double width, out double gap, out double rule)
{
ColumnPropertiesGroup columnProperties = new ColumnPropertiesGroup(structuralCache.PropertyOwner);
FontFamily pageFontFamily = (FontFamily)structuralCache.PropertyOwner.GetValue(Block.FontFamilyProperty);
double lineHeight = DynamicPropertyReader.GetLineHeightValue(structuralCache.PropertyOwner);
double pageFontSize = (double)structuralCache.PropertyOwner.GetValue(Block.FontSizeProperty);
Size pageSize = structuralCache.CurrentFormatContext.PageSize;
Thickness pageMargin = structuralCache.CurrentFormatContext.PageMargin;
double pageWidth = pageSize.Width - (pageMargin.Left + pageMargin.Right);
cColumns = PtsHelper.CalculateColumnCount(columnProperties, lineHeight, pageWidth, pageFontSize, pageFontFamily, true);
double freeSpace;
rule = columnProperties.ColumnRuleWidth;
PtsHelper.GetColumnMetrics(columnProperties, pageWidth,
pageFontSize, pageFontFamily, true, cColumns,
ref lineHeight, out width, out freeSpace, out gap);
if (columnProperties.IsColumnWidthFlexible && columnProperties.ColumnSpaceDistribution == ColumnSpaceDistribution.Between)
{
width += freeSpace / cColumns;
}
width = Math.Min(width, pageWidth);
}
internal override IInputElement InputHitTest(PTS.FSPOINT pt)
{
IInputElement ie = null;
// Query paragraph details
PTS.FSSUBTRACKDETAILS subtrackDetails;
PTS.Validate(PTS.FsQuerySubtrackDetails(PtsContext.Context, _paraHandle.Value, out subtrackDetails));
// Hittest subtrack content.
// There might be possibility to get empty sub-track, skip the sub-track
// in such case.
if (subtrackDetails.cParas != 0)
{
// Get list of paragraphs
PTS.FSPARADESCRIPTION [] arrayParaDesc;
PtsHelper.ParaListFromSubtrack(PtsContext, _paraHandle.Value, ref subtrackDetails, out arrayParaDesc);
// Render list of paragraphs
ie = PtsHelper.InputHitTestParaList(PtsContext, pt, ref subtrackDetails.fsrc, arrayParaDesc);
}
// If nothing is hit, return the owner of the paragraph.
if (ie == null && _rect.Contains(pt))
{
ie = Paragraph.Element as IInputElement;
}
return(ie);
}
// ------------------------------------------------------------------
// Return TextContentRange for the content of the paragraph.
// ------------------------------------------------------------------
internal override TextContentRange GetTextContentRange()
{
TextContentRange textContentRange;
// Query subpage details
PTS.FSSUBPAGEDETAILS subpageDetails;
PTS.Validate(PTS.FsQuerySubpageDetails(PtsContext.Context, _paraHandle.Value, out subpageDetails));
// 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)
textContentRange = PtsHelper.TextContentRangeFromTrack(PtsContext, subpageDetails.u.simple.trackdescr.pfstrack);
}
else
{
textContentRange = new TextContentRange();
// (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++)
{
// Merge TextContentRanges for all columns
textContentRange.Merge(PtsHelper.TextContentRangeFromTrack(PtsContext, arrayColumnDesc[index].pfstrack));
}
}
}
TextElement elementOwner = this.Paragraph.Element as TextElement;
// If the first paragraph is the first paragraph in the container and it is the first chunk,
// include start position of this element.
if (_isFirstChunk)
{
textContentRange.Merge(TextContainerHelper.GetTextContentRangeForTextElementEdge(
elementOwner, ElementEdge.BeforeStart));
}
// If the last paragraph is the last paragraph in the container and it is the last chunk,
// include end position of this element.
if (_isLastChunk)
{
textContentRange.Merge(TextContainerHelper.GetTextContentRangeForTextElementEdge(
elementOwner, ElementEdge.AfterEnd));
}
Invariant.Assert(textContentRange != null);
return(textContentRange);
}
internal ReadOnlyCollection <ColumnResult> GetColumnResults(out bool hasTextContent)
{
Invariant.Assert(!this.IsDisposed);
List <ColumnResult> list = new List <ColumnResult>(0);
hasTextContent = false;
if (!(this._ptsPage.PageHandle == IntPtr.Zero))
{
PTS.FSPAGEDETAILS fspagedetails;
PTS.Validate(PTS.FsQueryPageDetails(this.StructuralCache.PtsContext.Context, this._ptsPage.PageHandle, out fspagedetails));
if (PTS.ToBoolean(fspagedetails.fSimple))
{
PTS.FSTRACKDETAILS fstrackdetails;
PTS.Validate(PTS.FsQueryTrackDetails(this.StructuralCache.PtsContext.Context, fspagedetails.u.simple.trackdescr.pfstrack, out fstrackdetails));
if (fstrackdetails.cParas > 0)
{
list = new List <ColumnResult>(1);
ColumnResult columnResult = new ColumnResult(this, ref fspagedetails.u.simple.trackdescr, default(Vector));
list.Add(columnResult);
if (columnResult.HasTextContent)
{
hasTextContent = true;
}
}
}
else if (fspagedetails.u.complex.cSections > 0)
{
PTS.FSSECTIONDESCRIPTION[] array;
PtsHelper.SectionListFromPage(this.StructuralCache.PtsContext, this._ptsPage.PageHandle, ref fspagedetails, out array);
PTS.FSSECTIONDETAILS fssectiondetails;
PTS.Validate(PTS.FsQuerySectionDetails(this.StructuralCache.PtsContext.Context, array[0].pfssection, out fssectiondetails));
if (PTS.ToBoolean(fssectiondetails.fFootnotesAsPagenotes) && fssectiondetails.u.withpagenotes.cBasicColumns > 0)
{
PTS.FSTRACKDESCRIPTION[] array2;
PtsHelper.TrackListFromSection(this.StructuralCache.PtsContext, array[0].pfssection, ref fssectiondetails, out array2);
list = new List <ColumnResult>(fssectiondetails.u.withpagenotes.cBasicColumns);
foreach (PTS.FSTRACKDESCRIPTION fstrackdescription in array2)
{
if (fstrackdescription.pfstrack != IntPtr.Zero)
{
PTS.FSTRACKDETAILS fstrackdetails2;
PTS.Validate(PTS.FsQueryTrackDetails(this.StructuralCache.PtsContext.Context, fstrackdescription.pfstrack, out fstrackdetails2));
if (fstrackdetails2.cParas > 0)
{
ColumnResult columnResult2 = new ColumnResult(this, ref fstrackdescription, default(Vector));
list.Add(columnResult2);
if (columnResult2.HasTextContent)
{
hasTextContent = true;
}
}
}
}
}
}
}
Invariant.Assert(list != null);
return(new ReadOnlyCollection <ColumnResult>(list));
}
private void UpdateSectionVisuals(SectionVisual visual, PTS.FSKUPDATE fskupdInherited, ref PTS.FSSECTIONDESCRIPTION sectionDesc)
{
PTS.FSKUPDATE fskupdate = sectionDesc.fsupdinf.fskupd;
if (fskupdate == PTS.FSKUPDATE.fskupdInherited)
{
fskupdate = fskupdInherited;
}
ErrorHandler.Assert(fskupdate != PTS.FSKUPDATE.fskupdShifted, ErrorHandler.UpdateShiftedNotValid);
if (fskupdate == PTS.FSKUPDATE.fskupdNoChange)
{
return;
}
PTS.FSSECTIONDETAILS fssectiondetails;
PTS.Validate(PTS.FsQuerySectionDetails(this.PtsContext.Context, sectionDesc.pfssection, out fssectiondetails));
bool flag;
if (PTS.ToBoolean(fssectiondetails.fFootnotesAsPagenotes))
{
ErrorHandler.Assert(fssectiondetails.u.withpagenotes.cEndnoteColumns == 0, ErrorHandler.NotSupportedFootnotes);
flag = (fssectiondetails.u.withpagenotes.cBasicColumns == 0);
if (!flag)
{
PTS.FSTRACKDESCRIPTION[] array;
PtsHelper.TrackListFromSection(this.PtsContext, sectionDesc.pfssection, ref fssectiondetails, out array);
flag = (array.Length == 0);
if (!flag)
{
ColumnPropertiesGroup columnProperties = new ColumnPropertiesGroup(this._section.Element);
visual.DrawColumnRules(ref array, TextDpi.FromTextDpi(sectionDesc.fsrc.v), TextDpi.FromTextDpi(sectionDesc.fsrc.dv), columnProperties);
VisualCollection children = visual.Children;
if (fskupdate == PTS.FSKUPDATE.fskupdNew)
{
children.Clear();
for (int i = 0; i < array.Length; i++)
{
children.Add(new ContainerVisual());
}
}
ErrorHandler.Assert(children.Count == array.Length, ErrorHandler.ColumnVisualCountMismatch);
for (int j = 0; j < array.Length; j++)
{
ContainerVisual containerVisual = (ContainerVisual)children[j];
PtsHelper.UpdateTrackVisuals(this.PtsContext, containerVisual.Children, fskupdate, ref array[j]);
}
}
}
}
else
{
ErrorHandler.Assert(false, ErrorHandler.NotSupportedCompositeColumns);
flag = true;
}
if (flag)
{
visual.Children.Clear();
}
}
protected override void OnArrange()
{
base.OnArrange();
((FloaterParagraph)Paragraph).UpdateSegmentLastFormatPositions();
// Query subpage details
PTS.FSSUBPAGEDETAILS subpageDetails;
PTS.Validate(PTS.FsQuerySubpageDetails(PtsContext.Context, _paraHandle.Value, out subpageDetails));
_pageContext.AddFloatingParaClient(this);
// Arrange subpage content. Subpage content may be simple or complex -
// depending of set of features used in the content of the subpage.
// (1) simple subpage (contains only one track)
// (2) complex subpage (contains columns)
if (PTS.ToBoolean(subpageDetails.fSimple))
{
_pageContextOfThisPage.PageRect = new PTS.FSRECT(subpageDetails.u.simple.trackdescr.fsrc);
// (1) simple subpage (contains only one track)
// Exceptions don't need to pop, as the top level arrange context will be nulled out if thrown.
Paragraph.StructuralCache.CurrentArrangeContext.PushNewPageData(_pageContextOfThisPage, subpageDetails.u.simple.trackdescr.fsrc,
Paragraph.StructuralCache.CurrentArrangeContext.FinitePage);
PtsHelper.ArrangeTrack(PtsContext, ref subpageDetails.u.simple.trackdescr, subpageDetails.u.simple.fswdir);
Paragraph.StructuralCache.CurrentArrangeContext.PopPageData();
}
else
{
_pageContextOfThisPage.PageRect = new PTS.FSRECT(subpageDetails.u.complex.fsrc);
// (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++)
{
// Exceptions don't need to pop, as the top level arrange context will be nulled out if thrown.
Paragraph.StructuralCache.CurrentArrangeContext.PushNewPageData(_pageContextOfThisPage, arrayColumnDesc[index].fsrc,
Paragraph.StructuralCache.CurrentArrangeContext.FinitePage);
PtsHelper.ArrangeTrack(PtsContext, ref arrayColumnDesc[index], subpageDetails.u.complex.fswdir);
Paragraph.StructuralCache.CurrentArrangeContext.PopPageData();
}
}
}
}
internal override TextContentRange GetTextContentRange()
{
TextElement elementOwner = this.Paragraph.Element as TextElement;
TextContentRange textContentRange;
BaseParaClient paraClient;
PTS.FSSUBTRACKDETAILS subtrackDetails;
PTS.FSPARADESCRIPTION[] arrayParaDesc;
Invariant.Assert(elementOwner != null, "Expecting TextElement as owner of ContainerParagraph.");
// Query paragraph details
PTS.Validate(PTS.FsQuerySubtrackDetails(PtsContext.Context, _paraHandle.Value, out subtrackDetails));
// If container is empty, return range for the entire element.
// If the beginning and the end of content of the paragraph is
// part of this ParaClient, return range for the entire element.
// Otherwise combine ranges from all nested paragraphs.
if (subtrackDetails.cParas == 0 || (_isFirstChunk && _isLastChunk))
{
textContentRange = TextContainerHelper.GetTextContentRangeForTextElement(elementOwner);
}
else
{
PtsHelper.ParaListFromSubtrack(PtsContext, _paraHandle.Value, ref subtrackDetails, out arrayParaDesc);
// Merge TextContentRanges for all paragraphs
textContentRange = new TextContentRange();
for (int i = 0; i < arrayParaDesc.Length; i++)
{
paraClient = Paragraph.StructuralCache.PtsContext.HandleToObject(arrayParaDesc[i].pfsparaclient) as BaseParaClient;
PTS.ValidateHandle(paraClient);
textContentRange.Merge(paraClient.GetTextContentRange());
}
// If the first paragraph is the first paragraph in the container and it is the first chunk,
// include start position of this element.
if (_isFirstChunk)
{
textContentRange.Merge(TextContainerHelper.GetTextContentRangeForTextElementEdge(
elementOwner, ElementEdge.BeforeStart));
}
// If the last paragraph is the last paragraph in the container and it is the last chunk,
// include end position of this element.
if (_isLastChunk)
{
textContentRange.Merge(TextContainerHelper.GetTextContentRangeForTextElementEdge(
elementOwner, ElementEdge.AfterEnd));
}
}
Invariant.Assert(textContentRange != null);
return(textContentRange);
}
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);
}
