@ -4,8 +4,12 @@ using Avalonia.Utilities;
namespace Avalonia.Media.TextFormatting namespace Avalonia.Media.TextFormatting
{ {
internal sealed class TextLineImpl : TextLine internal class TextLineImpl : TextLine
{ {
internal static Comparer < TextBounds > TextBoundsComparer { get ; } =
Comparer < TextBounds > . Create ( ( x , y ) = > x . Rectangle . Left . CompareTo ( y . Rectangle . Left ) ) ;
private IReadOnlyList < IndexedTextRun > ? _ indexedTextRuns ;
private readonly TextRun [ ] _ textRuns ; private readonly TextRun [ ] _ textRuns ;
private readonly double _ paragraphWidth ; private readonly double _ paragraphWidth ;
private readonly TextParagraphProperties _ paragraphProperties ; private readonly TextParagraphProperties _ paragraphProperties ;
@ -338,184 +342,169 @@ namespace Avalonia.Media.TextFormatting
/// <inheritdoc/>
/// <inheritdoc/>
public override double GetDistanceFromCharacterHit ( CharacterHit characterHit ) public override double GetDistanceFromCharacterHit ( CharacterHit characterHit )
{ {
var flowDirection = _ paragraphProperties . FlowDirection ; if ( _ indexedTextRuns is null | | _ indexedTextRuns . Count = = 0 )
var characterIndex = characterHit . FirstCharacterIndex + characterHit . TrailingLength ;
var currentPosition = FirstTextSourceIndex ;
var remainingLength = characterIndex - FirstTextSourceIndex ;
var currentDistance = Start ;
if ( flowDirection = = FlowDirection . LeftToRight )
{ {
for ( var index = 0 ; index < _ textRuns . Length ; index + + ) return Start ;
{ }
var currentRun = _ textRuns [ index ] ;
if ( currentRun is ShapedTextRun shapedRun & & ! shapedRun . ShapedBuffer . IsLeftToRight )
{
var i = index ;
var rightToLeftWidth = shapedRun . Size . Width ;
while ( i + 1 < = _ textRuns . Length - 1 )
{
var nextRun = _ textRuns [ i + 1 ] ;
if ( nextRun is ShapedTextRun nextShapedRun & & ! nextShapedRun . ShapedBuffer . IsLeftToRight )
{
i + + ;
rightToLeftWidth + = nextShapedRun . Size . Width ; var characterIndex = Math . Min (
characterHit . FirstCharacterIndex + characterHit . TrailingLength ,
FirstTextSourceIndex + Length ) ;
continue ; var currentPosition = FirstTextSourceIndex ;
}
break ; static FlowDirection GetDirection ( TextRun textRun , FlowDirection currentDirection )
} {
if ( textRun is ShapedTextRun shapedTextRun )
{
return shapedTextRun . ShapedBuffer . IsLeftToRight ?
FlowDirection . LeftToRight :
FlowDirection . RightToLeft ;
}
if ( i > index ) return currentDirection ;
{ }
while ( i > = index )
{
currentRun = _ textRuns [ i ] ;
if ( currentRun is DrawableTextRun drawable ) IndexedTextRun FindIndexedRun ( )
{ {
rightToLeftWidth - = drawable . Size . Width ; var i = 0 ;
}
if ( currentPosition + currentRun . Length > = characterIndex ) IndexedTextRun currentIndexedRun = _ indexedTextRuns [ i ] ;
{
break ;
}
currentPosition + = currentRun . Length ; while ( currentIndexedRun . TextSourceCharacterIndex ! = currentPosition )
{
if ( i + 1 < _ indexedTextRuns . Count )
{
i + + ;
remainingLength - = currentRun . Length ; currentIndexedRun = _ indexedTextRuns [ i ] ;
}
}
i - - ; return currentIndexedRun ;
} }
currentDistance + = rightToLeftWidth ; double GetPreceedingDistance ( int firstIndex )
} {
} var distance = 0.0 ;
if ( currentPosition + currentRun . Length > = characterIndex & & for ( var i = 0 ; i < firstIndex ; i + + )
TryGetDistanceFromCharacterHit ( currentRun , characterHit , currentPosition , remainingLength , flowDirection , out var distance , out _ ) ) {
{ var currentRun = _ textRuns [ i ] ;
return Math . Max ( 0 , currentDistance + distance ) ;
}
if ( currentRun is DrawableTextRun drawableTextRun ) if ( currentRun is DrawableTextRun drawableTextRun )
{ {
currentD istance+ = drawableTextRun . Size . Width ; d istance+ = drawableTextRun . Size . Width ;
} }
//No hit hit found so we add the full width
currentPosition + = currentRun . Length ;
remainingLength - = currentRun . Length ;
} }
return distance ;
} }
else
TextRun ? currentTextRun = null ;
var currentIndexedRun = FindIndexedRun ( ) ;
while ( currentPosition < FirstTextSourceIndex + Length )
{ {
currentDistance + = WidthIncludingTrailingWhitespace ; currentTextRun = currentIndexedRun . TextRun ;
for ( var index = _ textRuns . Length - 1 ; index > = 0 ; index - - ) if ( currentTextRun = = null )
{ {
var currentRun = _ textRuns [ index ] ; break ;
}
if ( TryGetDistanceFromCharacterHit ( currentRun , characterHit , currentPosition , remainingLength , if ( currentIndexedRun . TextSourceCharacterIndex + currentTextRun . Length < = characterHit . FirstCharacterIndex )
flowDirection , out var distance , out var currentGlyphRun ) ) {
if ( currentPosition + currentTextRun . Length < FirstTextSourceIndex + Length )
{ {
if ( currentGlyphRun ! = null ) currentPosition + = currentTextRun . Length ;
{
currentDistance - = currentGlyphRun . Bounds . Width ;
}
return currentDistance + distance ; currentIndexedRun = FindIndexedRun ( ) ;
}
if ( currentRun is DrawableTextRun drawableTextRun ) continue ;
{
currentDistance - = drawableTextRun . Size . Width ;
} }
//No hit hit found so we add the full width
currentPosition + = currentRun . Length ;
remainingLength - = currentRun . Length ;
} }
break ;
} }
return Math . Max ( 0 , currentDistance ) ; if ( currentTextRun = = null )
} {
return 0 ;
}
private static bool TryGetDistanceFromCharacterHit ( var directionalWidth = 0.0 ;
TextRun currentRun , var firstRunIndex = currentIndexedRun . RunIndex ;
CharacterHit characterHit , var lastRunIndex = firstRunIndex ;
int currentPosition ,
int remainingLength ,
FlowDirection flowDirection ,
out double distance ,
out GlyphRun ? currentGlyphRun )
{
var characterIndex = characterHit . FirstCharacterIndex + characterHit . TrailingLength ;
var isTrailingHit = characterHit . TrailingLength > 0 ;
distance = 0 ; var currentDirection = GetDirection ( currentTextRun , _ resolvedFlowDirection ) ;
currentGlyphRun = null ;
switch ( currentRun ) var currentX = Start + GetPreceedingDistance ( currentIndexedRun . RunIndex ) ;
if ( currentTextRun is DrawableTextRun currentDrawable )
{ {
case ShapedTextRun shapedTextCharacters : directionalWidth = currentDrawable . Size . Width ;
{ }
currentGlyphRun = shapedTextCharacters . GlyphRun ;
if ( currentPosition + remainingLength < = currentPosition + currentRun . Length ) if ( currentTextRun is not TextEndOfLine )
{ {
characterHit = new CharacterHit ( currentPosition + remainingLength ) ; if ( currentDirection = = FlowDirection . LeftToRight )
{
// Find consecutive runs of same direction
for ( ; lastRunIndex + 1 < _ textRuns . Length ; lastRunIndex + + )
{
var nextRun = _ textRuns [ lastRunIndex + 1 ] ;
distance = currentGlyphRun . GetDistanceFromCharacterHit ( characterHit ) ; var nextDirection = GetDirection ( nextRun , currentDirection ) ;
return true ; if ( currentDirection ! = nextDirection )
{
break ;
} }
if ( currentPosition + remainingLength = = currentPosition + currentRun . Length & & isTrailingHit ) if ( nextRun is DrawableTextRun nextDrawable )
{ {
if ( currentGlyphRun . IsLeftToRight | | flowDirection = = FlowDirection . RightToLeft ) directionalWidth + = nextDrawable . Size . Width ;
{
distance = currentGlyphRun . Bounds . Width ;
}
return true ;
} }
break ;
} }
case DrawableTextRun drawableTextRun : }
else
{
// Find consecutive runs of same direction
for ( ; firstRunIndex - 1 > 0 ; firstRunIndex - - )
{ {
if ( characterIndex = = currentPosition ) var previousRun = _ textRuns [ firstRunIndex - 1 ] ;
var previousDirection = GetDirection ( previousRun , currentDirection ) ;
if ( currentDirection ! = previousDirection )
{ {
return true ; b reak ;
} }
if ( characterIndex = = currentPosition + currentRun . Length ) if ( previousRun is DrawableTextRun previousDrawable )
{ {
distance = drawableTextRun . Size . Width ; directionalWidth + = previousDrawable . Size . Width ;
return true ;
currentX - = previousDrawable . Size . Width ;
} }
}
}
}
break ; switch ( currentDirection )
{
case FlowDirection . RightToLeft :
{
return GetTextRunBoundsRightToLeft ( firstRunIndex , lastRunIndex , currentX + directionalWidth , characterIndex ,
currentPosition , 1 , out _ , out _ ) . Rectangle . Right ;
} }
default : default :
{ {
return false ; return GetTextBoundsLeftToRight ( firstRunIndex , lastRunIndex , currentX , characterIndex ,
currentPosition , 1 , out _ , out _ ) . Rectangle . Left ;
} }
} }
return false ;
} }
/// <inheritdoc/>
/// <inheritdoc/>
@ -585,7 +574,7 @@ namespace Avalonia.Media.TextFormatting
public override IReadOnlyList < TextBounds > GetTextBounds ( int firstTextSourceIndex , int textLength ) public override IReadOnlyList < TextBounds > GetTextBounds ( int firstTextSourceIndex , int textLength )
{ {
if ( _ textRuns . Length = = 0 ) if ( _ indexedTex tRuns is null | | _ indexedT extRuns. Count = = 0 )
{ {
return Array . Empty < TextBounds > ( ) ; return Array . Empty < TextBounds > ( ) ;
} }
@ -607,303 +596,154 @@ namespace Avalonia.Media.TextFormatting
return currentDirection ; return currentDirection ;
} }
if ( _ paragraphProperties . FlowDirection = = FlowDirection . LeftToRight ) IndexedTextRun FindIndexedRun ( )
{ {
var currentX = Start ; var i = 0 ;
for ( int i = 0 ; i < _ textRuns . Length ; i + + ) IndexedTextRun currentIndexedRun = _ indexedTextRuns [ i ] ;
{
var currentRun = _ textRuns [ i ] ;
var firstRunIndex = i ; while ( currentIndexedRun . TextSourceCharacterIndex ! = currentPosition )
var lastRunIndex = firstRunIndex ; {
var currentDirection = GetDirection ( currentRun , FlowDirection . LeftToRight ) ; if ( i + 1 < _ indexedTextRuns . Count )
var directionalWidth = 0.0 ;
if ( currentRun is DrawableTextRun currentDrawable )
{ {
directionalWidth = currentDrawable . Size . Width ; i + + ;
}
// Find consecutive runs of same direction
currentIndexedRun = _ indexedTextRuns [ i ] ;
for ( ; lastRunIndex + 1 < _ textRuns . Length ; lastRunIndex + + ) }
{ }
var nextRun = _ textRuns [ lastRunIndex + 1 ] ;
var nextDirection = GetDirection ( nextRun , currentDirection ) ; return currentIndexedRun ;
}
if ( currentDirection ! = nextDirection ) double GetPreceedingDistance ( int firstIndex )
{ {
break ; var distance = 0.0 ;
}
if ( nextRun is DrawableTextRun nextDrawable ) for ( var i = 0 ; i < firstIndex ; i + + )
{ {
directionalWidth + = nextDrawable . Size . Width ; var currentRun = _ textRuns [ i ] ;
}
}
//Skip runs that are not part of the hit test range
if ( currentRun is DrawableTextRun drawableTextRun )
switch ( currentDirection )
{ {
case FlowDirection . RightToLeft : distance + = drawableTextRun . Size . Width ;
{ }
for ( ; lastRunIndex > = firstRunIndex ; lastRunIndex - - ) }
{
currentRun = _ textRuns [ lastRunIndex ] ;
if ( currentPosition + currentRun . Length > firstTextSourceIndex ) return distance ;
{ }
break ;
}
currentPosition + = currentRun . Length ; while ( remainingLength > 0 & & currentPosition < FirstTextSourceIndex + Length )
{
var currentIndexedRun = FindIndexedRun ( ) ;
if ( currentRun is DrawableTextRun drawableTextRun ) if ( currentIndexedRun = = null )
{ {
directionalWidth - = drawableTextRun . Size . Width ; break ;
currentX + = drawableTextRun . Size . Width ; }
}
if ( lastRunIndex - 1 < 0 ) var directionalWidth = 0.0 ;
{ var firstRunIndex = currentIndexedRun . RunIndex ;
break ; var lastRunIndex = firstRunIndex ;
} var currentTextRun = currentIndexedRun . TextRun ;
}
break ; if ( currentTextRun = = null )
} {
default : break ;
{ }
for ( ; firstRunIndex < = lastRunIndex ; firstRunIndex + + )
{
currentRun = _ textRuns [ firstRunIndex ] ;
if ( currentPosition + currentRun . Length > firstTextSourceIndex )
{
break ;
}
currentPosition + = currentRun . Length ; var currentDirection = GetDirection ( currentTextRun , _ resolvedFlowDirection ) ;
if ( currentRun is DrawableTextRun drawableTextRun ) if ( currentIndexedRun . TextSourceCharacterIndex + currentTextRun . Length < = firstTextSourceIndex )
{ {
currentX + = drawableTextRun . Size . Width ; currentPosition + = currentTextRun . Length ;
directionalWidth - = drawableTextRun . Size . Width ;
}
if ( firstRunIndex + 1 = = _ textRuns . Length ) continue ;
{ }
break ;
}
}
break ; var currentX = Start + GetPreceedingDistance ( currentIndexedRun . RunIndex ) ;
}
}
i = lastRunIndex ; if ( currentTextRun is DrawableTextRun currentDrawable )
{
directionalWidth = currentDrawable . Size . Width ;
}
//Possible overlap at runs of different direction
if ( currentTextRun is not TextEndOfLine )
if ( directionalWidth = = 0 & & i < _ textRuns . Length - 1 ) {
if ( currentDirection = = FlowDirection . LeftToRight )
{ {
//In case a run only contains a linebreak we don't want to skip it.
// Find consecutive runs of same direction
if ( currentRun is ShapedTextRun shaped ) for ( ; lastRunIndex + 1 < _ textRuns . Length ; lastRunIndex + + )
{
if ( currentRun . Length - shaped . GlyphRun . Metrics . NewLineLength > 0 )
{
continue ;
}
}
else
{ {
continue ; var nextRun = _ textRuns [ lastRunIndex + 1 ] ;
}
}
int coveredLength ; var nextDirection = GetDirection ( nextRun , currentDirection ) ;
TextBounds ? textBounds ;
switch ( currentDirection ) if ( currentDirection ! = nextDirection )
{
case FlowDirection . RightToLeft :
{ {
textBounds = GetTextRunBoundsRightToLeft ( firstRunIndex , lastRunIndex , currentX + directionalWidth , firstTextSourceIndex ,
currentPosition , remainingLength , out coveredLength , out currentPosition ) ;
currentX + = directionalWidth ;
break ; break ;
} }
default :
{
textBounds = GetTextBoundsLeftToRight ( firstRunIndex , lastRunIndex , currentX , firstTextSourceIndex ,
currentPosition , remainingLength , out coveredLength , out currentPosition ) ;
currentX = textBounds . Rectangle . Right ; if ( nextRun is DrawableTextRun nextDrawable )
{
break ; directionalWidth + = nextDrawable . Size . Width ;
} }
}
} }
else
if ( coveredLength > 0 )
{
result . Add ( textBounds ) ;
remainingLength - = coveredLength ;
}
if ( remainingLength < = 0 )
{
break ;
}
}
}
else
{
var currentX = Start + WidthIncludingTrailingWhitespace ;
for ( int i = _ textRuns . Length - 1 ; i > = 0 ; i - - )
{
var currentRun = _ textRuns [ i ] ;
var firstRunIndex = i ;
var lastRunIndex = firstRunIndex ;
var currentDirection = GetDirection ( currentRun , FlowDirection . RightToLeft ) ;
var directionalWidth = 0.0 ;
if ( currentRun is DrawableTextRun currentDrawable )
{
directionalWidth = currentDrawable . Size . Width ;
}
// Find consecutive runs of same direction
for ( ; firstRunIndex - 1 > 0 ; firstRunIndex - - )
{ {
var previousRun = _ textRuns [ firstRunIndex - 1 ] ; // Find consecutive runs of same direction
for ( ; firstRunIndex - 1 > 0 ; firstRunIndex - - )
var previousDirection = GetDirection ( previousRun , currentDirection ) ;
if ( currentDirection ! = previousDirection )
{ {
break ; var previousRun = _ textRuns [ firstRunIndex - 1 ] ;
}
if ( currentRun is DrawableTextRun previousDrawable ) var previousDirection = GetDirection ( previousRun , currentDirection ) ;
{
directionalWidth + = previousDrawable . Size . Width ;
}
}
//Skip runs that are not part of the hit test range
if ( currentDirection ! = previousDirection )
switch ( currentDirection )
{
case FlowDirection . RightToLeft :
{ {
for ( ; lastRunIndex > = firstRunIndex ; lastRunIndex - - )
{
currentRun = _ textRuns [ lastRunIndex ] ;
if ( currentPosition + currentRun . Length < = firstTextSourceIndex )
{
currentPosition + = currentRun . Length ;
if ( currentRun is DrawableTextRun drawableTextRun )
{
currentX - = drawableTextRun . Size . Width ;
directionalWidth - = drawableTextRun . Size . Width ;
}
continue ;
}
break ;
}
break ; break ;
} }
default :
{
for ( ; firstRunIndex < = lastRunIndex ; firstRunIndex + + )
{
currentRun = _ textRuns [ firstRunIndex ] ;
if ( currentPosition + currentRun . Length < = firstTextSourceIndex )
{
currentPosition + = currentRun . Length ;
if ( currentRun is DrawableTextRun drawableTextRun )
{
currentX + = drawableTextRun . Size . Width ;
directionalWidth - = drawableTextRun . Size . Width ;
}
continue ; if ( previousRun is DrawableTextRun previousDrawable )
} {
directionalWidth + = previousDrawable . Size . Width ;
break ;
}
break ; currentX - = previousDrawable . Size . Width ;
} }
}
} }
}
i = firstRunIndex ; int coveredLength ;
TextBounds ? textBounds ;
//Possible overlap at runs of different direction
switch ( currentDirection )
if ( directionalWidth = = 0 & & i > 0 ) {
{ case FlowDirection . RightToLeft :
//In case a run only contains a linebreak we don't want to skip it.
if ( currentRun is ShapedTextRun shaped )
{ {
if ( currentRun . Length - shaped . GlyphRun . Metrics . NewLineLength > 0 ) textBounds = GetTextRunBoundsRightToLeft ( firstRunIndex , lastRunIndex , currentX + directionalWidth , firstTextSourceIndex ,
{ currentPosition , remainingLength , out coveredLength , out currentPosition ) ;
continue ;
} break ;
} }
else default :
{ {
continue ; textBounds = GetTextBoundsLeftToRight ( firstRunIndex , lastRunIndex , currentX , firstTextSourceIndex ,
} currentPosition , remainingLength , out coveredLength , out currentPosition ) ;
}
int coveredLength ;
TextBounds ? textBounds ;
switch ( currentDirection )
{
case FlowDirection . LeftToRight :
{
textBounds = GetTextBoundsLeftToRight ( firstRunIndex , lastRunIndex , currentX - directionalWidth , firstTextSourceIndex ,
currentPosition , remainingLength , out coveredLength , out currentPosition ) ;
currentX - = directionalWidth ;
break ;
}
default :
{
textBounds = GetTextRunBoundsRightToLeft ( firstRunIndex , lastRunIndex , currentX , firstTextSourceIndex ,
currentPosition , remainingLength , out coveredLength , out currentPosition ) ;
currentX = textBounds . Rectangle . Left ;
break ; break ;
} }
} }
//Visual order is always left to right so we need to insert
if ( coveredLength > 0 )
result . Insert ( 0 , textBounds ) ; {
result . Add ( textBounds ) ;
remainingLength - = coveredLength ; remainingLength - = coveredLength ;
if ( remainingLength < = 0 )
{
break ;
}
} }
} }
result . Sort ( TextBoundsComparer ) ;
return result ; return result ;
} }
@ -1164,7 +1004,7 @@ namespace Avalonia.Media.TextFormatting
_ textLineBreak = new TextLineBreak ( textEndOfLine ) ; _ textLineBreak = new TextLineBreak ( textEndOfLine ) ;
} }
BidiReorderer . Instance . BidiReorder ( _ textRuns , _ resolvedFlowDirection ) ; _ indexedTextRuns = BidiReorderer . Instance . BidiReorder ( _ textRuns , _ paragraphProperties . FlowDirection , FirstTextSourceIndex ) ;
} }
/// <summary>
/// <summary>
@ -1211,13 +1051,6 @@ namespace Avalonia.Media.TextFormatting
return true ; return true ;
} }
//var characterIndex = codepointIndex - shapedRun.Text.Start;
//if (characterIndex < 0 && shapedRun.ShapedBuffer.IsLeftToRight)
//{
// foundCharacterHit = new CharacterHit(foundCharacterHit.FirstCharacterIndex);
//}
nextCharacterHit = isAtEnd | | characterHit . TrailingLength ! = 0 ? nextCharacterHit = isAtEnd | | characterHit . TrailingLength ! = 0 ?
foundCharacterHit : foundCharacterHit :
new CharacterHit ( foundCharacterHit . FirstCharacterIndex + foundCharacterHit . TrailingLength ) ; new CharacterHit ( foundCharacterHit . FirstCharacterIndex + foundCharacterHit . TrailingLength ) ;
@ -1556,8 +1389,8 @@ namespace Avalonia.Media.TextFormatting
TrailingWhitespaceLength = trailingWhitespaceLength , TrailingWhitespaceLength = trailingWhitespaceLength ,
Width = width , Width = width ,
WidthIncludingTrailingWhitespace = widthIncludingWhitespace , WidthIncludingTrailingWhitespace = widthIncludingWhitespace ,
OverhangLeading = overhangLeading , OverhangLeading = overhangLeading ,
OverhangTrailing = overhangTrailing , OverhangTrailing = overhangTrailing ,
OverhangAfter = overhangAfter OverhangAfter = overhangAfter
} ; } ;
} }
@ -1615,8 +1448,7 @@ namespace Avalonia.Media.TextFormatting
return Math . Max ( 0 , start ) ; return Math . Max ( 0 , start ) ;
case TextAlignment . Right : case TextAlignment . Right :
return Math . Max ( 0 , _ paragraphWidth - width ) ; return Math . Max ( 0 , _ paragraphWidth - widthIncludingTrailingWhitespace ) ;
default : default :
return 0 ; return 0 ;
} }
Dan Walmsley
3 years ago
GitHub