GetBrush() 공개 정적인 메소드

public static GetBrush ( Color color ) : Brush
color Color
리턴 System.Drawing.Brush
        public void Paint(Graphics g, Rectangle rect)
        {
            if (rect.Width <= 0 || rect.Height <= 0)
            {
                return;
            }

            HighlightColor lineNumberPainterColor = Shared.TEP.LineNumbersColor;
            int            fontHeight             = TextArea._FontHeight;
            Brush          fillBrush = TextArea.Enabled ? BrushRegistry.GetBrush(lineNumberPainterColor.BackgroundColor) : SystemBrushes.InactiveBorder;
            Brush          drawBrush = BrushRegistry.GetBrush(lineNumberPainterColor.Color);

            for (int y = 0; y < (DrawingPosition.Height + TextArea.VisibleLineDrawingRemainder) / fontHeight + 1; ++y)
            {
                int       ypos = DrawingPosition.Y + fontHeight * y - TextArea.VisibleLineDrawingRemainder;
                Rectangle backgroundRectangle = new Rectangle(DrawingPosition.X, ypos, DrawingPosition.Width, fontHeight);
                if (rect.IntersectsWith(backgroundRectangle))
                {
                    g.FillRectangle(fillBrush, backgroundRectangle);
                    int curLine = TextArea.Document.GetFirstLogicalLine(TextArea.Document.GetVisibleLine(TextArea.FirstVisibleLine) + y);

                    if (curLine < TextArea.Document.TotalNumberOfLines)
                    {
                        g.DrawString((curLine + 1).ToString(),
                                     FontRegistry.GetFont(lineNumberPainterColor.Bold, lineNumberPainterColor.Italic),
                                     drawBrush,
                                     backgroundRectangle,
                                     _numberStringFormat);
                    }
                }
            }
        }
예제 #2
0
        void DrawFoldMarker(Graphics g, RectangleF rectangle, bool isOpened, bool isSelected)
        {
            HighlightColor foldMarkerColor  = textArea.Document.HighlightingStrategy.GetColorFor("FoldMarker");
            HighlightColor foldLineColor    = textArea.Document.HighlightingStrategy.GetColorFor("FoldLine");
            HighlightColor selectedFoldLine = textArea.Document.HighlightingStrategy.GetColorFor("SelectedFoldLine");

            Rectangle intRect = new Rectangle((int)rectangle.X, (int)rectangle.Y, (int)rectangle.Width, (int)rectangle.Height);

            g.FillRectangle(BrushRegistry.GetBrush(foldMarkerColor.BackgroundColor), intRect);
            g.DrawRectangle(BrushRegistry.GetPen(isSelected ? selectedFoldLine.Color : foldLineColor.Color), intRect);

            int space = (int)Math.Round(((double)rectangle.Height) / 8d) + 1;
            int mid   = intRect.Height / 2 + intRect.Height % 2;

            // draw minus
            g.DrawLine(BrushRegistry.GetPen(foldMarkerColor.Color),
                       rectangle.X + space,
                       rectangle.Y + mid,
                       rectangle.X + rectangle.Width - space,
                       rectangle.Y + mid);

            // draw plus
            if (!isOpened)
            {
                g.DrawLine(BrushRegistry.GetPen(foldMarkerColor.Color),
                           rectangle.X + mid,
                           rectangle.Y + space,
                           rectangle.X + mid,
                           rectangle.Y + rectangle.Height - space);
            }
        }
예제 #3
0
        public override void Paint(Graphics g, Rectangle rect)
        {
            if (rect.Width <= 0 || rect.Height <= 0)
            {
                return;
            }
            HighlightColor lineNumberPainterColor = textArea.Document.HighlightingStrategy.GetColorFor("LineNumbers");
            int            fontHeight             = textArea.TextView.FontHeight;
            Brush          fillBrush = textArea.Enabled ? BrushRegistry.GetBrush(lineNumberPainterColor.BackgroundColor) : SystemBrushes.InactiveBorder;
            Brush          drawBrush = BrushRegistry.GetBrush(lineNumberPainterColor.Color);

            for (int y = 0; y < (DrawingPosition.Height + textArea.TextView.VisibleLineDrawingRemainder) / fontHeight + 1; ++y)
            {
                int       ypos = drawingPosition.Y + fontHeight * y - textArea.TextView.VisibleLineDrawingRemainder;
                Rectangle backgroundRectangle = new Rectangle(drawingPosition.X, ypos, drawingPosition.Width, fontHeight);
                if (rect.IntersectsWith(backgroundRectangle))
                {
                    g.FillRectangle(fillBrush, backgroundRectangle);
                    int curLine = textArea.Document.GetFirstLogicalLine(textArea.Document.GetVisibleLine(textArea.TextView.FirstVisibleLine) + y);

                    if (curLine < textArea.Document.TotalNumberOfLines)
                    {
                        g.DrawString((curLine + 1).ToString(),
                                     lineNumberPainterColor.Font,
                                     drawBrush,
                                     backgroundRectangle,
                                     numberStringFormat);
                    }
                }
            }
        }
예제 #4
0
        public override void Paint(Graphics g, Rectangle rect)
        {
            if (rect.Width <= 0 || rect.Height <= 0)
            {
                return;
            }

            HighlightColor lineNumberPainterColor = textArea.Document.HighlightingStrategy.GetColorFor("LineNumbers");

            for (int y = 0; y < (DrawingPosition.Height + textArea.TextView.VisibleLineDrawingRemainder) / textArea.TextView.FontHeight + 1; ++y)
            {
                Rectangle markerRectangle = new Rectangle(DrawingPosition.X, DrawingPosition.Top + y * textArea.TextView.FontHeight - textArea.TextView.VisibleLineDrawingRemainder, DrawingPosition.Width, textArea.TextView.FontHeight);

                if (rect.IntersectsWith(markerRectangle))
                {
                    // draw dotted separator line
                    if (textArea.Document.TextEditorProperties.ShowLineNumbers)
                    {
                        g.FillRectangle(BrushRegistry.GetBrush(textArea.Enabled ? lineNumberPainterColor.BackgroundColor : SystemColors.InactiveBorder), markerRectangle);
                        g.DrawLine(BrushRegistry.GetDotPen(lineNumberPainterColor.Color), drawingPosition.X, markerRectangle.Y, drawingPosition.X, markerRectangle.Bottom);
                    }
                    else
                    {
                        g.FillRectangle(BrushRegistry.GetBrush(textArea.Enabled ? lineNumberPainterColor.BackgroundColor : SystemColors.InactiveBorder), markerRectangle);
                    }

                    int currentLine = textArea.Document.GetFirstLogicalLine(textArea.TextView.FirstPhysicalLine + y);

                    if (currentLine < textArea.Document.TotalNumberOfLines)
                    {
                        PaintFoldMarker(g, currentLine, markerRectangle);
                    }
                }
            }
        }
