sbox-public/engine/ThirdParty/Topten.RichTextKit/BidiAlgorithm/BidiData.cs

// RichTextKit
// Copyright © 2019-2020 Topten Software. All Rights Reserved.
// 
// Licensed under the Apache License, Version 2.0 (the "License"); you may 
// not use this product except in compliance with the License. You may obtain 
// a copy of the License at
// 
// http://www.apache.org/licenses/LICENSE-2.0
// 
// Unless required by applicable law or agreed to in writing, software 
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 
// License for the specific language governing permissions and limitations 
// under the License.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Topten.RichTextKit.Utils;

namespace Topten.RichTextKit
{
	/// <summary>
	/// Represents a unicode string and all associated attributes
	/// for each character required for the Bidi algorithm
	/// </summary>
	class BidiData
	{
		/// <summary>
		/// Construct a new empty BidiData
		/// </summary>
		public BidiData()
		{
			_types = new Buffer<Directionality>();
			_pairedBracketTypes = new Buffer<PairedBracketType>();
			_pairedBracketValues = new Buffer<int>();
		}

		List<int> _paragraphPositions = new List<int>();

		sbyte _paragraphEmbeddingLevel;
		public sbyte ParagraphEmbeddingLevel => _paragraphEmbeddingLevel;

		bool _hasBrackets;
		public bool HasBrackets => _hasBrackets;

		bool _hasEmbeddings;
		public bool HasEmbeddings => _hasEmbeddings;

		bool _hasIsolates;
		public bool HasIsolates => _hasIsolates;

		/// <summary>
		/// Initialize with an array of Unicode code points
		/// </summary>
		/// <param name="codePoints">The unicode code points to be processed</param>
		/// <param name="paragraphEmbeddingLevel">The paragraph embedding level</param>
		public void Init( Slice<int> codePoints, sbyte paragraphEmbeddingLevel )
		{
			// Set working buffer sizes
			_types.Length = codePoints.Length;
			_pairedBracketTypes.Length = codePoints.Length;
			_pairedBracketValues.Length = codePoints.Length;

			_paragraphPositions.Clear();
			_paragraphEmbeddingLevel = paragraphEmbeddingLevel;

			// Resolve the directionality, paired bracket type and paired bracket values for
			// all code points
			_hasBrackets = false;
			_hasEmbeddings = false;
			_hasIsolates = false;
			for ( int i = 0; i < codePoints.Length; i++ )
			{
				var bidiData = UnicodeClasses.BidiData( codePoints[i] );

				// Look up directionality
				var dir = (Directionality)(bidiData >> 24);
				_types[i] = dir;

				switch ( dir )
				{
					case Directionality.LRE:
					case Directionality.LRO:
					case Directionality.RLE:
					case Directionality.RLO:
					case Directionality.PDF:
						_hasEmbeddings = true;
						break;

					case Directionality.LRI:
					case Directionality.RLI:
					case Directionality.FSI:
					case Directionality.PDI:
						_hasIsolates = true;
						break;
				}

				// Lookup paired bracket types
				var pbt = (PairedBracketType)((bidiData >> 16) & 0xFF);
				_pairedBracketTypes[i] = pbt;
				switch ( pbt )
				{
					case PairedBracketType.o:
						_pairedBracketValues[i] = MapCanon( (int)(bidiData & 0xFFFF) );
						_hasBrackets = true;
						break;

					case PairedBracketType.c:
						_pairedBracketValues[i] = MapCanon( codePoints[i] );
						_hasBrackets = true;
						break;
				}

				/*
                if (_types[i] == RichTextKit.Directionality.B)
                {
                    _types[i] = (Directionality)Directionality.WS;
                    _paragraphPositions.Add(i);
                }
                */
			}

			// Create slices on work buffers
			Types = _types.AsSlice();
			PairedBracketTypes = _pairedBracketTypes.AsSlice();
			PairedBracketValues = _pairedBracketValues.AsSlice();
		}

		/// <summary>
		/// Map bracket types 0x3008 and 0x3009 to their canonical equivalents
		/// </summary>
		/// <param name="codePoint">The code point to be mapped</param>
		/// <returns>The mapped canonical code point, or the passed code point</returns>
		static int MapCanon( int codePoint )
		{
			if ( codePoint == 0x3008 )
				return 0x2329;
			if ( codePoint == 0x3009 )
				return 0x232A;
			else
				return codePoint;
		}

		/// <summary>
		/// Get the length of the data held by the BidiData
		/// </summary>
		public int Length => _types.Length;

		Buffer<Directionality> _types;
		Buffer<PairedBracketType> _pairedBracketTypes;
		Buffer<int> _pairedBracketValues;
		Buffer<Directionality> _savedTypes;
		Buffer<PairedBracketType> _savedPairedBracketTypes;

		/// <summary>
		/// Save the Types and PairedBracketTypes of this bididata 
		/// </summary>
		/// <remarks>
		/// This is used when processing embedded style runs with 
		/// directionality overrides.  TextBlock saves the data,
		/// overrides the style runs to neutral, processes the bidi
		/// data for the entire paragraph and then restores this data
		/// before processing the embedded runs.
		/// </remarks>
		public void SaveTypes()
		{
			// Make sure we have a buffer
			if ( _savedTypes == null )
			{
				_savedTypes = new Buffer<Directionality>();
				_savedPairedBracketTypes = new Buffer<PairedBracketType>();
			}

			// Capture the types data
			_savedTypes.Clear();
			_savedTypes.Add( _types.AsSlice() );
			_savedPairedBracketTypes.Clear();
			_savedPairedBracketTypes.Add( _pairedBracketTypes.AsSlice() );
		}

		/// <summary>
		/// Restore the data saved by SaveTypes
		/// </summary>
		public void RestoreTypes()
		{
			_types.Clear();
			_types.Add( _savedTypes.AsSlice() );
			_pairedBracketTypes.Clear();
			_pairedBracketTypes.Add( _savedPairedBracketTypes.AsSlice() );
		}

		/// <summary>
		/// The directionality of each code point
		/// </summary>
		public Slice<Directionality> Types;

		/// <summary>
		/// The paired bracket type for each code point
		/// </summary>
		public Slice<PairedBracketType> PairedBracketTypes;

		/// <summary>
		/// The paired bracket value for code code point
		/// </summary>
		/// <remarks>
		/// The paired bracket values are the code points
		/// of each character where the opening code point
		/// is replaced with the closing code point for easier
		/// matching.  Also, bracket code points are mapped
		/// to their canonical equivalents
		/// </remarks>
		public Slice<int> PairedBracketValues;

		public Buffer<sbyte> _tempLevelBuffer;

		/// <summary>
		/// Gets a temporary level buffer.  Used by TextBlock when
		/// resolving style runs with different directionality.
		/// </summary>
		/// <param name="length">Length of the required buffer</param>
		/// <returns>An uninitialized level buffer</returns>
		public Slice<sbyte> GetTempLevelBuffer( int length )
		{
			if ( _tempLevelBuffer == null )
				_tempLevelBuffer = new Buffer<sbyte>();

			_tempLevelBuffer.Clear();
			return _tempLevelBuffer.Add( length, false );
		}
	}
}