Exemplo n.º 1
0
        void CreateLine()
        {
            TextFormatter formatter = TextFormatter.Create();

            if (textSource.Text.Length == 0)
            {
                TextLine myTextLine = formatter.FormatLine(
                    textSource,
                    0,
                    this._width,
                    new GenericTextParagraphProperties(fontRender, this.FlowDirection, this.TextWarpping),
                    null);
                lines.Add(myTextLine);
            }
            else
            {
                int textStorePosition = 0;
                this.lines.Clear();
                while (textStorePosition < textSource.Text.Length)
                {
                    TextLine myTextLine = formatter.FormatLine(
                        textSource,
                        textStorePosition,
                        this._width,
                        new GenericTextParagraphProperties(fontRender, this.FlowDirection, this.TextWarpping),
                        null);
                    lines.Add(myTextLine);
                    textStorePosition += myTextLine.Length;
                }
            }
        }
 /// <summary>
 /// Constructs a TextLine from a simple text.
 /// </summary>
 internal static TextLine PrepareText(TextFormatter formatter, string text, TextRunProperties properties)
 {
     if (formatter == null)
     {
         throw new ArgumentNullException(nameof(formatter));
     }
     if (text == null)
     {
         throw new ArgumentNullException(nameof(text));
     }
     if (properties == null)
     {
         throw new ArgumentNullException(nameof(properties));
     }
     return(formatter.FormatLine(
                new SimpleTextSource(text, properties),
                0,
                32000,
                new TextParagraphProperties
     {
         DefaultTextRunProperties = properties,
         TextWrapping = TextWrapping.NoWrap,
         DefaultIncrementalTab = 40
     }));
 }
Exemplo n.º 3
0
        private void UpdateFormattedText02()
        {
            // Create a DrawingGroup object for storing formatted text.
            myTextDisplay = new DrawingGroup();
            DrawingContext drawingContext = myTextDisplay.Open();

            // Update the text store.
            customTextSource.Text = "The quick red fox jumped over the lazy brown dog.";

            // Create a TextFormatter object.
            TextFormatter formatter = TextFormatter.Create();

            // Create common paragraph property settings.
            CustomTextParagraphProperties customTextParagraphProperties
                = new CustomTextParagraphProperties();

            // <SnippetTextFormattingSnippet2>
            // Create a textline from the text store using the TextFormatter object.
            TextLine myTextLine = formatter.FormatLine(
                customTextSource,
                0,
                400,
                customTextParagraphProperties,
                null);

            // Draw the formatted text into the drawing context.
            myTextLine.Draw(drawingContext, new Point(0, 0), InvertAxes.None);
            // </SnippetTextFormattingSnippet2>

            // Persist the drawn text content.
            drawingContext.Close();

            // Display the formatted text in the DrawingGroup object.
            myDrawingBrush.Drawing = myTextDisplay;
        }
Exemplo n.º 4
0
 /// <summary>
 /// Constructs a TextLine from a simple text.
 /// </summary>
 public static TextLine PrepareText(TextFormatter formatter, string text, TextRunProperties properties)
 {
     if (formatter == null)
     {
         throw new ArgumentNullException("formatter");
     }
     if (text == null)
     {
         throw new ArgumentNullException("text");
     }
     if (properties == null)
     {
         throw new ArgumentNullException("properties");
     }
     return(formatter.FormatLine(
                new SimpleTextSource(text, properties),
                0,
                32000,
                new VisualLineTextParagraphProperties {
         defaultTextRunProperties = properties,
         textWrapping = TextWrapping.NoWrap,
         tabSize = 40
     },
                null));
 }
Exemplo n.º 5
0
            public Size Measure(double width)
            {
                var height = 0.0;

                int textSourcePosition = 0;

                while (textSourcePosition < textSource.Length)
                {
                    using (var line = formatter.FormatLine(textSource, textSourcePosition, width, defaultParagraphProps, previousLineBreak: null, textRunCache: textSource.Cache))
                    {
                        height             += line.Height;
                        textSourcePosition += line.Length;
                    }
                }

                return(new Size(width, height));
            }
Exemplo n.º 6
0
        Line CreateLine(ITextViewLine viewLine, LineNumberState lineNumberState, int lineNumber)
        {
            var lineNumberString = GetLineNumberString(lineNumber);
            var lineNumberSource = new LineNumberSource(lineNumberString, GetLineNumberTextFormattingRunProperties(viewLine, lineNumberState, lineNumber));
            var textLine         = textFormatter.FormatLine(lineNumberSource, 0, 0, defaultTextParagraphProperties, null);

            return(new Line(lineNumber, textLine, lineNumberTextRight, viewLine.TextTop + viewLine.Baseline - textLine.TextBaseline));
        }
Exemplo n.º 7
0
        public override HexFormattedLine FormatLineInVisualBuffer(HexBufferLine line)
        {
            if (line == null)
            {
                throw new ArgumentNullException(nameof(line));
            }

            var seqColl             = HexAndAdornmentSequencer.CreateHexAndAdornmentCollection(line);
            var linePartsCollection = CreateLinePartsCollection(seqColl, line);
            var textSource          = new HexLinePartsTextSource(linePartsCollection);

            TextLineBreak previousLineBreak = null;
            double        autoIndent        = BaseIndentation;
            int           column            = 0;
            int           linePartsIndex    = 0;
            var           lineParts         = linePartsCollection.LineParts;

            textSource.SetMaxLineLength(MAX_LINE_LENGTH);
            var textLine = textFormatter.FormatLine(textSource, column, 0, defaultTextParagraphProperties, previousLineBreak);

            int startColumn = column;
            int length      = TF.TextLineExtensions.GetLength(textLine, textSource.EndOfLine);

            column += length;

            int linePartsEnd = linePartsIndex;

            Debug.Assert(lineParts.Count == 0 || linePartsEnd < lineParts.Count);
            while (linePartsEnd < lineParts.Count)
            {
                var part = lineParts[linePartsEnd];
                linePartsEnd++;
                if (column <= part.Column + part.ColumnLength)
                {
                    break;
                }
            }
            linePartsEnd--;

            var startPos = textSource.ConvertColumnToLinePosition(startColumn);
            var endPos   = textSource.ConvertColumnToLinePosition(column);

            if (column >= textSource.Length)
            {
                endPos       = line.TextSpan.End;
                linePartsEnd = lineParts.Count - 1;
            }

            var lineSpan      = VST.Span.FromBounds(startPos, endPos);
            var formattedLine = new HexFormattedLineImpl(linePartsCollection, linePartsIndex, linePartsEnd - linePartsIndex + 1, startColumn, column, line, lineSpan, textLine, autoIndent, ColumnWidth);

            Debug.Assert(column == textSource.Length);

            return(formattedLine);
        }
