internal LsErr CreateLine(
int cpFirst,
int lineLength,
int maxWidth,
LineFlags lineFlags,
IntPtr previousLineBreakRecord,
out IntPtr ploline,
out LsLInfo plslineInfo,
out int maxDepth,
out LsLineWidths lineWidths
)
{
Invariant.Assert(_ploc.Value != System.IntPtr.Zero);
return UnsafeNativeMethods.LoCreateLine(
_ploc.Value,
cpFirst,
lineLength,
maxWidth,
(uint)lineFlags, // line flags
previousLineBreakRecord,
out plslineInfo,
out ploline,
out maxDepth,
out lineWidths
);
}
private void FormatLine(
FullTextState fullText,
int cpFirst,
int lineLength,
int formatWidth,
int finiteFormatWidth,
int paragraphWidth,
LineFlags lineFlags,
FormattedTextSymbols collapsingSymbol
)
{
_metrics._formatter = fullText.Formatter;
Debug.Assert(_metrics._formatter != null);
TextStore store = fullText.TextStore;
TextStore markerStore = fullText.TextMarkerStore;
FormatSettings settings = store.Settings;
ParaProp pap = settings.Pap;
_paragraphTextDecorations = pap.TextDecorations;
if (_paragraphTextDecorations != null)
{
if (_paragraphTextDecorations.Count != 0)
{
_defaultTextDecorationsBrush = pap.DefaultTextDecorationsBrush;
}
else
{
_paragraphTextDecorations = null;
}
}
// acquiring LS context
TextFormatterContext context = _metrics._formatter.AcquireContext(fullText, IntPtr.Zero);
LsLInfo plslineInfo = new LsLInfo();
LsLineWidths lineWidths = new LsLineWidths();
fullText.SetTabs(context);
int lscpLineLength = 0; // line length in LSCP
if (lineLength > 0)
{
// line length is previously known (e.g. during optimal paragraph formatting),
// prefetch lsruns up to the specified line length.
lscpLineLength = PrefetchLSRuns(store, cpFirst, lineLength);
}
IntPtr ploline;
LsErr lserr = context.CreateLine(
cpFirst,
lscpLineLength,
formatWidth,
lineFlags,
IntPtr.Zero, // single-line formatting does not require break record
out ploline,
out plslineInfo,
out _depthQueryMax,
out lineWidths
);
// Did we exceed the LineServices maximum line width?
if (lserr == LsErr.TooLongParagraph)
{
// Determine where to insert a fake line break. FullTextState.CpMeasured
// is a reasonable estimate since we know the nominal widths up to that
// point fit within the margin.
int cpLimit = fullText.CpMeasured;
int subtract = 1;
for (;;)
{
// The line must contain at least one character position.
if (cpLimit < 1)
{
cpLimit = 1;
}
store.InsertFakeLineBreak(cpLimit);
lserr = context.CreateLine(
cpFirst,
lscpLineLength,
formatWidth,
lineFlags,
IntPtr.Zero, // single-line formatting does not require break record
out ploline,
out plslineInfo,
out _depthQueryMax,
out lineWidths
);
if (lserr != LsErr.TooLongParagraph || cpLimit == 1)
{
// We're done or can't chop off any more text.
break;
}
else
{
// Chop off more text and try again. Double the amount of
// text we chop off each time so we retry too many times.
cpLimit = fullText.CpMeasured - subtract;
subtract *= 2;
}
}
}
_ploline.Value = ploline;
// get the exception in context before it is released
Exception callbackException = context.CallbackException;
// release the context
context.Release();
if(lserr != LsErr.None)
{
GC.SuppressFinalize(this);
if(callbackException != null)
{
// rethrow exception thrown in callbacks
throw WrapException(callbackException);
}
else
{
// throw with LS error codes
TextFormatterContext.ThrowExceptionFromLsError(SR.Get(SRID.CreateLineFailure, lserr), lserr);
}
}
// keep context alive at least till here
GC.KeepAlive(context);
unsafe
{
// construct text metrics for the line
_metrics.Compute(
fullText,
cpFirst,
paragraphWidth,
collapsingSymbol,
ref lineWidths,
&plslineInfo
);
}
// keep record for min width as we may be formatting min/max
_textMinWidthAtTrailing = lineWidths.upMinStartTrailing - _metrics._textStart;
if (collapsingSymbol != null)
{
_collapsingSymbol = collapsingSymbol;
_textMinWidthAtTrailing += TextFormatterImp.RealToIdeal(collapsingSymbol.Width);
}
else
{
// overflow detection for potential collapsible line
if (_metrics._textStart + _metrics._textWidthAtTrailing > finiteFormatWidth)
{
bool hasOverflowed = true;
if (_textFormattingMode == TextFormattingMode.Display)
{
// apply display-mode rounding before checking for overflow
double realWidth = Width;
double realFormatWidth = _metrics._formatter.IdealToReal(finiteFormatWidth);
hasOverflowed = (TextFormatterImp.CompareReal(realWidth, realFormatWidth, _textFormattingMode) > 0);
}
if (hasOverflowed)
{
// line has overflowed
_statusFlags |= StatusFlags.HasOverflowed;
// let's keep the full text state around. We'll need it later for collapsing
_fullText = fullText;
}
}
}
if ( fullText != null
&& ( fullText.KeepState
|| (_statusFlags & StatusFlags.KeepState) != 0
)
)
{
// the state of full text is to be kept after formatting is done
_fullText = fullText;
}
// retain all line properties for interactive operations
_ploc = context.Ploc;
_cpFirst = cpFirst;
_paragraphWidth = paragraphWidth;
if (pap.RightToLeft)
_statusFlags |= StatusFlags.RightToLeft;
if (plslineInfo.fForcedBreak != 0)
_statusFlags |= StatusFlags.IsTruncated;
// retain the state of plsruns
_plsrunVector = store.PlsrunVector;
_lsrunsMainText = store.LsrunList;
if (markerStore != null)
_lsrunsMarkerText = markerStore.LsrunList;
// we store the text source in the line in case drawing code calls
// the TextSource to find out the text effect index.
//
_textSource = settings.TextSource;
}
private FullTextBreakpoint(
FullTextState fullText,
int firstCharIndex,
int maxLineWidth,
ref LsBreaks lsbreaks,
int breakIndex
) : this()
{
// According to antons: PTS only uses the width of a feasible break to avoid
// clipping in subpage. At the moment, there is no good solution as of how
// PTS client would be able to compute this width efficiently using LS.
// The work around - although could be conceived would simply be too slow.
// The width should therefore be set to the paragraph width for the time being.
//
// Client of text formatter would simply pass the value of TextBreakpoint.Width
// back to PTS pfnFormatLineVariants call.
LsLineWidths lineWidths = new LsLineWidths();
lineWidths.upLimLine = maxLineWidth;
lineWidths.upStartMainText = fullText.TextStore.Settings.TextIndent;
lineWidths.upStartMarker = lineWidths.upStartMainText;
lineWidths.upStartTrailing = lineWidths.upLimLine;
lineWidths.upMinStartTrailing = lineWidths.upStartTrailing;
// construct the correspondent text metrics
unsafe
{
_metrics.Compute(
fullText,
firstCharIndex,
maxLineWidth,
null, // collapsingSymbol
ref lineWidths,
&lsbreaks.plslinfoArray[breakIndex]
);
_ploline = new SecurityCriticalDataForSet<IntPtr>(lsbreaks.pplolineArray[breakIndex]);
// keep the line penalty handle
_penaltyResource = new SecurityCriticalDataForSet<IntPtr>(lsbreaks.plinepenaltyArray[breakIndex]);
if (lsbreaks.plslinfoArray[breakIndex].fForcedBreak != 0)
_isLineTruncated = true;
}
}
internal unsafe void Compute(
FullTextState fullText,
int firstCharIndex,
int paragraphWidth,
FormattedTextSymbols collapsingSymbol,
ref LsLineWidths lineWidths,
LsLInfo* plsLineInfo
)
{
_formatter = fullText.Formatter;
TextStore store = fullText.TextStore;
// obtain position of important distances
_textStart = lineWidths.upStartMainText;
_textWidthAtTrailing = lineWidths.upStartTrailing;
_textWidth = lineWidths.upLimLine;
// append line end collapsing symbol if any
if (collapsingSymbol != null)
{
AppendCollapsingSymbolWidth(TextFormatterImp.RealToIdeal(collapsingSymbol.Width));
}
// make all widths relative to text start
_textWidth -= _textStart;
_textWidthAtTrailing -= _textStart;
// keep the newline character count if any
_cchNewline = store.CchEol;
// count text and dependant characters
_lscpLim = plsLineInfo->cpLimToContinue;
_lastRun = fullText.CountText(_lscpLim, firstCharIndex, out _cchLength);
Debug.Assert(_cchLength > 0);
if ( plsLineInfo->endr != LsEndRes.endrEndPara
&& plsLineInfo->endr != LsEndRes.endrSoftCR)
{
// endrEndPara denotes that the line ends at paragraph end. It is a result of submitting Paragraph Separator to LS.
// endrSoftCR denotes end of line but not end of paragraph. This is a result of submitting Line Separator to LS.
_cchNewline = 0;
if (plsLineInfo->dcpDepend >= 0)
{
// According to SergeyGe [2/16/2006], dcpDepend reported from LS cannot made precise when considering
// the line ending with hyphenation - this is because LS does not have the knowledge about the amount
// of text, after the hyphenation point, being examined by its client during the process of finding
// the right place to hyphenate. LS client must therefore take into account the number of lookahead
// LSCP examined by hyphenator when computing the correct dcpDepend for the line. In our implementation
// it would just mean we take the max of the two values.
int lscpFirstIndependence = Math.Max(
plsLineInfo->cpLimToContinue + plsLineInfo->dcpDepend,
fullText.LscpHyphenationLookAhead
);
fullText.CountText(lscpFirstIndependence, firstCharIndex, out _cchDepend);
_cchDepend -= _cchLength;
}
}
ParaProp pap = store.Pap;
if (_height <= 0)
{
// if height has not been settled,
// calculate line height and baseline offset
if(pap.LineHeight > 0)
{
// Host specifies line height, honor it.
_height = pap.LineHeight;
_baselineOffset = (int)Math.Round(
_height
* pap.DefaultTypeface.Baseline(pap.EmSize, Constants.DefaultIdealToReal, Util.PixelsPerDip, fullText.TextFormattingMode)
/ pap.DefaultTypeface.LineSpacing(pap.EmSize, Constants.DefaultIdealToReal, Util.PixelsPerDip, fullText.TextFormattingMode)
);
}
if(plsLineInfo->dvrMultiLineHeight == int.MaxValue)
{
// Line is empty so text height and text baseline are based on the default typeface;
// it doesn't make sense even for an emtpy line to have zero text height
_textAscent = (int)Math.Round(pap.DefaultTypeface.Baseline(pap.EmSize, Constants.DefaultIdealToReal, Util.PixelsPerDip, fullText.TextFormattingMode));
_textHeight = (int)Math.Round(pap.DefaultTypeface.LineSpacing(pap.EmSize, Constants.DefaultIdealToReal, Util.PixelsPerDip, fullText.TextFormattingMode));
}
else
{
_textAscent = plsLineInfo->dvrAscent;
_textHeight = _textAscent + plsLineInfo->dvrDescent;
if (fullText.VerticalAdjust)
{
// Line requires vertical repositioning of text runs
store.AdjustRunsVerticalOffset(
plsLineInfo->cpLimToContinue - firstCharIndex,
_height,
_baselineOffset,
out _textHeight,
out _textAscent
);
}
}
// if the client hasn't specified a line height then the line height and baseline
// are the same as the text height and text baseline
if (_height <= 0)
{
_height = _textHeight;
_baselineOffset = _textAscent;
}
}
// Text alignment aligns the line to correspondent paragraph alignment start edge
switch(pap.Align)
{
case TextAlignment.Right:
// alignment rule:
// "The sum of paragraph start to line start and line width is equal to paragraph width"
//
// PTL + LW = PW
// (PTT - LTT) + (LTT + TW) = PW
// (thus) PTT = PW - TW
_paragraphToText = paragraphWidth - _textWidthAtTrailing;
break;
case TextAlignment.Center:
// alignment rule:
// "The sum of paragraph start to line start and half the line width is equal to half the paragraph width"
//
// PTL + 0.5*LW = 0.5*PW
// (PTT - LTT) + 0.5*(LTT + TW) = 0.5*PW
// (thus) PTT = 0.5 * (PW + LTT - TW)
_paragraphToText = (int)Math.Round((paragraphWidth + _textStart - _textWidthAtTrailing) * 0.5);
break;
default:
// alignment rule:
// "Paragraph start to line start is paragraph indent"
//
// PTL = PI
// PTT - LTT = PI
// (thus) PTT = PI + LTT
_paragraphToText = pap.ParagraphIndent + _textStart;
break;
}
}
internal static extern LsErr LoCreateLine(
IntPtr ploc,
int cp,
int ccpLim,
int durColumn,
uint dwLineFlags,
IntPtr pInputBreakRec,
out LsLInfo plslinfo,
out IntPtr pploline,
out int maxDepth,
out LsLineWidths lineWidths
);
