// Token: 0x0600688D RID: 26765 RVA: 0x001D7D74 File Offset: 0x001D5F74
        protected TextRun HandleText(StaticTextPointer position)
        {
            Invariant.Assert(position.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text, "TextPointer does not point to characters.");
            DependencyObject target;

            if (position.Parent != null)
            {
                target = position.Parent;
            }
            else
            {
                target = this._paraClient.Paragraph.Element;
            }
            TextProperties    textRunProperties = new TextProperties(target, position, false, true, this._paraClient.Paragraph.StructuralCache.TextFormatterHost.PixelsPerDip);
            StaticTextPointer position2         = position.TextContainer.Highlights.GetNextPropertyChangePosition(position, LogicalDirection.Forward);

            if (position.GetOffsetToPosition(position2) > 4096)
            {
                position2 = position.CreatePointer(4096);
            }
            char[] array     = new char[position.GetOffsetToPosition(position2)];
            int    textInRun = position.GetTextInRun(LogicalDirection.Forward, array, 0, array.Length);

            return(new TextCharacters(array, 0, textInRun, textRunProperties));
        }
        // Token: 0x06004143 RID: 16707 RVA: 0x0012A510 File Offset: 0x00128710
        private TextRun HandleText(StaticTextPointer position)
        {
            StaticTextPointer position2 = this._owner.Host.TextContainer.Highlights.GetNextPropertyChangePosition(position, LogicalDirection.Forward);

            if (position.GetOffsetToPosition(position2) > 4096)
            {
                position2 = position.CreatePointer(4096);
            }
            Highlights highlights = position.TextContainer.Highlights;
            TextDecorationCollection textDecorationCollection = highlights.GetHighlightValue(position, LogicalDirection.Forward, typeof(SpellerHighlightLayer)) as TextDecorationCollection;
            TextRunProperties        textRunProperties        = this._lineProperties.DefaultTextRunProperties;

            if (textDecorationCollection != null)
            {
                if (this._spellerErrorProperties == null)
                {
                    this._spellerErrorProperties = new TextProperties((TextProperties)textRunProperties, textDecorationCollection);
                }
                textRunProperties = this._spellerErrorProperties;
            }
            ITextSelection textSelection = position.TextContainer.TextSelection;
            TextEditor     textEditor    = (textSelection != null) ? textSelection.TextEditor : null;

            if (textEditor != null)
            {
                ITextView textView = textEditor.TextView;
                if (((textView != null) ? new bool?(textView.RendersOwnSelection) : null) == true && highlights.GetHighlightValue(position, LogicalDirection.Forward, typeof(TextSelection)) != DependencyProperty.UnsetValue)
                {
                    TextProperties   textProperties   = new TextProperties((TextProperties)textRunProperties, textDecorationCollection);
                    FrameworkElement frameworkElement = (textEditor != null) ? textEditor.UiScope : null;
                    if (frameworkElement != null)
                    {
                        textProperties.SetBackgroundBrush(null);
                        Brush brush = frameworkElement.GetValue(TextBoxBase.SelectionTextBrushProperty) as Brush;
                        if (brush != null)
                        {
                            textProperties.SetForegroundBrush(brush);
                        }
                    }
                    textRunProperties = textProperties;
                }
            }
            char[] array     = new char[position.GetOffsetToPosition(position2)];
            int    textInRun = position.GetTextInRun(LogicalDirection.Forward, array, 0, array.Length);

            Invariant.Assert(textInRun == array.Length);
            return(new TextCharacters(array, 0, textInRun, textRunProperties));
        }
