// ------------------------------------------------------------------ // 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); }
// ------------------------------------------------------------------ // Table has been structurally altered // ------------------------------------------------------------------ private void TableStructureChanged(object sender, EventArgs e) { // Disconnect obsolete paragraphs. BaseParagraph paraInvalid = _firstChild; while (paraInvalid != null) { paraInvalid.Dispose(); paraInvalid = paraInvalid.Next; } _firstChild = null; // // Since whole table content is disposed, we need // - to create dirty text range corresponding to the Table content // - notify formatter that Table's content is changed. // int charCount = Table.SymbolCount - 2;// This is equivalent to (ContentEndOffset – ContentStartOffset) but is more performant. if (charCount > 0) { DirtyTextRange dtr = new DirtyTextRange(Table.ContentStartOffset, charCount, charCount); StructuralCache.AddDirtyTextRange(dtr); } if (StructuralCache.FormattingOwner.Formatter != null) { StructuralCache.FormattingOwner.Formatter.OnContentInvalidated(true, Table.ContentStart, Table.ContentEnd); } }
// ------------------------------------------------------------------ // 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); }
// Token: 0x06006742 RID: 26434 RVA: 0x001CDD66 File Offset: 0x001CBF66 protected BaseParagraph(DependencyObject element, StructuralCache structuralCache) : base(structuralCache.PtsContext) { this._element = element; this._structuralCache = structuralCache; this._changeType = PTS.FSKCHANGE.fskchNone; this._stopAsking = false; this.UpdateLastFormatPositions(); }
// Token: 0x060067D1 RID: 26577 RVA: 0x001D1984 File Offset: 0x001CFB84 internal static double CalculateFigureHeight(StructuralCache structuralCache, Figure figure, FigureLength figureLength, out bool isHeightAuto) { double num; if (figureLength.IsPage) { num = structuralCache.CurrentFormatContext.PageHeight * figureLength.Value; } else if (figureLength.IsContent) { Thickness pageMargin = structuralCache.CurrentFormatContext.PageMargin; num = (structuralCache.CurrentFormatContext.PageHeight - pageMargin.Top - pageMargin.Bottom) * figureLength.Value; } else if (figureLength.IsColumn) { int num2; double num3; double num4; double num5; FigureHelper.GetColumnMetrics(structuralCache, out num2, out num3, out num4, out num5); double num6 = figureLength.Value; if (num6 > (double)num2) { num6 = (double)num2; } int num7 = (int)num6; if ((double)num7 == num6 && num7 > 0) { num7--; } num = num3 * num6 + num4 * (double)num7; } else { num = FigureHelper.CalculateFigureCommon(figureLength); } if (!DoubleUtil.IsNaN(num)) { FigureVerticalAnchor verticalAnchor = figure.VerticalAnchor; if (FigureHelper.IsVerticalPageAnchor(verticalAnchor)) { num = Math.Max(1.0, Math.Min(num, structuralCache.CurrentFormatContext.PageHeight)); } else { Thickness pageMargin2 = structuralCache.CurrentFormatContext.PageMargin; num = Math.Max(1.0, Math.Min(num, structuralCache.CurrentFormatContext.PageHeight - pageMargin2.Top - pageMargin2.Bottom)); } TextDpi.EnsureValidPageWidth(ref num); isHeightAuto = false; } else { num = structuralCache.CurrentFormatContext.PageHeight; isHeightAuto = true; } return(num); }
/// <summary> /// Invalidates main text segment for bottomless pages if DTR list for this para is non-null. /// </summary> private void InvalidateMainTextSegment() { DtrList dtrs = StructuralCache.DtrsFromRange(ParagraphStartCharacterPosition, LastFormatCch); if (dtrs != null && dtrs.Length > 0) { _mainTextSegment.InvalidateStructure(dtrs[0].StartIndex); } }
//------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors /// <summary> /// Constructor. /// </summary> /// <param name="element"> /// Element associated with paragraph. /// </param> /// <param name="structuralCache"> /// Content's structural cache /// </param> protected BaseParagraph(DependencyObject element, StructuralCache structuralCache) : base(structuralCache.PtsContext) { _element = element; _structuralCache = structuralCache; _changeType = PTS.FSKCHANGE.fskchNone; _stopAsking = false; UpdateLastFormatPositions(); }
// Token: 0x06008AB0 RID: 35504 RVA: 0x002576EC File Offset: 0x002558EC internal DocumentOperationContext(StructuralCache owner, FlowDocumentPage page) { Invariant.Assert(owner != null, "Invalid owner object."); Invariant.Assert(page != null, "Invalid page object."); Invariant.Assert(owner._currentPage == null, "Page formatting reentrancy detected. Trying to create second _DocumentPageContext for the same StructuralCache."); this._owner = owner; this._owner._currentPage = page; this._owner._illegalTreeChangeDetected = false; owner.PtsContext.Enter(); }
// ------------------------------------------------------------------ // Width figure size calculation // ------------------------------------------------------------------ internal static double CalculateFigureWidth(StructuralCache structuralCache, Figure figure, FigureLength figureLength, out bool isWidthAuto) { double value; isWidthAuto = figureLength.IsAuto ? true : false; // Check figure's horizontal anchor. If anchored to page, use page width to format FigureHorizontalAnchor horizontalAnchor = figure.HorizontalAnchor; if (figureLength.IsPage || (figureLength.IsAuto && IsHorizontalPageAnchor(horizontalAnchor))) { value = structuralCache.CurrentFormatContext.PageWidth * figureLength.Value; } else if (figureLength.IsAbsolute) { value = CalculateFigureCommon(figureLength); } else // figureLength.IsColumn || figureLength.IsContent || figureLength.IsAuto { double columnWidth, gap, rule; int cColumns; GetColumnMetrics(structuralCache, out cColumns, out columnWidth, out gap, out rule); if (figureLength.IsContent || (figureLength.IsAuto && IsHorizontalContentAnchor(horizontalAnchor))) { // Use content width for figure value = (columnWidth * cColumns + gap * (cColumns - 1)) * figureLength.Value; } else // figureLength.IsColumn || figureLength.IsAuto { // We do this to prevent a 2.0 columns from spanning 2.0 + gap, so we just check for edge double lengthValue = figureLength.Value; int columnGapsSpanned = (int)lengthValue; if (columnGapsSpanned == lengthValue && columnGapsSpanned > 0) { columnGapsSpanned -= 1; } value = (columnWidth * lengthValue) + gap * columnGapsSpanned; } } Invariant.Assert(!double.IsNaN(value)); return(value); }
// ------------------------------------------------------------------ // Width figure size calculation // ------------------------------------------------------------------ internal static double CalculateFigureWidth(StructuralCache structuralCache, Figure figure, FigureLength figureLength, out bool isWidthAuto) { double value; isWidthAuto = figureLength.IsAuto ? true : false; // Check figure's horizontal anchor. If anchored to page, use page width to format FigureHorizontalAnchor horizontalAnchor = figure.HorizontalAnchor; if(figureLength.IsPage || (figureLength.IsAuto && IsHorizontalPageAnchor(horizontalAnchor))) { value = structuralCache.CurrentFormatContext.PageWidth * figureLength.Value; } else if (figureLength.IsAbsolute) { value = CalculateFigureCommon(figureLength); } else // figureLength.IsColumn || figureLength.IsContent || figureLength.IsAuto { double columnWidth, gap, rule; int cColumns; GetColumnMetrics(structuralCache, out cColumns, out columnWidth, out gap, out rule); if (figureLength.IsContent || (figureLength.IsAuto && IsHorizontalContentAnchor(horizontalAnchor))) { // Use content width for figure value = (columnWidth * cColumns + gap * (cColumns - 1)) * figureLength.Value; } else // figureLength.IsColumn || figureLength.IsAuto { // We do this to prevent a 2.0 columns from spanning 2.0 + gap, so we just check for edge double lengthValue = figureLength.Value; int columnGapsSpanned = (int) lengthValue; if(columnGapsSpanned == lengthValue && columnGapsSpanned > 0) { columnGapsSpanned -= 1; } value = (columnWidth * lengthValue) + gap * columnGapsSpanned; } } Invariant.Assert(!DoubleUtil.IsNaN(value)); return value; }
// Token: 0x060067D0 RID: 26576 RVA: 0x001D18A4 File Offset: 0x001CFAA4 internal static double CalculateFigureWidth(StructuralCache structuralCache, Figure figure, FigureLength figureLength, out bool isWidthAuto) { isWidthAuto = figureLength.IsAuto; FigureHorizontalAnchor horizontalAnchor = figure.HorizontalAnchor; double num; if (figureLength.IsPage || (figureLength.IsAuto && FigureHelper.IsHorizontalPageAnchor(horizontalAnchor))) { num = structuralCache.CurrentFormatContext.PageWidth * figureLength.Value; } else if (figureLength.IsAbsolute) { num = FigureHelper.CalculateFigureCommon(figureLength); } else { int num2; double num3; double num4; double num5; FigureHelper.GetColumnMetrics(structuralCache, out num2, out num3, out num4, out num5); if (figureLength.IsContent || (figureLength.IsAuto && FigureHelper.IsHorizontalContentAnchor(horizontalAnchor))) { num = (num3 * (double)num2 + num4 * (double)(num2 - 1)) * figureLength.Value; } else { double value = figureLength.Value; int num6 = (int)value; if ((double)num6 == value && num6 > 0) { num6--; } num = num3 * value + num4 * (double)num6; } } Invariant.Assert(!DoubleUtil.IsNaN(num)); return(num); }
internal void CreateFinitePage(PageBreakRecord breakRecord) { this.OnBeforeFormatPage(true, false); if (TracePageFormatting.IsEnabled) { TracePageFormatting.Trace(TraceEventType.Start, TracePageFormatting.FormatPage, this.PageContext, this.PtsContext); } IntPtr pfsBRPageStart = (breakRecord != null) ? breakRecord.BreakRecord : IntPtr.Zero; PTS.FSFMTR fsfmtr; IntPtr value; IntPtr zero; int num = PTS.FsCreatePageFinite(this.PtsContext.Context, pfsBRPageStart, this._section.Handle, out fsfmtr, out value, out zero); if (num != 0) { this._ptsPage.Value = IntPtr.Zero; zero = IntPtr.Zero; PTS.ValidateAndTrace(num, this.PtsContext); } else { this._ptsPage.Value = value; } if (zero != IntPtr.Zero) { StructuralCache structuralCache = this._section.StructuralCache; if (structuralCache != null) { this._breakRecord = new PageBreakRecord(this.PtsContext, new SecurityCriticalDataForSet <IntPtr>(zero), (breakRecord != null) ? (breakRecord.PageNumber + 1) : 1); } } if (TracePageFormatting.IsEnabled) { TracePageFormatting.Trace(TraceEventType.Stop, TracePageFormatting.FormatPage, this.PageContext, this.PtsContext); } this.OnAfterFormatPage(true, false); }
// Token: 0x06006942 RID: 26946 RVA: 0x001DCDB0 File Offset: 0x001DAFB0 internal static double CalculatePageMarginAdjustment(StructuralCache structuralCache, double pageMarginWidth) { double result = 0.0; DependencyObject element = structuralCache.Section.Element; if (element is FlowDocument) { ColumnPropertiesGroup columnPropertiesGroup = new ColumnPropertiesGroup(element); if (!columnPropertiesGroup.IsColumnWidthFlexible) { double lineHeightValue = DynamicPropertyReader.GetLineHeightValue(element); double pageFontSize = (double)structuralCache.PropertyOwner.GetValue(TextElement.FontSizeProperty); FontFamily pageFontFamily = (FontFamily)structuralCache.PropertyOwner.GetValue(TextElement.FontFamilyProperty); int cColumns = PtsHelper.CalculateColumnCount(columnPropertiesGroup, lineHeightValue, pageMarginWidth, pageFontSize, pageFontFamily, true); double num; double num2; double num3; PtsHelper.GetColumnMetrics(columnPropertiesGroup, pageMarginWidth, pageFontSize, pageFontFamily, true, cColumns, ref lineHeightValue, out num, out num2, out num3); result = num2; } } return(result); }
internal void UpdateFinitePage(PageBreakRecord breakRecord) { if (this.IsEmpty) { return; } this.OnBeforeFormatPage(true, true); if (TracePageFormatting.IsEnabled) { TracePageFormatting.Trace(TraceEventType.Start, TracePageFormatting.FormatPage, this.PageContext, this.PtsContext); } IntPtr pfsBRPageStart = (breakRecord != null) ? breakRecord.BreakRecord : IntPtr.Zero; PTS.FSFMTR fsfmtr; IntPtr intPtr; int num = PTS.FsUpdateFinitePage(this.PtsContext.Context, this._ptsPage.Value, pfsBRPageStart, this._section.Handle, out fsfmtr, out intPtr); if (num != 0) { this.DestroyPage(); PTS.ValidateAndTrace(num, this.PtsContext); } if (intPtr != IntPtr.Zero) { StructuralCache structuralCache = this._section.StructuralCache; if (structuralCache != null) { this._breakRecord = new PageBreakRecord(this.PtsContext, new SecurityCriticalDataForSet <IntPtr>(intPtr), (breakRecord != null) ? (breakRecord.PageNumber + 1) : 1); } } if (TracePageFormatting.IsEnabled) { TracePageFormatting.Trace(TraceEventType.Stop, TracePageFormatting.FormatPage, this.PageContext, this.PtsContext); } this.OnAfterFormatPage(true, true); }
// Token: 0x06006830 RID: 26672 RVA: 0x001D58E5 File Offset: 0x001D3AE5 internal FlowDocumentPage(StructuralCache structuralCache) : base(null) { this._structuralCache = structuralCache; this._ptsPage = new PtsPage(structuralCache.Section); }
/// <summary> /// Constructor /// </summary> /// <param name="owner">Associated structural cache instance</param> /// <param name="page">Document page to set</param> internal DocumentArrangeContext(StructuralCache owner, FlowDocumentPage page) : base(owner, page) { _owner._documentArrangeContext = this; }
// ------------------------------------------------------------------ // Height figure size calculation // ------------------------------------------------------------------ internal static double CalculateFigureHeight(StructuralCache structuralCache, Figure figure, FigureLength figureLength, out bool isHeightAuto) { double value; if(figureLength.IsPage) { value = (structuralCache.CurrentFormatContext.PageHeight) * figureLength.Value; } else if(figureLength.IsContent) // Column to be treated same as content { Thickness pageMargin = structuralCache.CurrentFormatContext.PageMargin; value = (structuralCache.CurrentFormatContext.PageHeight - pageMargin.Top - pageMargin.Bottom) * figureLength.Value; } else if (figureLength.IsColumn) { // Height is calculated based on column width, since column height is the same as content. Per spec. // Retrieve all column metrics for current page int cColumns; double columnWidth; double gap; double rule; FigureHelper.GetColumnMetrics(structuralCache, out cColumns, out columnWidth, out gap, out rule); // We do this to prevent a 2.0 columns from spanning 2.0 + gap, so we just check for edge double lengthValue = figureLength.Value; if (lengthValue > cColumns) { lengthValue = cColumns; } int columnGapsSpanned = (int)lengthValue; if (columnGapsSpanned == lengthValue && columnGapsSpanned > 0) { columnGapsSpanned -= 1; } value = (columnWidth * lengthValue) + gap * columnGapsSpanned; } else { value = FigureHelper.CalculateFigureCommon(figureLength); } if(!DoubleUtil.IsNaN(value)) { FigureVerticalAnchor verticalAnchor = figure.VerticalAnchor; // Value is in pixels. Now we limit value to max out depending on anchoring. if(FigureHelper.IsVerticalPageAnchor(verticalAnchor)) { value = Math.Max(1, Math.Min(value, structuralCache.CurrentFormatContext.PageHeight)); } else // Column and paragraph anchoring still max out at content height { Thickness pageMargin = structuralCache.CurrentFormatContext.PageMargin; value = Math.Max(1, Math.Min(value, structuralCache.CurrentFormatContext.PageHeight - pageMargin.Top - pageMargin.Bottom)); } TextDpi.EnsureValidPageWidth(ref value); isHeightAuto = false; } else { value = structuralCache.CurrentFormatContext.PageHeight; isHeightAuto = true; } return value; }
//------------------------------------------------------ // // Constructors // //------------------------------------------------------ #region Constructors internal TableParagraph(DependencyObject element, StructuralCache structuralCache) : base(element, structuralCache) { Table.TableStructureChanged += new System.EventHandler(TableStructureChanged); }
//------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors /// <summary> /// Constructor /// </summary> /// <param name="structuralCache"> /// Content's structural cache /// </param> internal Section(StructuralCache structuralCache) : base(structuralCache.PtsContext) { _structuralCache = structuralCache; }
/// <summary> /// Initialize FlowDocument. /// </summary> /// <param name="textContainer"></param> private void Initialize(TextContainer textContainer) { if (textContainer == null) { // Create text tree that contains content of the element. textContainer = new TextContainer(this, false /* plainTextOnly */); } // Create structural cache object _structuralCache = new StructuralCache(this, textContainer); // Get rid of the current formatter. if (_formatter != null) { _formatter.Suspend(); _formatter = null; } }
// ------------------------------------------------------------------ // 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; }
// Token: 0x06006AC6 RID: 27334 RVA: 0x001E8FFB File Offset: 0x001E71FB internal TableParagraph(DependencyObject element, StructuralCache structuralCache) : base(element, structuralCache) { this.Table.TableStructureChanged += this.TableStructureChanged; }
//------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors // ------------------------------------------------------------------ // Constructor. // // element - Element associated with paragraph. // structuralCache - Content's structural cache // ------------------------------------------------------------------ internal FloaterParagraph(TextElement element, StructuralCache structuralCache) : base(element, structuralCache) { }
// ------------------------------------------------------------------ // Constructor. // // element - Element associated with paragraph. // structuralCache - Content's structural cache // ------------------------------------------------------------------ internal CellParagraph(DependencyObject element, StructuralCache structuralCache) : base(element, structuralCache) { _isInterruptible = false; }
//------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors // ------------------------------------------------------------------ // Constructor. // // element - Element associated with paragraph. // structuralCache - Content's structural cache // ------------------------------------------------------------------ protected FloaterBaseParagraph(TextElement element, StructuralCache structuralCache) : base(element, structuralCache) { }
// ------------------------------------------------------------------ // Constructor. // // element - Element associated with paragraph. // structuralCache - Content's structural cache // ----------------------------------------------------------------- internal CellParagraph(DependencyObject element, StructuralCache structuralCache) : base(element, structuralCache) { _isInterruptible = false; }
//------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors // ------------------------------------------------------------------ // Constructor. // // element - Element associated with paragraph. // structuralCache - Content's structural cache // ------------------------------------------------------------------ internal ContainerParagraph(DependencyObject element, StructuralCache structuralCache) : base(element, structuralCache) { }
//------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors //------------------------------------------------------------------- // Constructor. // // structuralCache - context representing data //------------------------------------------------------------------- internal FlowDocumentPage(StructuralCache structuralCache) : base(null) { _structuralCache = structuralCache; _ptsPage = new PtsPage(structuralCache.Section); }
//------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors /// <summary> /// Structural Cache contructor /// </summary> internal BackgroundFormatInfo(StructuralCache structuralCache) { _structuralCache = structuralCache; }
// Token: 0x06008AB4 RID: 35508 RVA: 0x002577D0 File Offset: 0x002559D0 internal DocumentFormatContext(StructuralCache owner, FlowDocumentPage page) : base(owner, page) { this._owner._documentFormatContext = this; }
// ------------------------------------------------------------------ // Height figure size calculation // ------------------------------------------------------------------ internal static double CalculateFigureHeight(StructuralCache structuralCache, Figure figure, FigureLength figureLength, out bool isHeightAuto) { double value; if (figureLength.IsPage) { value = (structuralCache.CurrentFormatContext.PageHeight) * figureLength.Value; } else if (figureLength.IsContent) // Column to be treated same as content { Thickness pageMargin = structuralCache.CurrentFormatContext.PageMargin; value = (structuralCache.CurrentFormatContext.PageHeight - pageMargin.Top - pageMargin.Bottom) * figureLength.Value; } else if (figureLength.IsColumn) { // Height is calculated based on column width, since column height is the same as content. Per spec. // Retrieve all column metrics for current page int cColumns; double columnWidth; double gap; double rule; FigureHelper.GetColumnMetrics(structuralCache, out cColumns, out columnWidth, out gap, out rule); // We do this to prevent a 2.0 columns from spanning 2.0 + gap, so we just check for edge double lengthValue = figureLength.Value; if (lengthValue > cColumns) { lengthValue = cColumns; } int columnGapsSpanned = (int)lengthValue; if (columnGapsSpanned == lengthValue && columnGapsSpanned > 0) { columnGapsSpanned -= 1; } value = (columnWidth * lengthValue) + gap * columnGapsSpanned; } else { value = FigureHelper.CalculateFigureCommon(figureLength); } if (!double.IsNaN(value)) { FigureVerticalAnchor verticalAnchor = figure.VerticalAnchor; // Value is in pixels. Now we limit value to max out depending on anchoring. if (FigureHelper.IsVerticalPageAnchor(verticalAnchor)) { value = Math.Max(1, Math.Min(value, structuralCache.CurrentFormatContext.PageHeight)); } else // Column and paragraph anchoring still max out at content height { Thickness pageMargin = structuralCache.CurrentFormatContext.PageMargin; value = Math.Max(1, Math.Min(value, structuralCache.CurrentFormatContext.PageHeight - pageMargin.Top - pageMargin.Bottom)); } TextDpi.EnsureValidPageWidth(ref value); isHeightAuto = false; } else { value = structuralCache.CurrentFormatContext.PageHeight; isHeightAuto = true; } return(value); }
/// <summary> /// Constructor /// </summary> /// <param name="element"> /// Element associated with paragraph. /// </param> /// <param name="structuralCache"> /// Content's structural cache /// </param> internal ListItemParagraph(DependencyObject element, StructuralCache structuralCache) : base(element, structuralCache) { }
/// <summary> /// Constructor /// </summary> /// <param name="owner">Associated structural cache instance</param> /// <param name="page">Document page to set</param> internal DocumentVisualValidationContext(StructuralCache owner, FlowDocumentPage page) : base(owner, page) { }
/// <summary> /// Constructor /// </summary> /// <param name="owner">Associated structural cache instance</param> /// <param name="page">Document page to set</param> internal DocumentOperationContext(StructuralCache owner, FlowDocumentPage page) { Invariant.Assert(owner != null, "Invalid owner object."); Invariant.Assert(page != null, "Invalid page object."); Invariant.Assert(owner._currentPage == null, "Page formatting reentrancy detected. Trying to create second _DocumentPageContext for the same StructuralCache."); _owner = owner; _owner._currentPage = page; _owner._illegalTreeChangeDetected = false; owner.PtsContext.Enter(); }
//-------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors // ------------------------------------------------------------------ // Constructor. // // element - Element associated with paragraph. // structuralCache - Content's structural cache // ------------------------------------------------------------------ protected FloaterBaseParagraph(TextElement element, StructuralCache structuralCache) : base(element, structuralCache) { }
//------------------------------------------------------------------- // // Constructors // //------------------------------------------------------------------- #region Constructors // ------------------------------------------------------------------ // Constructor. // // element - Element associated with paragraph. // structuralCache - Content's structural cache // ------------------------------------------------------------------ internal FigureParagraph(DependencyObject element, StructuralCache structuralCache) : base(element, structuralCache) { }
// Token: 0x06006A1B RID: 27163 RVA: 0x001CF787 File Offset: 0x001CD987 internal RowParagraph(DependencyObject element, StructuralCache structuralCache) : base(element, structuralCache) { }