Exemplo n.º 8
0
        /// <summary>
        /// Method for starting the text formatting process. Each event handler
        /// will call this after the current fontrendering is updated.
        /// </summary>
        private void UpdateFormattedText(double pixelsPerDip)
        {
            // Make sure all UI is loaded
            if (!_UILoaded)
            {
                return;
            }

            // Initialize the text store.
            _textStore = new CustomTextSource(_pixelsPerDip);

            int textStorePosition = 0;                                          //Index into the text of the textsource

            System.Windows.Point linePosition = new System.Windows.Point(0, 0); //current line

            // Create a DrawingGroup object for storing formatted text.
            textDest = new DrawingGroup();
            DrawingContext dc = textDest.Open();

            // Update the text store.
            _textStore.Text          = textToFormat.Text;
            _textStore.FontRendering = _currentRendering;

            // Create a TextFormatter object.
            TextFormatter formatter = TextFormatter.Create();

            // Format each line of text from the text store and draw it.
            while (textStorePosition < _textStore.Text.Length)
            {
                // Create a textline from the text store using the TextFormatter object.
                using (TextLine myTextLine = formatter.FormatLine(
                           _textStore,
                           textStorePosition,
                           96 * 6,
                           new GenericTextParagraphProperties(_currentRendering, _pixelsPerDip),
                           null))
                {
                    // Draw the formatted text into the drawing context.
                    myTextLine.Draw(dc, linePosition, InvertAxes.None);

                    // Update the index position in the text store.
                    textStorePosition += myTextLine.Length;

                    // Update the line position coordinate for the displayed line.
                    linePosition.Y += myTextLine.Height;
                }
            }

            // Persist the drawn text content.
            dc.Close();

            // Display the formatted text in the DrawingGroup object.
            myDrawingBrush.Drawing = textDest;
        }
Exemplo n.º 9
0
        public WpfTextLine MakeTextLine(int lineNumber)
        {
            // Use '~' for the phantom line, otherwise the line number.
            string text = lineNumber == -1 ? "~" :
                          lineNumber.ToString(CultureInfo.CurrentUICulture.NumberFormat);

            var textSource = new LineNumberTextSource(text, _formatting);
            var format     = new TextFormattingParagraphProperties(_formatting);

            return(_textFormatter.FormatLine(textSource, 0, 0, format, null));
        }
Exemplo n.º 10
0
        private void UpdateFormattedText()
        {
            // Index into the text of the TextSource object.
            int textStorePosition = 0;

            // The position of the current line.
            Point linePosition = new Point(0, 0);

            // Create a DrawingGroup object for storing formatted text.
            myTextDisplay = new DrawingGroup();
            DrawingContext drawingContext = myTextDisplay.Open();

            // Update the text store.
            customTextSource.Text = textToFormat.Text;

            // <SnippetTextFormattingSnippet1>
            // Create a TextFormatter object.
            TextFormatter formatter = TextFormatter.Create();

            // Create common paragraph property settings.
            CustomTextParagraphProperties customTextParagraphProperties
                = new CustomTextParagraphProperties();

            // Format each line of text from the text store and draw it.
            while (textStorePosition < customTextSource.Text.Length)
            {
                // Create a textline from the text store using the TextFormatter object.
                using (TextLine myTextLine = formatter.FormatLine(
                           customTextSource,
                           textStorePosition,
                           96 * 6,
                           customTextParagraphProperties,
                           null))
                {
                    // Draw the formatted text into the drawing context.
                    myTextLine.Draw(drawingContext, linePosition, InvertAxes.None);

                    // Update the index position in the text store.
                    textStorePosition += myTextLine.Length;

                    // Update the line position coordinate for the displayed line.
                    linePosition.Y += myTextLine.Height;
                }
            }
            // </SnippetTextFormattingSnippet1>

            // Persist the drawn text content.
            drawingContext.Close();

            // Display the formatted text in the DrawingGroup object.
            myDrawingBrush.Drawing = myTextDisplay;
        }
 // Token: 0x06004134 RID: 16692 RVA: 0x0012A210 File Offset: 0x00128410
 internal void Format(int dcp, double formatWidth, double paragraphWidth, LineProperties lineProperties, TextRunCache textRunCache, TextFormatter formatter)
 {
     this._lineProperties = lineProperties;
     this._dcp            = dcp;
     this._paragraphWidth = paragraphWidth;
     lineProperties.IgnoreTextAlignment = (lineProperties.TextAlignment != TextAlignment.Justify);
     try
     {
         this._line = formatter.FormatLine(this, dcp, formatWidth, lineProperties, null, textRunCache);
     }
     finally
     {
         lineProperties.IgnoreTextAlignment = false;
     }
 }
