コード例 #1
0
        public override bool Equals(object o)
        {
            ScaledShapeTypeface t = o as ScaledShapeTypeface;

            if (t == null)
            {
                return(false);
            }

            return
                (_shapeTypeface.Equals(t._shapeTypeface) &&
                 _scaleInEm == t._scaleInEm &&
                 _nullShape == t._nullShape);
        }
コード例 #2
0
        /// <summary>
        /// Search and find index to the list of scaled shapeable typefaces.
        /// Unfound search creates a new entry in the list.
        /// </summary>
        private int IndexOfScaledTypeface(ScaledShapeTypeface scaledTypeface)
        {
            int i;

            for (i = 0; i < _cachedScaledTypefaces.Count; i++)
            {
                if (scaledTypeface.Equals(_cachedScaledTypefaces[i]))
                {
                    break;
                }
            }

            if (i == _cachedScaledTypefaces.Count)
            {
                // encountering this face for the first time, add it to the list
                i = _cachedScaledTypefaces.Count;
                _cachedScaledTypefaces.Add(scaledTypeface);
            }

            return(i);
        }
コード例 #3
0
ファイル: TypefaceMap.cs プロジェクト: sjyanxin/WPFSource
        /// <summary>
        /// Search and find index to the list of scaled shapeable typefaces.
        /// Unfound search creates a new entry in the list. 
        /// </summary>
        private int IndexOfScaledTypeface(ScaledShapeTypeface scaledTypeface) 
        { 
            int i;
            for(i = 0; i < _cachedScaledTypefaces.Count; i++) 
            {
                if(scaledTypeface.Equals(_cachedScaledTypefaces[i]))
                    break;
            } 

            if(i == _cachedScaledTypefaces.Count) 
            { 
                // encountering this face for the first time, add it to the list
                i = _cachedScaledTypefaces.Count; 
                _cachedScaledTypefaces.Add(scaledTypeface);
            }

            return i; 
        }
コード例 #4
0
        internal void GetShapeableText(
            CharacterBufferReference characterBufferReference,
            int stringLength,
            TextRunProperties textRunProperties,
            CultureInfo digitCulture,
            bool isRightToLeftParagraph,
            IList <TextShapeableSymbols> shapeableList,
            IShapeableTextCollector collector,
            TextFormattingMode textFormattingMode
            )
        {
            SpanVector <int> cachedScaledTypefaceIndexSpans;

            int ichItem = 0;

            CharacterBufferRange unicodeString = new CharacterBufferRange(
                characterBufferReference,
                stringLength
                );

            CultureInfo  culture = textRunProperties.CultureInfo;
            IList <Span> spans;

            GCHandle gcHandle;
            IntPtr   ptext = characterBufferReference.CharacterBuffer.PinAndGetCharacterPointer(characterBufferReference.OffsetToFirstChar, out gcHandle);

            // Contextual number substitution cannot be performed on the run level, since it depends
            // on context - nearest preceding strong character. For this reason, contextual number
            // substitutions has been already done (TextStore.CreateLSRunsUniformBidiLevel) and
            // digitCulture has been updated to reflect culture which is dependent on the context.
            // NumberSubstitutionMethod.AsCulture method can be resolved to Context, hence it also needs to be resolved to appropriate
            // not ambiguous method.
            // Both of those values (Context and AsCulture) are resolved to one of following: European, Traditional or NativeNational,
            // which can be safely handled by DWrite without getting context information.
            bool ignoreUserOverride;
            NumberSubstitutionMethod numberSubstitutionMethod = DigitState.GetResolvedSubstitutionMethod(textRunProperties, digitCulture, out ignoreUserOverride);

            // Itemize the text based on DWrite's text analysis for scripts and number substitution.
            unsafe
            {
                checked
                {
                    spans = MS.Internal.Text.TextInterface.TextAnalyzer.Itemize(
                        (ushort *)ptext.ToPointer(),
                        (uint)stringLength,
                        culture,
                        MS.Internal.FontCache.DWriteFactory.Instance,
                        isRightToLeftParagraph,
                        digitCulture,
                        ignoreUserOverride,
                        (uint)numberSubstitutionMethod,
                        ClassificationUtility.Instance,
                        UnsafeNativeMethods.CreateTextAnalysisSink,
                        UnsafeNativeMethods.GetScriptAnalysisList,
                        UnsafeNativeMethods.GetNumberSubstitutionList,
                        UnsafeNativeMethods.CreateTextAnalysisSource
                        );
                }
            }
            characterBufferReference.CharacterBuffer.UnpinCharacterPointer(gcHandle);

            SpanVector itemSpans = new SpanVector(null, new FrugalStructList <Span>((ICollection <Span>)spans));

            cachedScaledTypefaceIndexSpans = new SpanVector <int>(-1);
            foreach (Span itemSpan in itemSpans)
            {
                MapItem(
                    new CharacterBufferRange(
                        unicodeString,
                        ichItem,
                        itemSpan.length
                        ),
                    culture,
                    itemSpan,
                    ref cachedScaledTypefaceIndexSpans,
                    ichItem
                    );

                #if DEBUG
                ValidateMapResult(
                    ichItem,
                    itemSpan.length,
                    ref cachedScaledTypefaceIndexSpans
                    );
                #endif

                ichItem += itemSpan.length;
            }


            Debug.Assert(ichItem == unicodeString.Length);

            // intersect item spans with shapeable spans to create span of shapeable runs

            int ich = 0;

            SpanRider       itemSpanRider          = new SpanRider(itemSpans);
            SpanRider <int> typefaceIndexSpanRider = new SpanRider <int>(cachedScaledTypefaceIndexSpans);

            while (ich < unicodeString.Length)
            {
                itemSpanRider.At(ich);
                typefaceIndexSpanRider.At(ich);

                int index = typefaceIndexSpanRider.CurrentValue;
                Debug.Assert(index >= 0);

                int cch = unicodeString.Length - ich;
                cch = Math.Min(cch, itemSpanRider.Length);
                cch = Math.Min(cch, typefaceIndexSpanRider.Length);

                ScaledShapeTypeface scaledShapeTypeface = _cachedScaledTypefaces[index];

                collector.Add(
                    shapeableList,
                    new CharacterBufferRange(
                        unicodeString,
                        ich,
                        cch
                        ),
                    textRunProperties,
                    (MS.Internal.Text.TextInterface.ItemProps)itemSpanRider.CurrentElement,
                    scaledShapeTypeface.ShapeTypeface,
                    scaledShapeTypeface.ScaleInEm,
                    scaledShapeTypeface.NullShape,
                    textFormattingMode
                    );

                ich += cch;
            }
        }