예제 #5
0
        Brush GetBgColorBrush(int lineNumber)
        {
            if (DrawLineMarkerAtLine(lineNumber))
            {
                HighlightColor caretLine = textArea.Document.HighlightingStrategy.GetColorFor("CaretMarker");
                return(BrushRegistry.GetBrush(caretLine.Color));
            }
            HighlightBackground background = (HighlightBackground)textArea.Document.HighlightingStrategy.GetColorFor("Default");

            return(BrushRegistry.GetBrush(background.BackgroundColor));
        }
예제 #6
0
        private Brush GetBgColorBrush(int lineNumber)
        {
            if (this.DrawLineMarkerAtLine(lineNumber))
            {
                HighlightColor colorFor = this.textArea.Document.HighlightingStrategy.GetColorFor("CaretMarker");
                return(BrushRegistry.GetBrush(colorFor.Color));
            }
            HighlightColor highlightColor = this.textArea.Document.HighlightingStrategy.GetColorFor("Default");

            return(BrushRegistry.GetBrush(highlightColor.BackgroundColor));
        }
예제 #7
0
        public static float DrawDocumentWord(Graphics g, string word, PointF position, Font font, Color foreColor)
        {
            if (word == null || word.Length == 0)
            {
                return(0f);
            }
            SizeF sizeF = g.MeasureString(word, font, 32768, DrawableLine.sf);

            g.DrawString(word, font, BrushRegistry.GetBrush(foreColor), position, DrawableLine.sf);
            return(sizeF.Width);
        }
예제 #8
0
        float DrawEOLMarker(Graphics g, Color color, Brush backBrush, float x, float y)
        {
            float width = GetWidth(g, '\u00B6');

            g.FillRectangle(backBrush,
                            new RectangleF(x, y, width, fontHeight));

            HighlightColor eolMarkerColor = textArea.Document.HighlightingStrategy.GetColorFor("EOLMarkers");

            g.DrawString("\u00B6", eolMarkerColor.Font, BrushRegistry.GetBrush(color), x, y, measureStringFormat);
            return(width);
        }
예제 #9
0
 /// <summary>
 /// Get the marker brush (for solid block markers) at a given position.
 /// </summary>
 /// <param name="offset">The offset.</param>
 /// <param name="length">The length.</param>
 /// <param name="markers">All markers that have been found.</param>
 /// <returns>The Brush or null when no marker was found.</returns>
 Brush GetMarkerBrushAt(int offset, int length, out ArrayList markers)
 {
     markers = Document.MarkerStrategy.GetMarkers(offset, length);
     foreach (TextMarker marker in markers)
     {
         if (marker.TextMarkerType == TextMarkerType.SolidBlock)
         {
             return(BrushRegistry.GetBrush(marker.Color));
         }
     }
     return(null);
 }
예제 #10
0
        public static float DrawDocumentWord(Graphics g, string word, PointF position, Font font, Color foreColor)
        {
            if (string.IsNullOrEmpty(word))
            {
                return(0f);
            }

            SizeF wordSize = g.MeasureString(word, font, 32768, sf);

            g.DrawString(word, font, BrushRegistry.GetBrush(foreColor), position, sf);
            return(wordSize.Width);
        }