Exemplo n.º 12
0
        public IList <TextLineVisual> CreateLineVisual(Int32 lineNumber, IList <SpaceNegotiation> spaceNegotiations)
        {
            IList <ClassificationSpan> classificationSpans;
            Int32 startOfLineFromLineNumber   = _textView.TextBuffer.GetStartOfLineFromLineNumber(lineNumber);
            Int32 startOfNextLineFromPosition = _textView.TextBuffer.GetStartOfNextLineFromPosition(startOfLineFromLineNumber);
            Int32 lengthOfLineFromLineNumber  = _textView.TextBuffer.GetLengthOfLineFromLineNumber(lineNumber);
            Int32 length = 0;

            if (startOfNextLineFromPosition == startOfLineFromLineNumber)
            {
                length = _textView.TextBuffer.GetEndOfLineFromPosition(startOfLineFromLineNumber) - startOfLineFromLineNumber;
            }
            else
            {
                length = startOfNextLineFromPosition - startOfLineFromLineNumber;
            }
            if (length > 0)
            {
                classificationSpans = _classifier.GetClassificationSpans(new VersionedTextSpan(_textView.TextBuffer, startOfLineFromLineNumber, length));
            }
            else
            {
                classificationSpans = new List <ClassificationSpan>(0);
            }
            TextFormattingSource textSource = new TextFormattingSource(_textView.TextBuffer, _classificationFormatMap, startOfLineFromLineNumber, length, classificationSpans, spaceNegotiations);

            if (_textFormatter == null)
            {
                _textFormatter = TextFormatter.Create();
            }
            List <TextLine> textLines         = new List <TextLine>();
            Int32           firstCharIndex    = 0;
            TextLineBreak   previousLineBreak = null;

            while (firstCharIndex <= length)
            {
                TextLine item = _textFormatter.FormatLine(textSource, firstCharIndex, this.MaxLineWidth, _paragraphProperties, previousLineBreak);
                firstCharIndex   += item.Length;
                previousLineBreak = item.GetTextLineBreak();
                textLines.Add(item);
            }
            List <TextLineVisual> list3 = new List <TextLineVisual>();

            list3.Add(new TextLineVisual(_textView, textLines, new TextSpan(_textView.TextBuffer, startOfLineFromLineNumber, length), length - lengthOfLineFromLineNumber, textSource.VirtualCharacterPositions));
            return(list3);
        }
Exemplo n.º 13
0
        //-------------------------------------------------------------------
        //
        //  Internal Methods
        //
        //-------------------------------------------------------------------

        #region Internal Methods

        /// <summary>
        /// Create and format text line.
        /// </summary>
        /// <param name="dcp">First character position for the line.</param>
        /// <param name="formatWidth">Width to pass to LS formatter.</param>
        /// <param name="paragraphWidth">Line wrapping width.</param>
        /// <param name="lineProperties">Line's properties.</param>
        /// <param name="textRunCache">Run cache.</param>
        /// <param name="formatter">Text formatter.</param>
        /// <remarks>
        /// formatWidth/paragraphWidth is an attempt to work around bug 114719.
        /// Unfortunately, Line Services cannot guarantee that once a line
        /// has been measured, measuring the same content with the actual line
        /// width will produce the same line.
        ///
        /// For example, suppose we format dcp 0 with paragraphWidth = 100.
        /// Suppose this results in a line from dcp 0 - 10, with width = 95.
        ///
        /// We would expect that a call to FormatLine with dcp = 0,
        /// paragraphWidth = 95 would result in the same 10 char line.
        /// But in practice it might return a 9 char line.
        ///
        /// The workaround is to pass in an explicit formatting width across
        /// multiple calls, even if the paragraphWidth changes.
        /// </remarks>
        internal void Format(int dcp, double formatWidth, double paragraphWidth, LineProperties lineProperties, TextRunCache textRunCache, TextFormatter formatter)
        {
            _lineProperties = lineProperties;
            _dcp            = dcp;
            _paragraphWidth = paragraphWidth;

            // We must ignore TextAlignment here since formatWidth does not
            // necessarilly equal paragraphWidth.  We'll adjust on later calls.
            lineProperties.IgnoreTextAlignment = (lineProperties.TextAlignment != TextAlignment.Justify);
            try
            {
                _line = formatter.FormatLine(this, dcp, formatWidth, lineProperties, null, textRunCache);
            }
            finally
            {
                lineProperties.IgnoreTextAlignment = false;
            }
        }
Exemplo n.º 14
0
        private void GenerateFormattedText(CustomTextSource textStore, DrawingContext dc, TextFormatter formatter)
        {
            int   textStorePosition = 0;               //Index into the text of the textsource
            Point linePosition      = new Point(0, 0); //current line

            // Format each line of text from the text store and draw it.
            while (textStorePosition < textStore.Text.Length)
            {
                TextLine textLine = formatter.FormatLine(textStore, textStorePosition, textStore.ParagraphWidth, textStore.CTPProperties, null);

                // Draw the formatted text into the drawing context.
                textLine.Draw(dc, linePosition, InvertAxes.None);

                // Update the index position in the text store.
                textStorePosition += textLine.Length;

                // Update the line position coordinate for the displayed line.
                linePosition.Y += textLine.Height;
            }
        }
        public void Render(int startPos, int count)
        {
            DrawingContext dc = RenderOpen();

            if (_textStore != null && count > 0)
            {
                _textStore.LastRenderColumn = startPos + count;

                // Create a TextFormatter object.
                TextFormatter formatter = TextFormatter.Create();

                // Format each line of text from the text store and draw it.
                // Create a textline from the text store using the TextFormatter object.
                using (var myTextLine = formatter.FormatLine(_textStore, startPos, 0, _paragraphProps, null))
                {
                    // Draw the formatted text into the drawing context.
                    myTextLine.Draw(dc, new Point(), InvertAxes.None);
                }
            }
            dc.Close();
        }
Exemplo n.º 16
0
        public IEnumerable <TextLine> Format(string text, IChatSpanProvider spans, double width, Brush foreground, Brush background,
                                             TextWrapping textWrapping)
        {
            _text          = text;
            _spans         = spans;
            _background    = background;
            _runProperties = new CustomTextRunProperties(_runProperties.Typeface, _runProperties.FontRenderingEmSize, foreground,
                                                         Brushes.Transparent, false);
            _paraProperties = new CustomParagraphProperties(_runProperties);
            if (width < 0)
            {
                width = 0;
                text  = "";
            }

            int idx = 0;

            while (idx < _text.Length)
            {
                var line = _formatter.FormatLine(this, idx, width, _paraProperties, null);
                idx += line.Length;
                yield return(line);
            }
        }