Esempio n. 3
0
        //-------------------------------------------------------------------
        //
        //  Protected Methods
        //
        //-------------------------------------------------------------------

        #region Protected Methods

        /// <summary>
        /// Fetch the next run at text position.
        /// </summary>
        /// <param name="position">
        /// Current position in text array
        /// </param>
        /// <returns></returns>
        protected TextRun HandleText(StaticTextPointer position)
        {
            DependencyObject  element;
            StaticTextPointer endOfRunPosition;

            Invariant.Assert(position.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text, "TextPointer does not point to characters.");

            if (position.Parent != null)
            {
                element = position.Parent;
            }
            else
            {
                element = _paraClient.Paragraph.Element;
            }

            // Extract the aggregated properties into something that the textrun can use.
            //


            TextProperties textProps = new TextProperties(element, position, false /* inline objects */, true /* get background */,
                                                          _paraClient.Paragraph.StructuralCache.TextFormatterHost.PixelsPerDip);

            // Calculate the end of the run by finding either:
            //      a) the next intersection of highlight ranges, or
            //      b) the natural end of this textrun
            endOfRunPosition = position.TextContainer.Highlights.GetNextPropertyChangePosition(position, LogicalDirection.Forward);

            // Clamp the text run at an arbitrary limit, so we don't make
            // an unbounded allocation.
            if (position.GetOffsetToPosition(endOfRunPosition) > 4096)
            {
                endOfRunPosition = position.CreatePointer(4096);
            }

            // Get character buffer for the text run.
            char[] textBuffer = new char[position.GetOffsetToPosition(endOfRunPosition)];

            // Copy characters from text run into buffer. Note the actual number of characters copied,
            // which may be different than the buffer's length. Buffer length only specifies the maximum
            // number of characters
            int charactersCopied = position.GetTextInRun(LogicalDirection.Forward, textBuffer, 0, textBuffer.Length);

            // Create text run using the actual number of characters copied
            return(new TextCharacters(textBuffer, 0, charactersCopied, textProps));
        }
Esempio n. 4
0
        //-------------------------------------------------------------------
        //
        //  Private Methods
        //
        //-------------------------------------------------------------------

        #region Private Methods

        /// <summary>
        /// Fetch the next run at text position.
        /// </summary>
        private TextRun HandleText(StaticTextPointer position)
        {
            // Calculate the end of the run by finding either:
            //      a) the next intersection of highlight ranges, or
            //      b) the natural end of this textrun
            StaticTextPointer endOfRunPosition = _owner.Host.TextContainer.Highlights.GetNextPropertyChangePosition(position, LogicalDirection.Forward);

            // Clamp the text run at an arbitrary limit, so we don't make
            // an unbounded allocation.
            if (position.GetOffsetToPosition(endOfRunPosition) > 4096)
            {
                endOfRunPosition = position.CreatePointer(4096);
            }

            // Factor in any speller error squiggles on the run.
            TextDecorationCollection highlightDecorations = position.TextContainer.Highlights.GetHighlightValue(position, LogicalDirection.Forward, typeof(SpellerHighlightLayer)) as TextDecorationCollection;
            TextRunProperties        properties;

            if (highlightDecorations == null)
            {
                properties = _lineProperties.DefaultTextRunProperties;
            }
            else
            {
                if (_spellerErrorProperties == null)
                {
                    _spellerErrorProperties = new TextProperties((TextProperties)_lineProperties.DefaultTextRunProperties, highlightDecorations);
                }
                properties = _spellerErrorProperties;
            }

            // Get character buffer for the text run.
            char[] textBuffer = new char[position.GetOffsetToPosition(endOfRunPosition)];

            // Copy characters from text run into buffer. Since we are dealing with plain text content,
            // we expect to get all the characters from position to endOfRunPosition.
            int charactersCopied = position.GetTextInRun(LogicalDirection.Forward, textBuffer, 0, textBuffer.Length);

            Invariant.Assert(charactersCopied == textBuffer.Length);

            // Create text run, using characters copied as length
            return(new TextCharacters(textBuffer, 0, charactersCopied, properties));
        }
        // Token: 0x06006606 RID: 26118 RVA: 0x001CAF70 File Offset: 0x001C9170
        private TextRun HandleText(StaticTextPointer position)
        {
            DependencyObject target;

            if (position.Parent != null)
            {
                target = position.Parent;
            }
            else
            {
                target = this._owner;
            }
            TextRunProperties textRunProperties = new TextProperties(target, position, false, true, base.PixelsPerDip);
            StaticTextPointer position2         = this._owner.Highlights.GetNextPropertyChangePosition(position, LogicalDirection.Forward);

            if (position.GetOffsetToPosition(position2) > 4096)
            {
                position2 = position.CreatePointer(4096);
            }
            char[] array     = new char[position.GetOffsetToPosition(position2)];
            int    textInRun = position.GetTextInRun(LogicalDirection.Forward, array, 0, array.Length);

            return(new TextCharacters(array, 0, textInRun, textRunProperties));
        }