예제 #11
0
        private int PaintFoldingText(Graphics g, int lineNumber, int physicalXPos, Rectangle lineRectangle, string text, bool drawSelected)
        {
            HighlightColor colorFor    = this.textArea.Document.HighlightingStrategy.GetColorFor("Selection");
            Brush          brush       = (drawSelected ? BrushRegistry.GetBrush(colorFor.BackgroundColor) : this.GetBgColorBrush(lineNumber));
            Brush          brush1      = (this.textArea.Enabled ? brush : SystemBrushes.InactiveBorder);
            Font           regularFont = this.textArea.TextEditorProperties.FontContainer.RegularFont;
            int            num         = this.MeasureStringWidth(g, text, regularFont) + 1;
            Rectangle      rectangle   = new Rectangle(physicalXPos, lineRectangle.Y, num, lineRectangle.Height - 1);

            g.FillRectangle(brush1, rectangle);
            this.physicalColumn += text.Length;
            this.DrawString(g, text, regularFont, (drawSelected ? colorFor.Color : Color.Gray), rectangle.X + 1, rectangle.Y);
            g.DrawRectangle(BrushRegistry.GetPen((drawSelected ? Color.DarkGray : Color.Gray)), rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
            return(physicalXPos + num + 1);
        }
예제 #12
0
 public override void PaintCaret(Graphics g)
 {
     if (blink && visible)
     {
         g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighSpeed;
         if (parentCaret.CaretMode == CaretMode.OverwriteMode)
         {
             g.FillRectangle(BrushRegistry.GetBrush((this.textArea.TextEditorProperties.DarkScheme) ? Color.FromArgb(160, 255, 255, 255) : Color.FromArgb(144, 0, 0, 0)), x + 1, y, width, height);
         }
         else
         {
             g.DrawRectangle((this.textArea.TextEditorProperties.DarkScheme) ? Pens.White : Pens.Black, x, y, width - 1, height);
         }
     }
 }
예제 #13
0
        Brush GetBgColorBrush(int lineNumber)
        {
            if (DrawLineMarkerAtLine(lineNumber))
            {
                HighlightColor caretLine = textArea.Document.HighlightingStrategy.GetColorFor("CaretMarker");
                return(BrushRegistry.GetBrush(caretLine.Color));
            }
            HighlightBackground background = (HighlightBackground)textArea.Document.HighlightingStrategy.GetColorFor("DefaultBackground");
            Color bgColor = background.BackgroundColor;

            if (textArea.MotherTextAreaControl.TextEditorProperties.UseCustomLine == true)
            {
                bgColor = textArea.Document.CustomLineManager.GetCustomColor(lineNumber, bgColor);
            }
            return(BrushRegistry.GetBrush(bgColor));
        }
예제 #14
0
        public override void Paint(Graphics g, Rectangle rect)
        {
            if (rect.Width <= 0 || rect.Height <= 0)
            {
                return;
            }

            HighlightColor lineNumberPainterColor = textArea.Document.HighlightingStrategy.GetColorFor("LineNumbers");
            int            fontHeight             = textArea.TextView.FontHeight;
            Brush          fillBrush = textArea.Enabled ? BrushRegistry.GetBrush(lineNumberPainterColor.BackgroundColor) : SystemBrushes.InactiveBorder;
            Brush          drawBrush = BrushRegistry.GetBrush(lineNumberPainterColor.Color);

            for (int y = 0; y < (DrawingPosition.Height + textArea.TextView.VisibleLineDrawingRemainder) / fontHeight + 1; ++y)
            {
                int       ypos = drawingPosition.Y + fontHeight * y - textArea.TextView.VisibleLineDrawingRemainder;
                Rectangle backgroundRectangle = new Rectangle(drawingPosition.X, ypos, drawingPosition.Width, fontHeight);
                if (rect.IntersectsWith(backgroundRectangle))
                {
                    g.FillRectangle(fillBrush, backgroundRectangle);
                    int curLine = textArea.Document.GetFirstLogicalLine(textArea.Document.GetVisibleLine(textArea.TextView.FirstVisibleLine) + y);

                    if (curLine < textArea.Document.TotalNumberOfLines)
                    {
                        g.DrawString((curLine + 1).ToString(),
                                     lineNumberPainterColor.GetFont(TextEditorProperties.FontContainer),
                                     drawBrush,
                                     backgroundRectangle,
                                     numberStringFormat);

                        if (textArea.Document.LineSegmentCollection[curLine].State == LineState.Modified)
                        {
                            g.FillRectangle(BrushRegistry.GetBrush(Color.FromArgb(255, 238, 98)),
                                            backgroundRectangle.Width + backgroundRectangle.X - 4,
                                            backgroundRectangle.Y, 4, backgroundRectangle.Height);
                        }
                        else if (textArea.Document.LineSegmentCollection[curLine].State == LineState.Saved)
                        {
                            g.FillRectangle(BrushRegistry.GetBrush(Color.FromArgb(108, 226, 108)),
                                            backgroundRectangle.Width + backgroundRectangle.X - 4,
                                            backgroundRectangle.Y, 4, backgroundRectangle.Height);
                        }
                    }
                }
            }
            //g.FillRectangle(BrushRegistry.GetBrush(Color.Black), rect);
        }
        /////
        void DrawLine(Graphics g, LineSegment line, float yPos, RectangleF margin)
        {
            g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAliasGridFit;

            float xPos = 0.0f;

            FontContainer fontContainer = _editor.TextEditorProperties.FontContainer;

            foreach (TextWord word in line.Words)
            {
                switch (word.Type)
                {
                case TextWordType.Space:
                case TextWordType.Tab:
                //TODO2 this blows up throw new NotImplementedException();

                case TextWordType.Word:
                    Font f = word.GetFont(fontContainer);

                    // Check for run off side of page.
                    // Note that MeasureString does not count the same way as DrawString but should be close enough.
                    float reqWidth = _xSpace * word.Word.Length;
                    if (xPos + reqWidth > margin.Width)
                    {
                        Advance(ref xPos, ref yPos, margin.Width, reqWidth, _ySpace);
                    }

                    // Print word one letter at a time to control spacing.
                    for (int i = 0; i < word.Word.Length; i++)
                    {
                        // If bg is not "white" draw a colored rectangle first.
                        if (word.SyntaxColor.BackgroundColor != _hcDef.BackgroundColor)
                        {
                            g.FillRectangle(BrushRegistry.GetBrush(word.SyntaxColor.BackgroundColor),
                                            xPos + margin.X + 2.0f, yPos, _xSpace, f.Height); // have to add 2.0 to start to make bg work?!?
                        }

                        g.DrawString(new string(word.Word[i], 1), f, BrushRegistry.GetBrush(word.SyntaxColor.Color), xPos + margin.X, yPos);

                        xPos += _xSpace;
                    }
                    break;
                }
            }
        }
        private void DrawFoldMarker(Graphics g, RectangleF rectangle, bool isOpened, bool isSelected)
        {
            HighlightColor colorFor       = this.textArea.Document.HighlightingStrategy.GetColorFor("FoldMarker");
            HighlightColor highlightColor = this.textArea.Document.HighlightingStrategy.GetColorFor("FoldLine");
            HighlightColor colorFor1      = this.textArea.Document.HighlightingStrategy.GetColorFor("SelectedFoldLine");
            Rectangle      rectangle1     = new Rectangle((int)rectangle.X, (int)rectangle.Y, (int)rectangle.Width, (int)rectangle.Height);

            g.FillRectangle(BrushRegistry.GetBrush(colorFor.BackgroundColor), rectangle1);
            g.DrawRectangle(BrushRegistry.GetPen((isSelected ? colorFor1.Color : highlightColor.Color)), rectangle1);
            int num    = (int)Math.Round((double)rectangle.Height / 8) + 1;
            int height = rectangle1.Height / 2 + rectangle1.Height % 2;

            g.DrawLine(BrushRegistry.GetPen(colorFor.Color), rectangle.X + (float)num, rectangle.Y + (float)height, rectangle.X + rectangle.Width - (float)num, rectangle.Y + (float)height);
            if (!isOpened)
            {
                g.DrawLine(BrushRegistry.GetPen(colorFor.Color), rectangle.X + (float)height, rectangle.Y + (float)num, rectangle.X + (float)height, rectangle.Y + rectangle.Height - (float)num);
            }
        }
예제 #17
0
        private void DrawMarkerDraw(Graphics g)
        {
            foreach (TextView.MarkerToDraw markerToDraw in this.markersToDraw)
            {
                TextMarker textMarker = markerToDraw.marker;
                RectangleF rectangleF = markerToDraw.drawingRect;
                float      bottom     = rectangleF.Bottom - 1f;
                switch (textMarker.TextMarkerType)
                {
                case TextMarkerType.SolidBlock:
                {
                    g.FillRectangle(BrushRegistry.GetBrush(textMarker.Color), rectangleF);
                    continue;
                }

                case TextMarkerType.Underlined:
                {
                    g.DrawLine(BrushRegistry.GetPen(textMarker.Color), rectangleF.X, bottom, rectangleF.Right, bottom);
                    continue;
                }

                case TextMarkerType.WaveLine:
                {
                    int x = (int)rectangleF.X % 6;
                    for (float i = (float)((int)rectangleF.X - x); i < rectangleF.Right; i += 6f)
                    {
                        g.DrawLine(BrushRegistry.GetPen(textMarker.Color), i, bottom + 3f - 4f, i + 3f, bottom + 1f - 4f);
                        if (i + 3f < rectangleF.Right)
                        {
                            g.DrawLine(BrushRegistry.GetPen(textMarker.Color), i + 3f, bottom + 1f - 4f, i + 6f, bottom + 3f - 4f);
                        }
                    }
                    continue;
                }

                default:
                {
                    continue;
                }
                }
            }
            this.markersToDraw.Clear();
        }
예제 #18
0
        void DrawLine(Graphics g, LineSegment line, float yPos, RectangleF margin)
        {
            float xPos             = 0;
            float fontHeight       = Font.GetHeight(g);
            bool  gotNonWhitespace = false;

            curTabIndent = 0;

            FontContainer fontContainer = TextEditorProperties.FontContainer;

            foreach (TextWord word in line.Words)
            {
                switch (word.Type)
                {
                case TextWordType.Space:
                    Advance(ref xPos, ref yPos, margin.Width, primaryTextArea.TextArea.TextView.SpaceWidth, fontHeight);
                    if (!gotNonWhitespace)
                    {
                        curTabIndent = xPos;
                    }
                    break;

                case TextWordType.Tab:
                    Advance(ref xPos, ref yPos, margin.Width, TabIndent * primaryTextArea.TextArea.TextView.WideSpaceWidth, fontHeight);
                    if (!gotNonWhitespace)
                    {
                        curTabIndent = xPos;
                    }
                    break;

                case TextWordType.Word:
                    if (!gotNonWhitespace)
                    {
                        gotNonWhitespace = true;
//							curTabIndent    += TabIndent * primaryTextArea.TextArea.TextView.GetWidth(' ');
                    }
                    g.DrawString(word.Word, word.GetFont(fontContainer), BrushRegistry.GetBrush(word.Color), xPos + margin.X, yPos);
                    SizeF drawingSize = g.MeasureString(word.Word, word.GetFont(fontContainer), new SizeF(margin.Width, fontHeight * 100), printingStringFormat);
                    Advance(ref xPos, ref yPos, margin.Width, drawingSize.Width, fontHeight);
                    break;
                }
            }
        }
예제 #19
0
        float DrawDocumentWord(Graphics g, string word, PointF position, Font font, Color foreColor, Brush backBrush)
        {
            if (word == null || word.Length == 0)
            {
                return(0f);
            }
            float wordWidth = g.MeasureString(word, font, 32768, measureStringFormat).Width;

            g.FillRectangle(backBrush,
                            new RectangleF(position.X, position.Y, (float)Math.Ceiling(wordWidth), FontHeight));

            g.DrawString(word,
                         font,
                         BrushRegistry.GetBrush(foreColor),
                         position.X,
                         position.Y,
                         measureStringFormat);
            return(wordWidth);
        }
예제 #20
0
파일: GutterMargin.cs 프로젝트: mryp/kkde
        public override void Paint(Graphics g, Rectangle rect)
        {
            if (rect.Width <= 0 || rect.Height <= 0)
            {
                return;
            }
            HighlightColor lineNumberPainterColor = textArea.Document.HighlightingStrategy.GetColorFor("LineNumbers");
            int            fontHeight             = textArea.TextView.FontHeight;
            Brush          fillBrush = textArea.Enabled ? BrushRegistry.GetBrush(lineNumberPainterColor.BackgroundColor) : SystemBrushes.InactiveBorder;
            Brush          drawBrush = BrushRegistry.GetBrush(lineNumberPainterColor.Color);

            //行番号を右揃えにするためのフォーマット作成
            int    figure = textArea.Document.TotalNumberOfLines.ToString().Length + 1;                 //一つ多めにする
            string format = "{0, " + figure.ToString() + "}";

            for (int y = 0; y < (DrawingPosition.Height + textArea.TextView.VisibleLineDrawingRemainder) / fontHeight + 1; ++y)
            {
                int       ypos = drawingPosition.Y + fontHeight * y - textArea.TextView.VisibleLineDrawingRemainder;
                Rectangle backgroundRectangle = new Rectangle(drawingPosition.X, ypos, drawingPosition.Width, fontHeight);
                if (rect.IntersectsWith(backgroundRectangle))
                {
                    g.FillRectangle(fillBrush, backgroundRectangle);
                    int curLine = textArea.Document.GetFirstLogicalLine(textArea.Document.GetVisibleLine(textArea.TextView.FirstVisibleLine) + y);

                    if (curLine < textArea.Document.TotalNumberOfLines)
                    {
                        g.DrawString(String.Format(format, curLine + 1),
                                     lineNumberPainterColor.GetFont(TextEditorProperties.FontContainer),
                                     drawBrush,
                                     backgroundRectangle,
                                     numberStringFormat);
                        //g.DrawString((curLine + 1).ToString(),
                        //             lineNumberPainterColor.GetFont(TextEditorProperties.FontContainer),
                        //             drawBrush,
                        //             backgroundRectangle,
                        //             numberStringFormat);
                    }
                }
            }
        }
예제 #21
0
        public override void Paint(Graphics g, Rectangle rect)
        {
            if (rect.Width <= 0 || rect.Height <= 0)
            {
                return;
            }
            HighlightColor lineNumberPainterColor = textArea.Document.HighlightingStrategy.GetColorFor("LineNumbers");
            int            fontHeight             = textArea.TextView.FontHeight;
            Brush          fillBrush = textArea.Enabled ? BrushRegistry.GetBrush(lineNumberPainterColor.BackgroundColor) : SystemBrushes.InactiveBorder;
            Font           lineFont  = lineNumberPainterColor.GetFont(TextEditorProperties.FontContainer);

            for (int y = 0; y < (DrawingPosition.Height + textArea.TextView.VisibleLineDrawingRemainder) / fontHeight + 1; ++y)
            {
                int       ypos = drawingPosition.Y + fontHeight * y - textArea.TextView.VisibleLineDrawingRemainder;
                Rectangle backgroundRectangle = new Rectangle(drawingPosition.X, ypos, drawingPosition.Width, fontHeight);
                //if (rect.IntersectsWith(backgroundRectangle)) {
                g.FillRectangle(fillBrush, backgroundRectangle);
                int curLine = textArea.Document.GetFirstLogicalLine(textArea.Document.GetVisibleLine(textArea.TextView.FirstVisibleLine) + y);
                if (curLine < textArea.Document.TotalNumberOfLines)
                {
                    Brush drawBrush = (curLine != textArea.Caret.Line)
                                                                                   ? BrushRegistry.GetBrush(lineNumberPainterColor.Color)
                                                                                   : drawBrush = BrushRegistry.GetBrush((textArea.Document.TextEditorProperties.DarkScheme) ? Color.Gold : Color.Blue);
                    g.DrawString((curLine + 1).ToString(),
                                 lineFont,
                                 drawBrush,
                                 backgroundRectangle,
                                 numberStringFormat);
                }
                //}
            }
            if (!textArea.Document.TextEditorProperties.EnableFolding)
            {
                g.DrawLine(BrushRegistry.GetPen(lineNumberPainterColor.Color),
                           rect.X + Size.Width - 3,
                           rect.Y,
                           rect.X + Size.Width - 3,
                           rect.Bottom);
            }
        }
예제 #22
0
        private void DrawLine(Graphics g, LineSegment line, float yPos, RectangleF margin)
        {
            float single = 0f;
            float height = this.Font.GetHeight(g);

            this.curTabIndent = 0f;
            FontContainer fontContainer = base.TextEditorProperties.FontContainer;

            foreach (TextWord word in line.Words)
            {
                switch (word.Type)
                {
                case TextWordType.Word:
                {
                    g.DrawString(word.Word, word.GetFont(fontContainer), BrushRegistry.GetBrush(word.Color), single + margin.X, yPos);
                    SizeF sizeF = g.MeasureString(word.Word, word.GetFont(fontContainer), new SizeF(margin.Width, height * 100f), this.printingStringFormat);
                    this.Advance(ref single, ref yPos, margin.Width, sizeF.Width, height);
                    continue;
                }

                case TextWordType.Space:
                {
                    this.Advance(ref single, ref yPos, margin.Width, (float)this.primaryTextArea.TextArea.TextView.SpaceWidth, height);
                    continue;
                }

                case TextWordType.Tab:
                {
                    this.Advance(ref single, ref yPos, margin.Width, (float)(base.TabIndent * this.primaryTextArea.TextArea.TextView.WideSpaceWidth), height);
                    continue;
                }

                default:
                {
                    continue;
                }
                }
            }
        }
예제 #23
0
        public void Paint(Graphics g, Rectangle rect)
        {
            if (rect.Width <= 0 || rect.Height <= 0)
            {
                return;
            }
            HighlightColor lineNumberPainterColor = Shared.TEP.LineNumbersColor;

            for (int y = 0; y < (DrawingPosition.Height + TextArea.VisibleLineDrawingRemainder) / TextArea._FontHeight + 1; ++y)
            {
                Rectangle markerRectangle = new Rectangle(DrawingPosition.X,
                                                          DrawingPosition.Top + y * TextArea._FontHeight - TextArea.VisibleLineDrawingRemainder,
                                                          DrawingPosition.Width,
                                                          TextArea._FontHeight);

                if (rect.IntersectsWith(markerRectangle))
                {
                    // draw dotted separator line
                    if (Shared.TEP.ShowLineNumbers)
                    {
                        g.FillRectangle(BrushRegistry.GetBrush(TextArea.Enabled ? lineNumberPainterColor.BackgroundColor : SystemColors.InactiveBorder), markerRectangle);

                        g.DrawLine(BrushRegistry.GetDotPen(lineNumberPainterColor.Color), DrawingPosition.X, markerRectangle.Y, DrawingPosition.X, markerRectangle.Bottom);
                    }
                    else
                    {
                        g.FillRectangle(BrushRegistry.GetBrush(TextArea.Enabled ? lineNumberPainterColor.BackgroundColor : SystemColors.InactiveBorder), markerRectangle);
                    }

                    int currentLine = TextArea.Document.GetFirstLogicalLine(TextArea.FirstPhysicalLine + y);
                    if (currentLine < TextArea.Document.TotalNumberOfLines)
                    {
                        PaintFoldMarker(g, currentLine, markerRectangle);
                    }
                }
            }
        }
예제 #24
0
        void DrawMarker(Graphics g, TextMarker marker, RectangleF drawingRect)
        {
            float drawYPos = drawingRect.Bottom - 1;

            switch (marker.TextMarkerType)
            {
            case TextMarkerType.Underlined:
                g.DrawLine(BrushRegistry.GetPen(marker.Color), drawingRect.X, drawYPos, drawingRect.Right, drawYPos);
                break;

            case TextMarkerType.WaveLine:
                int reminder = ((int)drawingRect.X) % 6;
                for (float i = drawingRect.X - reminder; i < drawingRect.Right + reminder; i += 6)
                {
                    g.DrawLine(BrushRegistry.GetPen(marker.Color), i, drawYPos + 3 - 4, i + 3, drawYPos + 1 - 4);
                    g.DrawLine(BrushRegistry.GetPen(marker.Color), i + 3, drawYPos + 1 - 4, i + 6, drawYPos + 3 - 4);
                }
                break;

            case TextMarkerType.SolidBlock:
                g.FillRectangle(BrushRegistry.GetBrush(marker.Color), drawingRect);
                break;
            }
        }
예제 #25
0
        protected override void OnPaintBackground(System.Windows.Forms.PaintEventArgs e)
        {
            //横定規はエディタのデフォルト値を使用する
            HighlightColor color = textArea.Document.HighlightingStrategy.GetColorFor("Default");

            int x = 0;

            if (textArea.TextEditorProperties.IsIconBarVisible)
            {
                x = textArea.IconBarMargin.DrawingPosition.Width;
                if (x != 0)
                {
                    //アイコン表示領域が存在するときはその部分を描画する
                    e.Graphics.FillRectangle(BrushRegistry.GetBrush(SystemColors.Control),
                                             new Rectangle(0, 0, x, Height));
                    e.Graphics.DrawLine(SystemPens.ControlDark, x - 1, 0, x - 1, Height);
                }
            }
            e.Graphics.FillRectangle(BrushRegistry.GetBrush(color.BackgroundColor),
                                     new Rectangle(x,
                                                   0,
                                                   Width,
                                                   Height));
        }
예제 #26
0
        float PaintLinePart(Graphics g, int lineNumber, int startColumn, int endColumn, Rectangle lineRectangle, float physicalXPos)
        {
            bool  drawLineMarker  = DrawLineMarkerAtLine(lineNumber);
            Brush bgColorBrush    = GetBgColorBrush(lineNumber);
            Brush backgroundBrush = textArea.Enabled ? bgColorBrush : SystemBrushes.InactiveBorder;

            HighlightColor selectionColor   = textArea.Document.HighlightingStrategy.GetColorFor("Selection");
            ColumnRange    selectionRange   = textArea.SelectionManager.GetSelectionAtLine(lineNumber);
            HighlightColor tabMarkerColor   = textArea.Document.HighlightingStrategy.GetColorFor("TabMarkers");
            HighlightColor spaceMarkerColor = textArea.Document.HighlightingStrategy.GetColorFor("SpaceMarkers");

            float spaceWidth = GetWidth(g, ' ');

            LineSegment currentLine = textArea.Document.GetLineSegment(lineNumber);

            int logicalColumn = startColumn;

            Brush selectionBackgroundBrush  = BrushRegistry.GetBrush(selectionColor.BackgroundColor);
            Brush unselectedBackgroundBrush = backgroundBrush;

            if (currentLine.Words != null)
            {
                int startword = 0;
                // search the first word after startColumn and update physicalColumn if a word is Tab
                int wordOffset = 0;
                for (; startword < currentLine.Words.Count; ++startword)
                {
                    if (wordOffset >= startColumn)
                    {
                        break;
                    }
                    TextWord currentWord = ((TextWord)currentLine.Words[startword]);
                    if (currentWord.Type == TextWordType.Tab)
                    {
                        ++wordOffset;
                    }
                    else if (currentWord.Type == TextWordType.Space)
                    {
                        ++wordOffset;
                    }
                    else
                    {
                        wordOffset += currentWord.Length;
                    }
                }


                for (int i = startword; i < currentLine.Words.Count; ++i)
                {
                    // if already all words before endColumn are drawen: break
                    if (logicalColumn >= endColumn)
                    {
                        break;
                    }

                    ArrayList markers = Document.MarkerStrategy.GetMarkers(currentLine.Offset + wordOffset);
                    foreach (TextMarker marker in markers)
                    {
                        if (marker.TextMarkerType == TextMarkerType.SolidBlock)
                        {
//							if (unselectedBackgroundBrush != null) {
//								unselectedBackgroundBrush.Dispose();
//							}
                            unselectedBackgroundBrush = BrushRegistry.GetBrush(marker.Color);
                            break;
                        }
                    }
                    // Clear old marker arrary


                    // TODO: cut the word if startColumn or endColimn is in the word;
                    // needed for foldings wich can start or end in the middle of a word
                    TextWord currentWord = ((TextWord)currentLine.Words[i]);
                    switch (currentWord.Type)
                    {
                    case TextWordType.Space:
                        RectangleF spaceRectangle = new RectangleF(physicalXPos, lineRectangle.Y, (float)Math.Ceiling(spaceWidth), lineRectangle.Height);

                        Brush spaceBackgroundBrush;

                        if (ColumnRange.WholeColumn.Equals(selectionRange) || logicalColumn >= selectionRange.StartColumn && logicalColumn < selectionRange.EndColumn)
                        {
                            spaceBackgroundBrush = selectionBackgroundBrush;
                        }
                        else
                        {
                            Brush markerBrush = GetMarkerBrushAt(currentLine.Offset + logicalColumn, 1);
                            if (!drawLineMarker && markerBrush != null)
                            {
                                spaceBackgroundBrush = markerBrush;
                            }
                            else if (!drawLineMarker && currentWord.SyntaxColor != null && currentWord.SyntaxColor.HasBackground)
                            {
                                spaceBackgroundBrush = BrushRegistry.GetBrush(currentWord.SyntaxColor.BackgroundColor);
                            }
                            else
                            {
                                spaceBackgroundBrush = unselectedBackgroundBrush;
                            }
                        }
                        g.FillRectangle(spaceBackgroundBrush, spaceRectangle);

                        if (TextEditorProperties.ShowSpaces)
                        {
                            DrawSpaceMarker(g, spaceMarkerColor.Color, physicalXPos, lineRectangle.Y);
                        }
                        foreach (TextMarker marker in markers)
                        {
                            DrawMarker(g, marker, spaceRectangle);
                        }

                        physicalXPos += spaceWidth;

                        ++logicalColumn;
                        ++physicalColumn;
                        break;

                    case TextWordType.Tab:

                        int oldPhysicalColumn = physicalColumn;
                        physicalColumn += TextEditorProperties.TabIndent;
                        physicalColumn  = (physicalColumn / TextEditorProperties.TabIndent) * TextEditorProperties.TabIndent;
                        float      tabWidth     = (physicalColumn - oldPhysicalColumn) * spaceWidth;
                        RectangleF tabRectangle = new RectangleF(physicalXPos, lineRectangle.Y, (float)Math.Ceiling(tabWidth), lineRectangle.Height);

                        if (ColumnRange.WholeColumn.Equals(selectionRange) || logicalColumn >= selectionRange.StartColumn && logicalColumn <= selectionRange.EndColumn - 1)
                        {
                            spaceBackgroundBrush = selectionBackgroundBrush;
                        }
                        else
                        {
                            Brush markerBrush = GetMarkerBrushAt(currentLine.Offset + logicalColumn, 1);
                            if (!drawLineMarker && markerBrush != null)
                            {
                                spaceBackgroundBrush = markerBrush;
                            }
                            else if (!drawLineMarker && currentWord.SyntaxColor != null && currentWord.SyntaxColor.HasBackground)
                            {
                                spaceBackgroundBrush = BrushRegistry.GetBrush(currentWord.SyntaxColor.BackgroundColor);
                            }
                            else
                            {
                                spaceBackgroundBrush = unselectedBackgroundBrush;
                            }
                        }
                        g.FillRectangle(spaceBackgroundBrush, tabRectangle);

                        if (TextEditorProperties.ShowTabs)
                        {
                            DrawTabMarker(g, tabMarkerColor.Color, physicalXPos, lineRectangle.Y);
                        }

                        foreach (TextMarker marker in markers)
                        {
                            DrawMarker(g, marker, tabRectangle);
                        }

                        physicalXPos += tabWidth;

                        ++logicalColumn;
                        break;

                    case TextWordType.Word:
                        string word    = currentWord.Word;
                        float  lastPos = physicalXPos;

                        Brush bgMarkerBrush = GetMarkerBrushAt(currentLine.Offset + logicalColumn, word.Length);
                        Brush wordBackgroundBrush;
                        if (!drawLineMarker && bgMarkerBrush != null)
                        {
                            wordBackgroundBrush = bgMarkerBrush;
                        }
                        else if (!drawLineMarker && currentWord.SyntaxColor.HasBackground)
                        {
                            wordBackgroundBrush = BrushRegistry.GetBrush(currentWord.SyntaxColor.BackgroundColor);
                        }
                        else
                        {
                            wordBackgroundBrush = unselectedBackgroundBrush;
                        }


                        if (ColumnRange.WholeColumn.Equals(selectionRange) || selectionRange.EndColumn - 1 >= word.Length + logicalColumn &&
                            selectionRange.StartColumn <= logicalColumn)
                        {
                            physicalXPos += DrawDocumentWord(g,
                                                             word,
                                                             new PointF(physicalXPos, lineRectangle.Y),
                                                             currentWord.Font,
                                                             selectionColor.HasForgeground ? selectionColor.Color : currentWord.Color,
                                                             selectionBackgroundBrush);
                        }
                        else
                        {
                            if (ColumnRange.NoColumn.Equals(selectionRange) /* || selectionRange.StartColumn > logicalColumn + word.Length || selectionRange.EndColumn  - 1 <= logicalColumn */)
                            {
                                physicalXPos += DrawDocumentWord(g,
                                                                 word,
                                                                 new PointF(physicalXPos, lineRectangle.Y),
                                                                 currentWord.Font,
                                                                 currentWord.Color,
                                                                 wordBackgroundBrush);
                            }
                            else
                            {
                                int offset1 = Math.Min(word.Length, Math.Max(0, selectionRange.StartColumn - logicalColumn));
                                int offset2 = Math.Max(offset1, Math.Min(word.Length, selectionRange.EndColumn - logicalColumn));

                                physicalXPos += DrawDocumentWord(g,
                                                                 word.Substring(0, offset1),
                                                                 new PointF(physicalXPos, lineRectangle.Y),
                                                                 currentWord.Font,
                                                                 currentWord.Color,
                                                                 wordBackgroundBrush);

                                physicalXPos += DrawDocumentWord(g,
                                                                 word.Substring(offset1, offset2 - offset1),
                                                                 new PointF(physicalXPos, lineRectangle.Y),
                                                                 currentWord.Font,
                                                                 selectionColor.HasForgeground ? selectionColor.Color : currentWord.Color,
                                                                 selectionBackgroundBrush);

                                physicalXPos += DrawDocumentWord(g,
                                                                 word.Substring(offset2),
                                                                 new PointF(physicalXPos, lineRectangle.Y),
                                                                 currentWord.Font,
                                                                 currentWord.Color,
                                                                 wordBackgroundBrush);
                            }
                        }
//							if (markerBrush != null) {
//								markerBrush.Dispose();
//							}
                        foreach (TextMarker marker in markers)
                        {
                            if (marker.TextMarkerType != TextMarkerType.SolidBlock)
                            {
                                DrawMarker(g, marker, new RectangleF(lastPos, lineRectangle.Y, (physicalXPos - lastPos), lineRectangle.Height));
                            }
                        }

                        // draw bracket highlight
                        if (highlight != null)
                        {
                            if (highlight.OpenBrace.Y == lineNumber && highlight.OpenBrace.X == logicalColumn ||
                                highlight.CloseBrace.Y == lineNumber && highlight.CloseBrace.X == logicalColumn)
                            {
                                DrawBracketHighlight(g, new Rectangle((int)lastPos, lineRectangle.Y, (int)(physicalXPos - lastPos) - 1, lineRectangle.Height - 1));
                            }
                        }
                        physicalColumn += word.Length;
                        logicalColumn  += word.Length;
                        break;
                    }
                    markers.Clear();
                }
            }

//			if (bgColorBrush != null) {
//				bgColorBrush.Dispose();
//				bgColorBrush = null;
//			}
//
//			if (selectionBackgroundBrush != null) {
//				selectionBackgroundBrush.Dispose();
//				selectionBackgroundBrush = null;
//			}
//
//			if (unselectedBackgroundBrush != null) {
//				unselectedBackgroundBrush.Dispose();
//				unselectedBackgroundBrush = null;
//			}

            return(physicalXPos);
        }
예제 #27
0
        void PaintDocumentLine(Graphics g, int lineNumber, Rectangle lineRectangle)
        {
            Debug.Assert(lineNumber >= 0);
            Brush bgColorBrush    = GetBgColorBrush(lineNumber);
            Brush backgroundBrush = textArea.Enabled ? bgColorBrush : SystemBrushes.InactiveBorder;

            if (lineNumber >= textArea.Document.TotalNumberOfLines)
            {
                g.FillRectangle(backgroundBrush, lineRectangle);
                if (TextEditorProperties.ShowInvalidLines)
                {
                    DrawInvalidLineMarker(g, lineRectangle.Left, lineRectangle.Top);
                }
                if (TextEditorProperties.ShowVerticalRuler)
                {
                    DrawVerticalRuler(g, lineRectangle);
                }
//				bgColorBrush.Dispose();
                return;
            }

            float physicalXPos = lineRectangle.X;
            // there can't be a folding wich starts in an above line and ends here, because the line is a new one,
            // there must be a return before this line.
            int column = 0;

            physicalColumn = 0;
            if (TextEditorProperties.EnableFolding)
            {
                while (true)
                {
                    ArrayList starts = textArea.Document.FoldingManager.GetFoldedFoldingsWithStartAfterColumn(lineNumber, column - 1);
                    if (starts == null || starts.Count <= 0)
                    {
                        if (lineNumber < textArea.Document.TotalNumberOfLines)
                        {
                            physicalXPos = PaintLinePart(g, lineNumber, column, textArea.Document.GetLineSegment(lineNumber).Length, lineRectangle, physicalXPos);
                        }
                        break;
                    }
                    // search the first starting folding
                    FoldMarker firstFolding = (FoldMarker)starts[0];
                    foreach (FoldMarker fm in starts)
                    {
                        if (fm.StartColumn < firstFolding.StartColumn)
                        {
                            firstFolding = fm;
                        }
                    }
                    starts.Clear();

                    physicalXPos = PaintLinePart(g, lineNumber, column, firstFolding.StartColumn, lineRectangle, physicalXPos);
                    column       = firstFolding.EndColumn;
                    lineNumber   = firstFolding.EndLine;

                    ColumnRange selectionRange2 = textArea.SelectionManager.GetSelectionAtLine(lineNumber);
                    bool        drawSelected    = ColumnRange.WholeColumn.Equals(selectionRange2) || firstFolding.StartColumn >= selectionRange2.StartColumn && firstFolding.EndColumn <= selectionRange2.EndColumn;

                    physicalXPos = PaintFoldingText(g, lineNumber, physicalXPos, lineRectangle, firstFolding.FoldText, drawSelected);
                }
            }
            else
            {
                physicalXPos = PaintLinePart(g, lineNumber, 0, textArea.Document.GetLineSegment(lineNumber).Length, lineRectangle, physicalXPos);
            }

            if (lineNumber < textArea.Document.TotalNumberOfLines)
            {
                // Paint things after end of line
                ColumnRange    selectionRange = textArea.SelectionManager.GetSelectionAtLine(lineNumber);
                LineSegment    currentLine    = textArea.Document.GetLineSegment(lineNumber);
                HighlightColor selectionColor = textArea.Document.HighlightingStrategy.GetColorFor("Selection");

                float spaceWidth         = GetWidth(g, ' ');
                bool  selectionBeyondEOL = selectionRange.EndColumn > currentLine.Length || ColumnRange.WholeColumn.Equals(selectionRange);

                if (TextEditorProperties.ShowEOLMarker)
                {
                    HighlightColor eolMarkerColor = textArea.Document.HighlightingStrategy.GetColorFor("EOLMarkers");
                    physicalXPos += DrawEOLMarker(g, eolMarkerColor.Color, selectionBeyondEOL ? bgColorBrush : backgroundBrush, physicalXPos, lineRectangle.Y);
                }
                else
                {
                    if (selectionBeyondEOL)
                    {
                        g.FillRectangle(BrushRegistry.GetBrush(selectionColor.BackgroundColor), new RectangleF(physicalXPos, lineRectangle.Y, spaceWidth, lineRectangle.Height));
                        physicalXPos += spaceWidth;
                    }
                }

                Brush fillBrush = selectionBeyondEOL && TextEditorProperties.AllowCaretBeyondEOL ? bgColorBrush : backgroundBrush;
                g.FillRectangle(fillBrush,
                                new RectangleF(physicalXPos, lineRectangle.Y, lineRectangle.Width - physicalXPos + lineRectangle.X, lineRectangle.Height));
            }
            if (TextEditorProperties.ShowVerticalRuler)
            {
                DrawVerticalRuler(g, lineRectangle);
            }
//			bgColorBrush.Dispose();
        }
예제 #28
0
        void DrawTabMarker(Graphics g, Color color, float x, float y)
        {
            HighlightColor tabMarkerColor = textArea.Document.HighlightingStrategy.GetColorFor("TabMarkers");

            g.DrawString("\u00BB", tabMarkerColor.Font, BrushRegistry.GetBrush(color), x, y, measureStringFormat);
        }
예제 #29
0
        void DrawInvalidLineMarker(Graphics g, float x, float y)
        {
            HighlightColor invalidLinesColor = textArea.Document.HighlightingStrategy.GetColorFor("InvalidLines");

            g.DrawString("~", invalidLinesColor.Font, BrushRegistry.GetBrush(invalidLinesColor.Color), x, y, measureStringFormat);
        }
예제 #30
0
 void DrawBracketHighlight(Graphics g, Rectangle rect)
 {
     g.FillRectangle(BrushRegistry.GetBrush(Color.FromArgb(50, 0, 0, 255)), rect);
     g.DrawRectangle(Pens.Blue, rect);
 }