Exemplo n.º 17
0
 public TextLine FormatLine(TextSource textSource, int firstCharIndex, double paragraphWidth,
                            TextParagraphProperties paragraphProperties, TextLineBreak previousLineBreak)
 {
     return(formatter.FormatLine(textSource, firstCharIndex, paragraphWidth, paragraphProperties, previousLineBreak));
 }
        private void Render(Point location, string colour)
        {
            int  textStorePosition = 0;
            bool flipped;

            Position = location;
            if (ParentAtom == null)
            {
                flipped = false;
            }
            else
            {
                flipped = Flipped;
            }

            var textStore = new FunctionalGroupTextSource(ParentGroup, colour, flipped);

            //main textformatter - this does the writing of the visual
            using (TextFormatter textFormatter = TextFormatter.Create())
            {
                //set up the default paragraph properties
                var paraprops = new FunctionalGroupTextSource.GenericTextParagraphProperties(
                    FlowDirection.LeftToRight,
                    TextAlignment.Left,
                    true,
                    false,
                    new LabelTextRunProperties(colour),
                    TextWrapping.NoWrap,
                    GlyphText.SymbolSize,
                    0d);

                var    anchorRuns   = textStore.Runs.Where(f => f.IsAnchor);
                string anchorString = string.Empty;
                foreach (var run in anchorRuns)
                {
                    anchorString += run.Text;
                }

                using (TextLine myTextLine =
                           textFormatter.FormatLine(textStore, textStorePosition, 999, paraprops, null))
                {
                    IList <TextBounds> textBounds;
                    Rect firstRect = Rect.Empty;
                    if (!Flipped) //isolate them at the beginning
                    {
                        textBounds = myTextLine.GetTextBounds(0, anchorString.Length);
                    }
                    else
                    {
                        //isolate them at the end
                        var start = myTextLine.Length - 1 - anchorString.Length;
                        textBounds = myTextLine.GetTextBounds(start, anchorString.Length);
                    }

                    //add all the bounds together
                    foreach (TextBounds anchorBound in textBounds)
                    {
                        firstRect.Union(anchorBound.Rectangle);
                    }

                    //center will be position close to the origin 0,0
                    Point center = new Point((firstRect.Left + firstRect.Right) / 2,
                                             (firstRect.Top + firstRect.Bottom) / 2);

                    //the displacement vector will be added to each relative coordinate for the glyph run
                    var displacementVector = location - center;

                    //locus is where the text line is drawn
                    var locus = new Point(0, 0) + displacementVector;

                    textBounds = myTextLine.GetTextBounds(0, 999);
                    var obb = textBounds[0].Rectangle;

                    //draw the line of text
                    using (DrawingContext dc = RenderOpen())
                    {
                        myTextLine.Draw(dc, locus, InvertAxes.None);
#if DEBUG
#if SHOWBOUNDS
                        obb.Offset(new Vector(locus.X, locus.Y));
                        dc.DrawRectangle(null, new Pen(new SolidColorBrush(Colors.BlueViolet), 1.0), obb);
#endif
#endif
                        var          glyphRuns     = myTextLine.GetIndexedGlyphRuns();
                        List <Point> outline       = new List <Point>();
                        double       advanceWidths = 0d;

                        //build up the convex hull from each glyph
                        //you need to add in the advance widths for each
                        //glyph run as they are traversed,
                        //to the outline
                        foreach (IndexedGlyphRun igr in glyphRuns)
                        {
                            var originalRun = textStore.GetTextRun(igr.TextSourceCharacterIndex);
                            var currentRun  = igr.GlyphRun;
                            //need to work out how much the current run has been offset from the baseline
                            var runBounds =
                                myTextLine.GetTextBounds(igr.TextSourceCharacterIndex, igr.TextSourceLength);
                            //get the bounding rect
                            var rect = runBounds[0].TextRunBounds[0].Rectangle;

                            //it's relative to the baseline
                            //adjust it
                            rect.Offset(new Vector(locus.X, locus.Y));
                            var rectCopy = rect;
#if DEBUG
#if SHOWBOUNDS
                            dc.DrawRectangle(null, new Pen(new SolidColorBrush(Colors.DarkOrange), 1.0), rect);
#endif
#endif
                            var runOutline = GlyphUtils.GetOutline(currentRun);
                            //need to see if the run has been super or sub-scripted
                            var variants = originalRun.Properties.TypographyProperties.Variants;

                            if (variants == FontVariants.Subscript || variants == FontVariants.Superscript)
                            {
                                //simply union in the rect -it's easier!
                                outline.AddRange(new[]
                                {
                                    rectCopy.BottomLeft, rectCopy.BottomRight, rectCopy.TopLeft,
                                    rectCopy.TopRight
                                });
                            }
                            else
                            {
                                //add in the points from the convex hull
                                for (int i = 0; i < runOutline.Count; i++)
                                {
                                    var point = runOutline[i] + displacementVector +
                                                new Vector(0.0, myTextLine.Baseline);
                                    point.X      += advanceWidths;
                                    runOutline[i] = point;
                                }

                                outline.AddRange(runOutline);
                            }

                            advanceWidths += currentRun.AdvanceWidths.Sum();
                        }

                        _sortedOutline = (from Point p in outline
                                          orderby p.X ascending, p.Y descending
                                          select p).ToList();

                        Hull = Geometry <Point> .GetHull(_sortedOutline, p => p);

                        // Diag: Show Hulls or Atom centres
#if DEBUG
#if SHOWHULLS
                        dc.DrawGeometry(null, new Pen(Brushes.GreenYellow, thickness: 1), HullGeometry);
#endif
#if SHOWATOMCENTRES
                        dc.DrawEllipse(Brushes.Red, null, ParentAtom.Position, 5, 5);
#endif
#endif
                        // End Diag
                        dc.Close();
                    }
                }
            }
        }
        /// <summary>
        /// When overridden in a derived class, participates in rendering operations that are directed by the layout system.
        /// The rendering instructions for this element are not used directly when this method is invoked,
        /// and are instead preserved for later asynchronous use by layout and drawing.
        /// </summary>
        /// <param name="drawingContext">The drawing instructions for a specific element. This context is provided to the layout system.</param>
        protected override void OnRender([NotNull] DrawingContext drawingContext)
        {
            Assert.ArgumentNotNull(drawingContext, "drawingContext");

            try
            {
                if (Visibility != Visibility.Visible)
                {
                    return;
                }

                drawingContext.DrawRectangle(Themes.ThemeManager.Instance.ActiveTheme.GetBrushByTextColor(Themes.TextColor.None, true), new Pen(Themes.ThemeManager.Instance.ActiveTheme.GetBrushByTextColor(Themes.TextColor.None, true), 0), new Rect(0, 0, ActualWidth, ActualHeight));
                var renderedLines = 0;
                if (_selectionSettings.NeedUpdate)
                {
                    _tempSelectionSettings.SelectedMessages.Clear();
                }

                if (_messages.Count > 0)
                {
                    var currentHeight = ActualHeight;
                    var lineNumber    = _currentLineNumber;
                    while (currentHeight > 0 && lineNumber > 0)
                    {
                        _textSource.Message = _messages[lineNumber - 1];
                        var textStorePosition = 0;

                        _linesToRenderStack.Clear();

                        do
                        {
                            var line = _formatter.FormatLine(_textSource, textStorePosition, ActualWidth, _customTextParagraphProperties, null, _textRunCache);
                            _linesToRenderStack.Push(line);
                            textStorePosition += line.Length;
                        }while (textStorePosition < _messages[lineNumber - 1].InnerText.Length);

                        var  drawnChars      = 0;
                        bool messageSelected = false;
                        while (_linesToRenderStack.Count > 0)
                        {
                            var line = _linesToRenderStack.Pop();
                            line.Draw(drawingContext, new Point(0, currentHeight - line.Height), InvertAxes.None);

                            _lineHeight = line.Height;
                            drawnChars += line.Length;
                            if (_selectionSettings.NeedUpdate)
                            {
                                messageSelected = ProcessLineForSelection(line, _messages[lineNumber - 1], currentHeight, drawnChars, messageSelected);
                            }

                            currentHeight -= line.Height;
                            line.Dispose();
                        }

                        renderedLines++;
                        lineNumber--;
                        _textRunCache.Invalidate();
                    }
                }

                _currentNumberOfLinesInView = renderedLines;
                if (_selectionSettings.NeedUpdate)
                {
                    _selectionSettings.SelectionEndCharacterNumber   = _tempSelectionSettings.SelectionEndCharacterNumber;
                    _selectionSettings.SelectionStartCharacterNumber = _tempSelectionSettings.SelectionStartCharacterNumber;
                    _selectionSettings.SelectedMessages.Clear();
                    _selectionSettings.SelectedMessages.AddRange(_tempSelectionSettings.SelectedMessages);
                    _selectionSettings.NeedUpdate = false;
                    InvalidateVisual();
                }
            }
            catch (Exception ex)
            {
                _selectionSettings.NeedUpdate = false;
                _textRunCache.Invalidate();
                ClearTextSelection();
                ErrorLogger.Instance.Write(string.Format("Error rendering text {0}", ex));
            }
        }