Esempio n. 6
0
        //-------------------------------------------------------------------
        //
        //  Private Methods
        //
        //-------------------------------------------------------------------

        #region Private Methods

        /// <summary>
        /// Fetch the next run at text position.
        /// </summary>
        private TextRun HandleText(StaticTextPointer position)
        {
            // Calculate the end of the run by finding either:
            //      a) the next intersection of highlight ranges, or
            //      b) the natural end of this textrun
            StaticTextPointer endOfRunPosition = _owner.Host.TextContainer.Highlights.GetNextPropertyChangePosition(position, LogicalDirection.Forward);

            // Clamp the text run at an arbitrary limit, so we don't make
            // an unbounded allocation.
            if (position.GetOffsetToPosition(endOfRunPosition) > 4096)
            {
                endOfRunPosition = position.CreatePointer(4096);
            }

            var highlights = position.TextContainer.Highlights;

            // Factor in any speller error squiggles on the run.
            TextDecorationCollection highlightDecorations = highlights.GetHighlightValue(position, LogicalDirection.Forward, typeof(SpellerHighlightLayer)) as TextDecorationCollection;

            TextRunProperties properties = _lineProperties.DefaultTextRunProperties;

            if (highlightDecorations != null)
            {
                if (_spellerErrorProperties == null)
                {
                    _spellerErrorProperties = new TextProperties((TextProperties)properties, highlightDecorations);
                }
                properties = _spellerErrorProperties;
            }

            var textEditor = position.TextContainer.TextSelection?.TextEditor;

            // DDVSO:405199
            // Apply selection highlighting if needed
            if ((textEditor?.TextView?.RendersOwnSelection == true) &&
                highlights.GetHighlightValue(position, LogicalDirection.Forward, typeof(TextSelection)) != DependencyProperty.UnsetValue)
            {
                // We need to create a new TextProperties instance here since we are going to change the Foreground and Background.
                var selectionProps = new TextProperties((TextProperties)properties, highlightDecorations);

                // The UiScope that owns this line should be the source for text/highlight properties
                var uiScope = textEditor?.UiScope;

                if (uiScope != null)
                {
                    // All selection properties are taken from TextBoxBase
                    bool isSelectionActive = (bool)uiScope.GetValue(TextBoxBase.IsSelectionActiveProperty);
                    bool isInactiveSelectionHighlightEnabled = (bool)uiScope.GetValue(TextBoxBase.IsInactiveSelectionHighlightEnabledProperty);

                    Brush selectionTextBrush = SystemColors.HighlightTextBrush;

                    // If we have an inactive selection and we allow the highlight, set the appropriate brush for the text here.
                    if (!isSelectionActive && isInactiveSelectionHighlightEnabled)
                    {
                        selectionTextBrush = SystemColors.InactiveSelectionHighlightTextBrush;
                    }

                    // Background should not be drawn since the selection is drawn below us
                    selectionProps.SetBackgroundBrush(null);
                    selectionProps.SetForegroundBrush(selectionTextBrush);
                }

                properties = selectionProps;
            }

            // Get character buffer for the text run.
            char[] textBuffer = new char[position.GetOffsetToPosition(endOfRunPosition)];

            // Copy characters from text run into buffer. Since we are dealing with plain text content,
            // we expect to get all the characters from position to endOfRunPosition.
            int charactersCopied = position.GetTextInRun(LogicalDirection.Forward, textBuffer, 0, textBuffer.Length);

            Invariant.Assert(charactersCopied == textBuffer.Length);

            // Create text run, using characters copied as length
            return(new TextCharacters(textBuffer, 0, charactersCopied, properties));
        }