Exemplo n.º 20
0
        public Collection <IFormattedLine> FormatLineInVisualBuffer(ITextSnapshotLine visualLine)
        {
            if (visualLine == null)
            {
                throw new ArgumentNullException(nameof(visualLine));
            }
            if (visualLine.Snapshot != TopTextSnapshot)
            {
                throw new ArgumentException();
            }

            var seqColl             = TextAndAdornmentSequencer.CreateTextAndAdornmentCollection(visualLine, visualLine.Snapshot);
            var bufferLine          = GetBufferLine(seqColl);
            var linePartsCollection = CreateLinePartsCollection(seqColl, bufferLine.ExtentIncludingLineBreak);
            var textSource          = new LinePartsTextSource(linePartsCollection);
            var lines = new Collection <IFormattedLine>();

            TextLineBreak previousLineBreak = null;
            double        autoIndent        = BaseIndentation;
            int           column            = 0;

            for (int lineSegment = 0; ; lineSegment++)
            {
                var paragraphProperties = textParagraphPropertiesFactoryService?.Create(this,
                                                                                        classificationFormatMap.DefaultTextProperties,
                                                                                        TextAndAdornmentSequencer.BufferGraph.CreateMappingSpan(bufferLine.Extent, SpanTrackingMode.EdgeNegative),
                                                                                        TextAndAdornmentSequencer.BufferGraph.CreateMappingPoint(textSource.ConvertColumnToBufferPosition(column), PointTrackingMode.Negative), lineSegment)
                                          ?? defaultTextParagraphProperties;

                double paragraphWidth = WordWrapWidth == 0 ? 0 : Math.Max(1, WordWrapWidth - autoIndent - wrapGlyphWidth);

                textSource.SetMaxLineLength(MAX_LINE_LENGTH);
                var textLine = textFormatter.FormatLine(textSource, column, paragraphWidth, paragraphProperties, previousLineBreak);

                int startColumn = column;
                int length      = textLine.GetLength(textSource.EndOfLine);
                column += length;

                var startPos = textSource.ConvertColumnToBufferPosition(startColumn);
                var endPos   = textSource.ConvertColumnToBufferPosition(column);
                if (column >= textSource.Length)
                {
                    endPos = bufferLine.ExtentIncludingLineBreak.End;
                }

                var lineSpan = new SnapshotSpan(startPos, endPos);
                var wpfLine  = new WpfTextViewLine(TextAndAdornmentSequencer.BufferGraph, linePartsCollection, startColumn, column, bufferLine, lineSpan, visualLine.Snapshot, textLine, autoIndent, ColumnWidth);
                lines.Add(wpfLine);

                if (column >= textSource.Length)
                {
                    Debug.Assert(column == textSource.Length);
                    break;
                }
                if (startColumn == column)
                {
                    throw new InvalidOperationException();
                }

                if (lineSegment == 0)
                {
                    autoIndent = 0;
                    var firstCharColumn = textSource.GetColumnOfFirstNonWhitespace();
                    if (firstCharColumn < column)
                    {
                        autoIndent += textLine.GetDistanceFromCharacterHit(new CharacterHit(firstCharColumn, 0));
                    }
                    autoIndent += TabSize / 2 * ColumnWidth;
                    if (autoIndent > MaxAutoIndent)
                    {
                        autoIndent = MaxAutoIndent;
                    }
                    // Base indentation should always be included
                    autoIndent += BaseIndentation;
                }

                previousLineBreak = textLine.GetTextLineBreak();
            }

            return(lines);
        }
Exemplo n.º 21
0
        protected void InvalidateText()
        {
            if (Core == null || Core.IsDisposed)
            {
                return;
            }
            ITextZone zonebackground  = null;
            ITextZone zoneforeground  = null;
            ITextZone zonefontweight  = null;
            ITextZone zonefontfamily  = null;
            ITextZone zonefontstyle   = null;
            ITextZone zonefontstretch = null;
            ITextZone zonefontsize    = null;
            ITextItem item            = Core.Start.Item;

            textbuilder.Clear();
            fontindics.Clear();
            this.skipzone      = null;
            this.skipzonestart = -1;
            this.openzone      = null;
            this.closezone     = null;
            this.intozone      = null;
            void _FindAllZone(ITextItem startitem)
            {
                for (ITextZone zone = startitem.Parent; zone != null; zone = zone.Parent)
                {
                    if (!(zone.Doc is IDocsFill))
                    {
                        continue;
                    }
                    IDocsFill doc = (IDocsFill)(zone.Doc);
                    if (doc.Fill == null)
                    {
                        continue;
                    }
                    if (zonebackground == null && doc.Fill.Background != null)
                    {
                        zonebackground = zone;
                    }
                    if (zoneforeground == null && doc.Fill.Foreground != null)
                    {
                        zoneforeground = zone;
                    }
                    if (zonefontweight == null && doc.Fill.FontWeight != null)
                    {
                        zonefontweight = zone;
                    }
                    if (zonefontfamily == null && doc.Fill.FontFamily != null)
                    {
                        zonefontfamily = zone;
                    }
                    if (zonefontstyle == null && doc.Fill.FontStyle != null)
                    {
                        zonefontstyle = zone;
                    }
                    if (zonefontstretch == null && doc.Fill.FontStretch != null)
                    {
                        zonefontstretch = zone;
                    }
                    if (zonefontsize == null && doc.Fill.FontSize != null)
                    {
                        zonefontsize = zone;
                    }
                    if (zonebackground == null)
                    {
                        continue;
                    }
                    if (zoneforeground == null)
                    {
                        continue;
                    }
                    if (zonefontweight == null)
                    {
                        continue;
                    }
                    if (zonefontfamily == null)
                    {
                        continue;
                    }
                    if (zonefontstyle == null)
                    {
                        continue;
                    }
                    if (zonefontsize == null)
                    {
                        continue;
                    }
                    if (zonefontstretch == null)
                    {
                        continue;
                    }
                    break;
                }
            }

            void _RefindAllZone(ITextItem startitem)
            {
                zonebackground  = null;
                zoneforeground  = null;
                zonefontweight  = null;
                zonefontfamily  = null;
                zonefontstyle   = null;
                zonefontsize    = null;
                zonefontstretch = null;
                _FindAllZone(startitem);
            }

            void _AppendText(ITextItem additem, string addtext)
            {
                FontFamily  fontfamily  = TextCore.FontFamily;
                FontStyle   fontstyle   = TextCore.FontStyle;
                FontStretch fontstretch = TextCore.FontStretch;
                FontWeight  fontweight  = TextCore.FontWeight;
                double      fontsize    = TextCore.FontSize;
                Brush       background  = null;
                Brush       foreground  = TextCore.Foreground;

                if (additem.Doc is IDocsFill)
                {
                    IDocsFill doc = (IDocsFill)(additem.Doc);
                    if (doc.Fill != null)
                    {
                        if (doc.Fill.FontFamily != null)
                        {
                            fontfamily = doc.Fill.FontFamily;
                        }
                        if (doc.Fill.FontStyle != null)
                        {
                            fontstyle = doc.Fill.FontStyle.Value;
                        }
                        if (doc.Fill.FontWeight != null)
                        {
                            fontweight = doc.Fill.FontWeight.Value;
                        }
                        if (doc.Fill.FontStretch != null)
                        {
                            fontstretch = doc.Fill.FontStretch.Value;
                        }
                        if (doc.Fill.FontSize != null)
                        {
                            fontsize = doc.Fill.FontSize.Value;
                        }
                        if (doc.Fill.Background != null)
                        {
                            background = new SolidColorBrush(doc.Fill.Background.Value);
                        }
                        if (doc.Fill.Foreground != null)
                        {
                            foreground = new SolidColorBrush(doc.Fill.Foreground.Value);
                        }
                    }
                }
                if (zonefontfamily?.Doc is IDocsFill)
                {
                    fontfamily = ((IDocsFill)(zonefontfamily.Doc)).Fill.FontFamily;
                }
                if (zonefontstyle?.Doc is IDocsFill)
                {
                    fontstyle = ((IDocsFill)(zonefontstyle.Doc)).Fill.FontStyle.Value;
                }
                if (zonefontweight?.Doc is IDocsFill)
                {
                    fontweight = ((IDocsFill)(zonefontweight.Doc)).Fill.FontWeight.Value;
                }
                if (zonefontstretch?.Doc is IDocsFill)
                {
                    fontstretch = ((IDocsFill)(zonefontstretch.Doc)).Fill.FontStretch.Value;
                }
                if (zonefontsize?.Doc is IDocsFill)
                {
                    fontsize = ((IDocsFill)(zonefontsize.Doc)).Fill.FontSize.Value;
                }
                if (zonebackground?.Doc is IDocsFill)
                {
                    background = new SolidColorBrush(((IDocsFill)(zonebackground.Doc)).Fill.Background.Value);
                }
                if (zoneforeground?.Doc is IDocsFill)
                {
                    foreground = new SolidColorBrush(((IDocsFill)(zoneforeground.Doc)).Fill.Foreground.Value);
                }
                fontindics.Add(new TextFontIndex(new TextFontCore(fontstyle, fontstretch, fontfamily, fontweight, fontsize, background, foreground), textbuilder.Length));
                textbuilder.Append(addtext);
            }

            void _AppendSkipZone(ITextZone skipzone)
            {
                FontFamily  fontfamily  = TextCore.FontFamily;
                FontStyle   fontstyle   = TextCore.FontStyle;
                FontStretch fontstretch = TextCore.FontStretch;
                FontWeight  fontweight  = TextCore.FontWeight;
                double      fontsize    = TextCore.FontSize;
                Brush       background  = null;
                Brush       foreground  = Brushes.Gray;

                TextCore.DictBrush.TryGetValue("foreground_skipzone", out foreground);
                skipzonestart = textbuilder.Length;
                skipzonecount = 3;
                fontindics.Add(new TextFontIndex(new TextFontCore(fontstyle, fontstretch, fontfamily, fontweight, fontsize, background, foreground), textbuilder.Length));
                int showstart = 0;
                int showend   = 0;

                if (TextCore.View.Counselor != null)
                {
                    string zonename          = skipzone?.Doc?.Name ?? "{zone_deault}";
                    MRATextInputContext ictx = new MRATextInputContext(skipzone, 0, 0);
                    MRAZoneContext      zctx = new MRAZoneContext(zonename, ictx, MRAZoneAction.Skip);
                    IMRAZoneResult      zret = TextCore.View.Counselor.ZoneAction(zctx);
                    if (zret is IMRAZoneSkipResult)
                    {
                        IMRAZoneSkipResult zsret = (IMRAZoneSkipResult)zret;
                        showstart = zsret.ShowStart;
                        showend   = zsret.ShowEnd;
                    }
                }
                for (int i = 0; i < Math.Min(showstart, skipzone.Items.Count); i++)
                {
                    textbuilder.Append(skipzone.Items[i].ToString());
                }
                textbuilder.Append("...");
                for (int i = Math.Max(0, skipzone.Items.Count - showend); i < skipzone.Items.Count; i++)
                {
                    textbuilder.Append(skipzone.Items[i].ToString());
                }
            }

            void _RemoveZone(ITextItem zone)
            {
                if (item == zonebackground)
                {
                    zonebackground = null;
                }
                if (item == zoneforeground)
                {
                    zoneforeground = null;
                }
                if (item == zonefontweight)
                {
                    zonefontweight = null;
                }
                if (item == zonefontfamily)
                {
                    zonefontfamily = null;
                }
                if (item == zonefontstyle)
                {
                    zonefontstyle = null;
                }
                if (item == zonefontstretch)
                {
                    zonefontstretch = null;
                }
                if (item == zonefontsize)
                {
                    zonefontstretch = null;
                }
            }

            void _AddZone(ITextZone zone)
            {
                if (zone.Doc is IDocsFill)
                {
                    IDocsFill doc = (IDocsFill)(zone.Doc);
                    if (doc.Fill != null)
                    {
                        if (doc.Fill.Background != null)
                        {
                            zonebackground = zone;
                        }
                        if (doc.Fill.Foreground != null)
                        {
                            zoneforeground = zone;
                        }
                        if (doc.Fill.FontWeight != null)
                        {
                            zonefontweight = zone;
                        }
                        if (doc.Fill.FontFamily != null)
                        {
                            zonefontfamily = zone;
                        }
                        if (doc.Fill.FontStyle != null)
                        {
                            zonefontstyle = zone;
                        }
                        if (doc.Fill.FontStretch != null)
                        {
                            zonefontstretch = zone;
                        }
                        if (doc.Fill.FontSize != null)
                        {
                            zonefontsize = zone;
                        }
                    }
                }
            }

            _FindAllZone(item);
            if (Core.Start != null && Core.End != null)
            {
                ITextItem startitem = Core.Start.Item;
                ITextItem enditem   = Core.End.Item;
                startitem = startitem.Parent;
                enditem   = enditem.Parent;
                while (startitem.Level > enditem.Level)
                {
                    startitem = startitem.Parent;
                }
                while (startitem.Level < enditem.Level)
                {
                    enditem = enditem.Parent;
                }
                while (startitem != enditem)
                {
                    startitem = startitem.Parent; enditem = enditem.Parent;
                }
                while (startitem?.Parent != null)
                {
                    if (!(startitem is ITextLine) && ((ITextZone)startitem).LineCount > 1)
                    {
                        this.intozone = (ITextZone)startitem;
                        break;
                    }
                    startitem = startitem.Parent;
                }
            }
            {
                ITextItem startitem = Core.Start.Item;
                ITextItem enditem   = Core.End.Item;
                if (startitem.ID == 0 &&
                    !(startitem.Parent is ITextLine) && !(startitem.Parent is ITextBoxCore) && startitem.Parent.LineCount > 1)
                {
                    this.openzone = startitem.Parent;
                }
                if (enditem.ID == enditem.Parent.Items.Count - 1 &&
                    !(enditem.Parent is ITextLine) && !(enditem.Parent is ITextBoxCore) && enditem.Parent.LineCount > 1)
                {
                    this.closezone = enditem.Parent;
                }
            }
            if (Core.Start.Item == Core.End.Item)
            {
                string text = Core.Start.RightPart.Substring(0, Core.End.ItemIndex - Core.Start.ItemIndex);
                _AppendText(Core.Start.Item, text);
            }
            else if (Core is IMRAZoneSkipInfo)
            {
                IMRAZoneSkipInfo zscore = (IMRAZoneSkipInfo)Core;
                this.skipzone = zscore.SkipZone;
                if (Core.Start.Item.Parent != zscore.SkipZone)
                {
                    _AppendText(Core.Start.Item, Core.Start.RightPart);
                    while (item != null && item != Core.End.Item)
                    {
                        while (item?.Parent != null && item.ID + 1 >= item.Parent.Items.Count)
                        {
                            item = item.Parent;
                            ITextZone zone = (ITextZone)item;
                            if (!(zone is ITextLine) && zone.LineCount > 1)
                            {
                                this.closezone = zone;
                            }
                            _RemoveZone(item);
                        }
                        if (item?.Parent == null)
                        {
                            break;
                        }
                        item = item.Parent.Items[item.ID + 1];
                        _FindAllZone(item);
                        while (item is ITextZone)
                        {
                            ITextZone zone = (ITextZone)item;
                            if (zone == zscore.SkipZone)
                            {
                                break;
                            }
                            _AddZone(zone);
                            item = zone.Items.FirstOrDefault();
                        }
                        if (item == zscore.SkipZone)
                        {
                            break;
                        }
                        _AppendText(item, item.ToString());
                    }
                }
                _AppendSkipZone(zscore.SkipZone);
                if (Core.End.Item.Parent != zscore.SkipZone)
                {
                    item = zscore.SkipZone;
                    _RefindAllZone(item);
                    while (item != null && item != Core.End.Item)
                    {
                        while (item?.Parent != null && item.ID + 1 >= item.Parent.Items.Count)
                        {
                            item = item.Parent;
                            _RemoveZone(item);
                        }
                        if (item?.Parent == null)
                        {
                            break;
                        }
                        item = item.Parent.Items[item.ID + 1];
                        _FindAllZone(item);
                        while (item is ITextZone)
                        {
                            ITextZone zone = (ITextZone)item;
                            if (!(zone is ITextLine) && zone.LineCount > 1)
                            {
                                this.openzone = zone;
                            }
                            _AddZone(zone);
                            item = zone.Items.FirstOrDefault();
                        }
                        _AppendText(item, item.ToString());
                    }
                    _AppendText(Core.End.Item, Core.End.LeftPart);
                }
            }
            else
            {
                _AppendText(Core.Start.Item, Core.Start.RightPart);
                while (item != null && item != Core.End.Item)
                {
                    while (item?.Parent != null && item.ID + 1 >= item.Parent.Items.Count)
                    {
                        item = item.Parent;
                        ITextZone zone = (ITextZone)item;
                        if (!(zone is ITextLine) && zone.LineCount > 1)
                        {
                            this.closezone = zone;
                            if (intozone == null || zone.Level < intozone.Level)
                            {
                                this.intozone = zone;
                            }
                        }
                        _RemoveZone(item);
                    }
                    if (item?.Parent == null)
                    {
                        break;
                    }
                    item = item.Parent.Items[item.ID + 1];
                    _FindAllZone(item);
                    while (item is ITextZone)
                    {
                        ITextZone zone = (ITextZone)item;
                        if (!(zone is ITextLine) && zone.LineCount > 1)
                        {
                            this.openzone = zone;
                            if (intozone == null || zone.Level < intozone.Level)
                            {
                                this.intozone = zone;
                            }
                        }
                        _AddZone(zone);
                        item = zone.Items.FirstOrDefault();
                    }
                    if (item == Core.End.Item)
                    {
                        break;
                    }
                    _AppendText(item, item.ToString());
                }
                _AppendText(Core.End.Item, Core.End.LeftPart);
            }

            this.textsource = new MRATextSource(textbuilder.ToString(), fontindics);
            this.textline   = textfmtr.FormatLine(textsource, 0, 10000.0, new MRATextParagraphProperties(TextCore, textsource), null);
        }
Exemplo n.º 22
0
        protected override void OnRender(DrawingContext drawingContext)
        {
            base.OnRender(drawingContext);
            Rect rect = new Rect(0.0, 0.0, base.ActualWidth, base.ActualHeight);
            JapaneseTextSource source = new JapaneseTextSource();

            source.Text = this.Text;
            JapaneseTextParagraphProperties textParagraphProperties = this.MakeTextProperties();

            source.JapaneseTextRunProperties = (JapaneseTextRunProperties)textParagraphProperties.DefaultTextRunProperties;
            source.IsVarticalWriting         = textParagraphProperties.IsVerticalWriting;
            if (textParagraphProperties.DefaultTextRunProperties.BackgroundBrush != null)
            {
                drawingContext.DrawRectangle(textParagraphProperties.DefaultTextRunProperties.BackgroundBrush, null, rect);
            }
            Rect   paddingRect = new Rect(this.Padding.Left, this.Padding.Top, Math.Max(0.0, base.ActualWidth - this.Padding.Left - this.Padding.Right), Math.Max(0.0, base.ActualHeight - this.Padding.Top - this.Padding.Bottom));
            Point  center      = new Point((paddingRect.Left + paddingRect.Right) / 2.0, (paddingRect.Top + paddingRect.Bottom) / 2.0);
            Point  startPosition;
            double paragraphWidth;

            if (textParagraphProperties.IsVerticalWriting)
            {
                Point     origin      = paddingRect.TopRight;
                Transform transOrigin = new RotateTransform(-90.0, center.X, center.Y);
                startPosition  = transOrigin.Transform(origin);
                paragraphWidth = Math.Abs(paddingRect.Height);
                Transform trans = new RotateTransform(90.0, center.X, center.Y);
                drawingContext.PushTransform(trans);
            }
            else
            {
                startPosition  = paddingRect.TopLeft;
                paragraphWidth = Math.Abs(paddingRect.Width);
            }
            startPosition.Y += textParagraphProperties.JapaneseTextRunProperties.FontRenderingEmSize;
            int           textStorePosition = 0;
            Point         linePosition      = startPosition;
            TextFormatter formatter         = TextFormatter.Create();

            while (textStorePosition < source.Text.Length)
            {
                using (TextLine textLine = formatter.FormatLine(source, textStorePosition, paragraphWidth, textParagraphProperties, null))
                {
                    foreach (IndexedGlyphRun indexedrun in textLine.GetIndexedGlyphRuns())
                    {
                        if (textParagraphProperties.IsVerticalWriting)
                        {
                            source.UniscribeIndexedGlyphRun(indexedrun);
                            Rect runRect;
                            if (source.GlyphCount != 0 && source.Glyphs[0] != 0)
                            {
                                Point ansiLinePosition = linePosition;
                                ansiLinePosition.Y -= textParagraphProperties.JapaneseTextRunProperties.FontRenderingEmSize / 2.0;
                                runRect             = this.DrawIndexedGlyphRun(drawingContext, indexedrun, ansiLinePosition, source, true);
                            }
                            else
                            {
                                Point ansiLinePosition = linePosition;
                                ansiLinePosition.Y -= textParagraphProperties.JapaneseTextRunProperties.FontRenderingEmSize / 10.0;
                                runRect             = this.DrawIndexedGlyphRun(drawingContext, indexedrun, ansiLinePosition, source, false);
                            }
                            linePosition.X += runRect.Width;
                        }
                        else
                        {
                            Rect runRect = this.DrawIndexedGlyphRun(drawingContext, indexedrun, linePosition, source, false);
                            linePosition.X += runRect.Width;
                        }
                    }
                    textStorePosition += textLine.Length;
                    linePosition.X     = startPosition.X;
                    linePosition.Y    += textLine.Height;
                }
            }
            if (textParagraphProperties.IsVerticalWriting)
            {
                drawingContext.Pop();
            }
        }