protected override bool OnDrawn(Cairo.Context cr)
{
double step_width = Allocation.Width / (double)steps;
double step_height = Allocation.Height / (double)steps;
double h = 1.0;
double s = 0.0;
for (int xi = 0, i = 0; xi < steps; xi++) {
for (int yi = 0; yi < steps; yi++, i++) {
double bg_b = (double)(i / 255.0);
double fg_b = 1.0 - bg_b;
double x = xi * step_width;
double y = yi * step_height;
cr.Rectangle (x, y, step_width, step_height);
cr.SetSourceColor (CairoExtensions.ColorFromHsb (h, s, bg_b));
cr.Fill ();
int tw, th;
Pango.Layout layout = new Pango.Layout (PangoContext);
layout.SetText (((int)(bg_b * 255.0)).ToString ());
layout.GetPixelSize (out tw, out th);
cr.Translate (0.5, 0.5);
cr.MoveTo (x + (step_width - tw) / 2.0, y + (step_height - th) / 2.0);
cr.SetSourceColor (CairoExtensions.ColorFromHsb (h, s, fg_b));
Pango.CairoHelper.ShowLayout (cr, layout);
cr.Translate (-0.5, -0.5);
}
}
return true;
}
public override void DrawFrameBorder(Cairo.Context cr, Gdk.Rectangle alloc)
{
if (IsPanelWidget) {
return;
} else if (!IsSourceViewWidget) {
base.DrawFrameBorder (cr, alloc);
return;
}
cr.SetSourceColor (TextMidColor);
cr.LineWidth = 1.0;
cr.Antialias = Cairo.Antialias.None;
cr.MoveTo (alloc.Right - 1, alloc.Top);
cr.LineTo (alloc.Right - 1, alloc.Bottom);
cr.Stroke ();
if (Widget.Allocation.Bottom < Widget.Toplevel.Allocation.Height) {
cr.MoveTo (alloc.Left, alloc.Bottom - 1);
cr.LineTo (alloc.Right, alloc.Bottom - 1);
cr.Stroke ();
}
cr.Antialias = Cairo.Antialias.Default;
}
protected override bool OnDrawn(Cairo.Context cr)
{
bool ret = true;
var rect = this.Allocation;
if (rect.Width > 0 && rect.Height > 0)
{
var arrowWidth = popupButton.Allocation.Width;
var arrowPos = rect.Width - arrowWidth;
var arrowSize = 10;
StyleContext.Save();
StyleContext.AddClass("entry");
StyleContext.RenderBackground(cr, 0, 0, rect.Width, rect.Height);
ret = base.OnDrawn(cr);
StyleContext.RenderArrow(cr, Math.PI, arrowPos, (rect.Height - arrowSize) / 2, arrowSize);
cr.SetSourceColor(new Cairo.Color(.8, .8, .8));
cr.Rectangle(arrowPos - 5, 2, 1, rect.Height - 4);
cr.Fill();
Entry.StyleContext.RenderFrame(cr, 0, 0, rect.Width, rect.Height);
StyleContext.Restore();
}
return ret;
}
internal protected override void Draw (Cairo.Context cr, Cairo.Rectangle area, DocumentLine lineSegment, int line, double x, double y, double lineHeight)
{
cr.MoveTo (x + 0.5, y);
cr.LineTo (x + 0.5, y + lineHeight);
cr.SetSourceColor (color);
cr.Stroke ();
}
public override bool DrawBackground (TextEditor editor, Cairo.Context cr, double y, LineMetrics metrics)
{
if (metrics.SelectionStart > 0)
return true;
cr.SetSourceColor (color);
cr.Rectangle (metrics.TextRenderStartPosition, y, metrics.TextRenderEndPosition - metrics.TextRenderStartPosition, editor.LineHeight);
cr.Fill ();
return true;
}
void DrawMarginBackground (Cairo.Context cr, int line, double x, double y, double lineHeight)
{
if (editor.Caret.Line == line) {
editor.TextViewMargin.DrawCaretLineMarker (cr, x, y, Width, lineHeight);
return;
}
cr.Rectangle (x, y, Width, lineHeight);
cr.SetSourceColor (editor.ColorStyle.LineNumbers.Background);
cr.Fill ();
}
public override void DrawFrameBackground(Cairo.Context cr, Gdk.Rectangle alloc, Cairo.Color color, Cairo.Pattern pattern)
{
color.A = Context.FillAlpha;
if (pattern != null) {
cr.SetSource (pattern);
} else {
cr.SetSourceColor (color);
}
CairoExtensions.RoundedRectangle (cr, alloc.X, alloc.Y, alloc.Width, alloc.Height, Context.Radius, CairoCorners.All);
cr.Fill ();
}
void DrawHand(double fThickness, double length, Cairo.Color color, double radians, Cairo.Context e)
{
e.MoveTo(new Cairo.PointD(center.X - (length / 9 * Math.Sin(radians)), center.Y + (length / 9 * Math.Cos(radians))));
e.LineTo(new Cairo.PointD(center.X + (length * Math.Sin(radians)), center.Y - (length * Math.Cos(radians))));
e.ClosePath();
e.LineCap = Cairo.LineCap.Round;
e.LineJoin = Cairo.LineJoin.Round;
e.SetSourceColor(color);
e.LineWidth = fThickness;
e.Stroke();
}
public override void Draw (Mono.TextEditor.MonoTextEditor editor, Cairo.Context cr, LineMetrics metrics, int startOffset, int endOffset)
{
this.editor = editor;
var line = editor.GetLine (loc.Line);
if (line == null)
return;
var x = editor.ColumnToX (line, loc.Column) - editor.HAdjustment.Value + editor.TextViewMargin.XOffset + editor.TextViewMargin.TextStartPosition;
cr.Rectangle (Math.Floor (x), Math.Floor (metrics.LineYRenderStartPosition) + (line == editor.GetLineByOffset (startOffset) ? editor.LineHeight - tagMarkerHeight : 0), tagMarkerWidth, tagMarkerHeight);
cr.SetSourceColor ((HslColor.Brightness (editor.ColorStyle.PlainText.Background) < 0.5 ? Ide.Gui.Styles.Editor.SmartTagMarkerColorDark : Ide.Gui.Styles.Editor.SmartTagMarkerColorLight).ToCairoColor ());
cr.Fill ();
}
protected virtual void DrawBar (Cairo.Context cr)
{
if (vadjustment == null || vadjustment.Upper <= vadjustment.PageSize)
return;
double x, y, w, h;
GetBarDimensions (out x, out y, out w, out h);
if (Platform.IsWindows) {
cr.Rectangle (x, y, w, h);
} else {
MonoDevelop.Components.CairoExtensions.RoundedRectangle (cr, x, y, w, h, 4);
}
bool prelight = State == StateType.Prelight;
Cairo.Color c;
if (Platform.IsWindows) {
c = prelight ? win81SliderPrelight : win81Slider;
//compute new color such that it will produce same color when blended with bg
c = AddAlpha (win81Background, c, 0.5d);
} else {
c = new Cairo.Color (0, 0, 0, (prelight ? 50.0 : 22.0) / 255);
}
cr.SetSourceColor (c);
cr.Fill ();
}
protected Severity DrawQuickTasks (Cairo.Context cr)
{
Severity severity = Severity.None;
/*
foreach (var usage in AllUsages) {
double y = GetYPosition (usage.Line);
var usageColor = TextEditor.ColorStyle.PlainText.Foreground;
usageColor.A = 0.4;
cr.Color = usageColor;
cr.MoveTo (0, y - 3);
cr.LineTo (5, y);
cr.LineTo (0, y + 3);
cr.ClosePath ();
cr.Fill ();
}
*/
foreach (var task in AllTasks) {
double y = GetYPosition (task.Location.Line);
cr.SetSourceColor (GetBarColor (task.Severity));
cr.Rectangle (0, Math.Round (y) - 1, Allocation.Width, 2);
cr.Fill ();
switch (task.Severity) {
case Severity.Error:
severity = Severity.Error;
break;
case Severity.Warning:
if (severity == Severity.None)
severity = Severity.Warning;
break;
}
}
return severity;
}
void DrawIndicator (Cairo.Context cr, Cairo.Color color, Cairo.Color borderColor)
{
var width = Allocation.Width;
int diameter = Math.Min (width, (int)IndicatorHeight) - indicatorPadding * 2;
var x1 = Math.Round (width / 2d);
double y1 = indicatorPadding + diameter / 2;
if (diameter % 2 == 0) {
x1 += 0.5;
y1 += 0.5;
}
cr.Arc (x1, y1, diameter / 2d, 0, 2 * Math.PI);
if (Platform.IsWindows) {
using (var pattern = new Cairo.SolidPattern (color)) {
cr.SetSource (pattern);
cr.FillPreserve ();
}
} else {
using (var pattern = new Cairo.RadialGradient (x1, y1, width / 2, x1 - width, y1 - width, width)) {
pattern.AddColorStop (0, borderColor);
pattern.AddColorStop (1, color);
cr.SetSource (pattern);
cr.FillPreserve ();
}
}
cr.SetSourceColor (borderColor);
cr.Stroke ();
}
public override void Draw (Cairo.Context cr, Cairo.Rectangle erea)
{
TextEditor editor = mode.editor;
double y = editor.LineToY (mode.CurrentInsertionPoint.Line) - editor.VAdjustment.Value;
double x = GetLineIndentationStart ();
double x2 = editor.Allocation.Width - mode.HelpWindow.Allocation.Width - InsertionCursorEditMode.HelpWindowMargin * 2;
cr.MoveTo (x, y);
cr.LineTo (x2, y);
cr.SetSourceColor (LineColor);
cr.Stroke ();
// DrawArrow (cr, x - 4, y);
}
public override bool DrawBackground (TextEditor editor, Cairo.Context g, double y, LineMetrics metrics)
{
if (!IsVisible)
return false;
bool markerShouldDrawnAsHidden = cache.CurrentSelectedTextMarker != null && cache.CurrentSelectedTextMarker != this;
if (metrics.LineSegment.Markers.Any (m => m is DebugTextMarker))
return false;
EnsureLayoutCreated (editor);
double x = editor.TextViewMargin.XOffset;
int right = editor.Allocation.Width;
bool isCaretInLine = metrics.TextStartOffset <= editor.Caret.Offset && editor.Caret.Offset <= metrics.TextEndOffset;
int errorCounterWidth = GetErrorCountBounds (metrics).Item1;
double x2 = System.Math.Max (right - LayoutWidth - border - (ShowIconsInBubble ? cache.errorPixbuf.Width : 0) - errorCounterWidth, editor.TextViewMargin.XOffset + editor.LineHeight / 2);
bool isEolSelected = editor.IsSomethingSelected && editor.SelectionMode != Mono.TextEditor.SelectionMode.Block ? editor.SelectionRange.Contains (lineSegment.Offset + lineSegment.Length) : false;
int active = editor.Document.GetTextAt (lineSegment) == initialText ? 0 : 1;
bool highlighted = active == 0 && isCaretInLine;
// draw background
if (!markerShouldDrawnAsHidden) {
DrawRectangle (g, x, y, right, editor.LineHeight);
g.SetSourceColor (LineColor.Color);
g.Fill ();
if (metrics.Layout.StartSet || metrics.SelectionStart == metrics.TextEndOffset) {
double startX;
double endX;
if (metrics.SelectionStart != metrics.TextEndOffset) {
var start = metrics.Layout.Layout.IndexToPos ((int)metrics.Layout.SelectionStartIndex);
startX = (int)(start.X / Pango.Scale.PangoScale);
var end = metrics.Layout.Layout.IndexToPos ((int)metrics.Layout.SelectionEndIndex);
endX = (int)(end.X / Pango.Scale.PangoScale);
} else {
startX = x2;
endX = startX;
}
if (editor.MainSelection.SelectionMode == Mono.TextEditor.SelectionMode.Block && startX == endX)
endX = startX + 2;
startX += metrics.TextRenderStartPosition;
endX += metrics.TextRenderStartPosition;
startX = Math.Max (editor.TextViewMargin.XOffset, startX);
// clip region to textviewmargin start
if (isEolSelected)
endX = editor.Allocation.Width + (int)editor.HAdjustment.Value;
if (startX < endX) {
DrawRectangle (g, startX, y, endX - startX, editor.LineHeight);
g.SetSourceColor (GetLineColor (highlighted, true));
g.Fill ();
}
}
DrawErrorMarkers (editor, g, metrics, y);
}
double y2 = y + 0.5;
double y2Bottom = y2 + editor.LineHeight - 1;
var selected = isEolSelected;
var lineTextPx = editor.TextViewMargin.XOffset + editor.TextViewMargin.TextStartPosition + metrics.Layout.Width;
if (x2 < lineTextPx)
x2 = lineTextPx;
if (editor.Options.ShowRuler) {
double divider = Math.Max (editor.TextViewMargin.XOffset, x + editor.TextViewMargin.RulerX);
if (divider >= x2) {
g.MoveTo (new Cairo.PointD (divider + 0.5, y2));
g.LineTo (new Cairo.PointD (divider + 0.5, y2Bottom));
g.SetSourceColor (GetLineColorBorder (highlighted, selected));
g.Stroke ();
}
}
return true;
}
void DrawIconMarginBackground (TextEditor ed, Cairo.Context cr, MarginDrawMetrics metrics)
{
cr.Rectangle (metrics.X, metrics.Y, metrics.Width, metrics.Height);
cr.SetSourceColor (IconMarginColor.Color);
cr.Fill ();
cr.MoveTo (metrics.Right - 0.5, metrics.Y);
cr.LineTo (metrics.Right - 0.5, metrics.Bottom);
cr.SetSourceColor (IconMarginColor.BorderColor);
cr.Stroke ();
if (cache.CurrentSelectedTextMarker != null && cache.CurrentSelectedTextMarker != this) {
cr.Rectangle (metrics.X, metrics.Y, metrics.Width, metrics.Height);
cr.SetSourceRGBA (ed.ColorStyle.IndicatorMargin.Color.R, ed.ColorStyle.IndicatorMargin.Color.G, ed.ColorStyle.IndicatorMargin.Color.B, 0.5);
cr.Fill ();
}
}
protected override void OnDrawContent (Gdk.EventExpose evnt, Cairo.Context g)
{
g.Rectangle (0, 0, Allocation.Width, Allocation.Height);
g.SetSourceColor (marker.TooltipColor.Color);
g.Fill ();
using (var drawingLayout = new Pango.Layout (this.PangoContext)) {
drawingLayout.FontDescription = cache.tooltipFontDescription;
double y = verticalTextBorder;
var showBulletedList = marker.Errors.Count > 1;
foreach (var msg in marker.Errors) {
var icon = msg.IsError ? errorPixbuf : warningPixbuf;
int w, h;
if (!showBulletedList)
drawingLayout.Width = maxTextWidth;
drawingLayout.SetText (GetFirstLine (msg));
drawingLayout.GetPixelSize (out w, out h);
if (showBulletedList) {
g.Save ();
g.Translate (textBorder, y + verticalTextSpace / 2 + Math.Max (0, (h - icon.Height) / 2));
g.DrawImage (this, icon, 0, 0);
g.Restore ();
}
g.Save ();
g.Translate (showBulletedList ? textBorder + iconTextSpacing + icon.Width: textBorder, y + verticalTextSpace / 2);
g.SetSourceColor (marker.TagColor.SecondColor);
g.ShowLayout (drawingLayout);
g.Restore ();
y += h + verticalTextSpace;
}
}
}
public override void DrawAfterEol (TextEditor textEditor, Cairo.Context g, double y, EndOfLineMetrics metrics)
{
if (!IsVisible)
return;
EnsureLayoutCreated (editor);
int errorCounterWidth = 0, eh = 0;
if (errorCountLayout != null) {
errorCountLayout.GetPixelSize (out errorCounterWidth, out eh);
errorCounterWidth = Math.Max (15, Math.Max (errorCounterWidth + 3, (int)(editor.LineHeight * 3 / 4)));
}
var sx = metrics.TextRenderEndPosition;
var width = LayoutWidth + errorCounterWidth + editor.LineHeight;
var drawLayout = layouts[0].Layout;
int ex = 0 , ey = 0;
bool customLayout = true; //sx + width > editor.Allocation.Width;
bool hideText = false;
bubbleIsReduced = customLayout;
var showErrorCount = errorCounterWidth > 0 && errorCountLayout != null;
if (customLayout) {
width = editor.Allocation.Width - sx;
string text = layouts[0].Layout.Text;
drawLayout = new Pango.Layout (editor.PangoContext);
drawLayout.FontDescription = cache.fontDescription;
var paintWidth = (width - errorCounterWidth - editor.LineHeight + 4);
var minWidth = Math.Max (17, errorCounterWidth) + editor.LineHeight;
if (paintWidth < minWidth) {
hideText = true;
drawLayout.SetMarkup ("<span weight='heavy'>···</span>");
width = minWidth;
showErrorCount = false;
sx = Math.Min (sx, editor.Allocation.Width - width);
} else {
drawLayout.Ellipsize = Pango.EllipsizeMode.End;
drawLayout.Width = (int)(paintWidth * Pango.Scale.PangoScale);
drawLayout.SetText (text);
int w2, h2;
drawLayout.GetPixelSize (out w2, out h2);
width = w2 + errorCounterWidth + editor.LineHeight;
}
}
bubbleDrawX = sx - editor.TextViewMargin.XOffset;
bubbleDrawY = y;
bubbleWidth = width;
var bubbleHeight = editor.LineHeight - 1;
g.RoundedRectangle (sx, y + 1, width, bubbleHeight, editor.LineHeight / 2 - 1);
g.SetSourceColor (TagColor.Color);
g.Fill ();
// Draw error count icon
if (showErrorCount) {
var errorCounterHeight = bubbleHeight - 2;
var errorCounterX = sx + width - errorCounterWidth - 3;
var errorCounterY = y + 1 + (bubbleHeight - errorCounterHeight) / 2;
g.RoundedRectangle (
errorCounterX - 1,
errorCounterY - 1,
errorCounterWidth + 2,
errorCounterHeight + 2,
editor.LineHeight / 2 - 3
);
g.SetSourceColor (new Cairo.Color (0, 0, 0, 0.081));
g.Fill ();
g.RoundedRectangle (
errorCounterX,
errorCounterY,
errorCounterWidth,
errorCounterHeight,
editor.LineHeight / 2 - 3
);
using (var lg = new Cairo.LinearGradient (errorCounterX, errorCounterY, errorCounterX, errorCounterY + errorCounterHeight)) {
lg.AddColorStop (0, CounterColor.Color);
lg.AddColorStop (1, CounterColor.Color.AddLight (-0.1));
g.Pattern = lg;
g.Fill ();
}
g.Save ();
int ew;
errorCountLayout.GetPixelSize (out ew, out eh);
g.Translate (
errorCounterX + (errorCounterWidth - ew) / 2,
errorCounterY + (errorCounterHeight - eh) / 2
);
g.SetSourceColor (CounterColor.SecondColor);
g.ShowLayout (errorCountLayout);
g.Restore ();
}
// Draw label text
if (!showErrorCount || !hideText) {
g.Save ();
g.Translate (sx + editor.LineHeight / 2, y + (editor.LineHeight - layouts [0].Height) / 2 + 1);
// draw shadow
g.SetSourceColor (MessageBubbleCache.ShadowColor);
g.ShowLayout (drawLayout);
g.Translate (0, -1);
g.SetSourceColor (TagColor.SecondColor);
g.ShowLayout (drawLayout);
g.Restore ();
}
if (customLayout)
drawLayout.Dispose ();
}
public void DrawCaretLineMarker (Cairo.Context cr, double xPos, double y, double width, double lineHeight)
{
if (BackgroundRenderer != null)
return;
xPos = System.Math.Floor (xPos);
cr.Rectangle (xPos, y, width, lineHeight);
var color = CurrentLineColor;
cr.SetSourceColor (color.Color);
cr.Fill ();
double halfLine = (cr.LineWidth / 2.0);
cr.MoveTo (xPos, y + halfLine);
cr.LineTo (xPos + width, y + halfLine);
cr.MoveTo (xPos, y + lineHeight - halfLine);
cr.LineTo (xPos + width, y + lineHeight - halfLine);
cr.SetSourceColor (color.SecondColor);
cr.Stroke ();
}
bool DrawMarginBackground (TextEditor e, Margin margin, Cairo.Context cr, Cairo.Rectangle area, DocumentLine documentLine, long line, double x, double y, double lineHeight)
{
if (cache.CurrentSelectedTextMarker != null && cache.CurrentSelectedTextMarker != this)
return false;
cr.Rectangle (x, y, margin.Width, lineHeight);
cr.SetSourceColor (LineColor.Color);
cr.Fill ();
return true;
}
void DrawIndent (Cairo.Context cr, LayoutWrapper layout, DocumentLine line, double xPos, double y)
{
if (!textEditor.Options.DrawIndentationMarkers)
return;
if (line.Length == 0) {
var nextLine = line.NextLine;
while (nextLine != null && nextLine.Length == 0)
nextLine = nextLine.NextLine;
if (nextLine != null)
layout = GetLayout (nextLine);
}
if (layout.IndentSize == 0)
return;
cr.Save ();
var dotted = new [] { textEditor.Options.Zoom };
cr.SetDash (dotted, (int)y + textEditor.VAdjustment.Value);
var top = y;
var bottom = y + LineHeight;
if (Caret.Line == line.LineNumber && textEditor.GetTextEditorData ().HighlightCaretLine) {
top += textEditor.Options.Zoom;
bottom -= textEditor.Options.Zoom;
}
for (int i = 0; i < layout.IndentSize; i += textEditor.Options.IndentationSize) {
var x = System.Math.Floor (xPos + i * charWidth);
cr.MoveTo (x + 0.5, top);
cr.LineTo (x + 0.5, bottom);
cr.SetSourceColor (ColorStyle.IndentationGuide.Color);
cr.Stroke ();
}
cr.Restore ();
}
void DrawErrorMarkers (TextEditor editor, Cairo.Context g, LineMetrics metrics, double y)
{
uint curIndex = 0, byteIndex = 0;
var o = metrics.LineSegment.Offset;
foreach (var task in errors.Select (t => t.Task)) {
var column = (uint)(Math.Min (Math.Max (0, task.Column - 1), metrics.Layout.LineChars.Length));
int index = (int)metrics.Layout.TranslateToUTF8Index (column, ref curIndex, ref byteIndex);
var pos = metrics.Layout.Layout.IndexToPos (index);
var co = o + task.Column - 1;
g.SetSourceColor (GetMarkerColor (false, metrics.SelectionStart <= co && co < metrics.SelectionEnd));
g.MoveTo (
metrics.TextRenderStartPosition + editor.TextViewMargin.TextStartPosition + pos.X / Pango.Scale.PangoScale,
y + editor.LineHeight - 3
);
g.RelLineTo (3, 3);
g.RelLineTo (-6, 0);
g.ClosePath ();
g.Fill ();
}
}
void DrawLinePart (Cairo.Context cr, DocumentLine line, int lineNumber, int logicalRulerColumn, int offset, int length, ref double position, ref bool isSelectionDrawn, double y, double maxX, double _lineHeight)
{
ISyntaxMode mode = Document.SyntaxMode != null && textEditor.Options.EnableSyntaxHighlighting ? Document.SyntaxMode : new SyntaxMode (Document);
int selectionStartOffset;
int selectionEndOffset;
if (this.HideSelection) {
selectionStartOffset = selectionEndOffset = -1;
} else {
GetSelectionOffsets (line, out selectionStartOffset, out selectionEndOffset);
}
// ---- new renderer
LayoutWrapper layout = CreateLinePartLayout (mode, line, logicalRulerColumn, offset, length, selectionStartOffset, selectionEndOffset);
int lineOffset = line.Offset;
double width = layout.Width;
double xPos = position;
// The caret line marker must be drawn below the text markers otherwise the're invisible
if ((HighlightCaretLine || textEditor.GetTextEditorData ().HighlightCaretLine) && Caret.Line == lineNumber)
DrawCaretLineMarker (cr, xPos, y, layout.Width, _lineHeight);
// if (!(HighlightCaretLine || textEditor.Options.HighlightCaretLine) || Document.GetLine(Caret.Line) != line) {
if (BackgroundRenderer == null) {
foreach (var bg in layout.BackgroundColors) {
int x1, x2;
x1 = layout.Layout.IndexToPos (bg.FromIdx).X;
x2 = layout.Layout.IndexToPos (bg.ToIdx).X;
DrawRectangleWithRuler (
cr, xPos + textEditor.HAdjustment.Value - TextStartPosition,
new Cairo.Rectangle (x1 / Pango.Scale.PangoScale + position, y, (x2 - x1) / Pango.Scale.PangoScale + 1, _lineHeight),
bg.Color, true);
}
}
var metrics = new LineMetrics {
LineSegment = line,
Layout = layout,
SelectionStart = selectionStartOffset,
SelectionEnd = selectionEndOffset,
TextStartOffset = offset,
TextEndOffset = offset + length,
TextRenderStartPosition = xPos,
TextRenderEndPosition = xPos + width,
LineHeight = _lineHeight,
WholeLineWidth = textEditor.Allocation.Width - xPos,
LineYRenderStartPosition = y
};
foreach (TextLineMarker marker in line.Markers) {
if (!marker.IsVisible)
continue;
if (marker.DrawBackground (textEditor, cr, metrics)) {
isSelectionDrawn |= (marker.Flags & TextLineMarkerFlags.DrawsSelection) == TextLineMarkerFlags.DrawsSelection;
}
}
var textSegmentMarkers = TextDocument.OrderTextSegmentMarkersByInsertion (Document.GetTextSegmentMarkersAt (line).Where (m => m.IsVisible)).ToArray ();
foreach (var marker in textSegmentMarkers) {
if (layout.Layout != null)
marker.DrawBackground (textEditor, cr, metrics, offset, offset + length);
}
if (DecorateLineBg != null)
DecorateLineBg (cr, layout, offset, length, xPos, y, selectionStartOffset, selectionEndOffset);
if (!isSelectionDrawn && (layout.StartSet || selectionStartOffset == offset + length) && BackgroundRenderer == null) {
double startX;
int startY;
double endX;
int endY;
if (selectionStartOffset != offset + length) {
var start = layout.Layout.IndexToPos (layout.SelectionStartIndex);
startX = System.Math.Floor (start.X / Pango.Scale.PangoScale);
startY = (int)(y + System.Math.Floor (start.Y / Pango.Scale.PangoScale));
var end = layout.Layout.IndexToPos (layout.SelectionEndIndex);
endX = System.Math.Ceiling (end.X / Pango.Scale.PangoScale);
endY = (int)(y + System.Math.Ceiling (end.Y / Pango.Scale.PangoScale));
} else {
startY = endY = (int)y;
startX = width;
endX = startX;
}
if (textEditor.MainSelection.SelectionMode == SelectionMode.Block && startX == endX) {
endX = startX + 2;
}
if (startY == endY) {
DrawRectangleWithRuler (
cr,
xPos + textEditor.HAdjustment.Value - TextStartPosition,
new Cairo.Rectangle (xPos + startX, startY, endX - startX, LineHeight),
this.SelectionColor.Background,
true
);
} else {
DrawRectangleWithRuler (
cr,
xPos + textEditor.HAdjustment.Value - TextStartPosition,
new Cairo.Rectangle (xPos + startX, startY, textEditor.Allocation.Width - xPos - startX, LineHeight),
this.SelectionColor.Background,
true
);
if (endY - startY > LineHeight) {
DrawRectangleWithRuler (
cr,
xPos,
new Cairo.Rectangle (xPos, startY + LineHeight, textEditor.Allocation.Width - xPos, endY - startY - LineHeight),
this.SelectionColor.Background,
true
);
}
DrawRectangleWithRuler (
cr,
xPos,
new Cairo.Rectangle (xPos, endY, endX, LineHeight),
this.SelectionColor.Background,
true
);
}
}
// highlight search results
TextSegment firstSearch;
int o = offset;
uint curIndex = 0, byteIndex = 0;
if (textEditor.HighlightSearchPattern) {
while (!(firstSearch = GetFirstSearchResult (o, offset + length)).IsInvalid) {
double x = position;
HandleSelection (lineOffset, logicalRulerColumn, selectionStartOffset, selectionEndOffset, System.Math.Max (lineOffset, firstSearch.Offset), System.Math.Min (lineOffset + line.Length, firstSearch.EndOffset), delegate(int start, int end) {
uint startIndex = (uint)(start - offset);
uint endIndex = (uint)(end - offset);
if (startIndex < endIndex && endIndex <= layout.LineChars.Length) {
uint startTranslated = TranslateToUTF8Index (layout.LineChars, startIndex, ref curIndex, ref byteIndex);
uint endTranslated = TranslateToUTF8Index (layout.LineChars, endIndex, ref curIndex, ref byteIndex);
int l, x1, x2;
layout.Layout.IndexToLineX ((int)startTranslated, false, out l, out x1);
layout.Layout.IndexToLineX ((int)endTranslated, false, out l, out x2);
int w = (int) System.Math.Ceiling ((x2 - x1) / Pango.Scale.PangoScale);
int s = (int) System.Math.Floor (x1 / Pango.Scale.PangoScale + x);
double corner = System.Math.Min (4, width) * textEditor.Options.Zoom;
cr.SetSourceColor (MainSearchResult.IsInvalid || MainSearchResult.Offset != firstSearch.Offset ? ColorStyle.SearchResult.Color : ColorStyle.SearchResultMain.Color);
FoldingScreenbackgroundRenderer.DrawRoundRectangle (cr, true, true, s, y, corner, w + 1, LineHeight);
cr.Fill ();
}
}, null);
o = System.Math.Max (firstSearch.EndOffset, o + 1);
}
}
cr.Save ();
cr.Translate (xPos, y);
cr.ShowLayout (layout.Layout);
cr.Restore ();
if (offset == line.Offset) {
DrawIndent (cr, layout, line, xPos, y);
}
if (textEditor.Options.ShowWhitespaces != ShowWhitespaces.Never && !(BackgroundRenderer != null && textEditor.Options.ShowWhitespaces == ShowWhitespaces.Selection))
DecorateTabsAndSpaces (cr, layout, offset, xPos, y, selectionStartOffset, selectionEndOffset);
if (textEditor.IsSomethingSelected && !isSelectionDrawn && BackgroundRenderer == null) {
if (lineNumber == textEditor.MainSelection.End.Line && textEditor.MainSelection.End.Column > line.Length + 1) {
using (var wrapper = GetVirtualSpaceLayout (line, textEditor.MainSelection.End)) {
double startX;
double endX;
startX = xPos;
endX = position + wrapper.Width + layout.Width;
DrawRectangleWithRuler (cr, xPos + textEditor.HAdjustment.Value - TextStartPosition, new Cairo.Rectangle (startX, y, endX - startX, _lineHeight), this.SelectionColor.Background, true);
if (lineNumber == Caret.Line &&
textEditor.Options.ShowWhitespaces == ShowWhitespaces.Selection &&
textEditor.IsSomethingSelected &&
(selectionStartOffset < offset || selectionStartOffset == selectionEndOffset) &&
BackgroundRenderer == null) {
DecorateTabsAndSpaces (cr, wrapper, offset, xPos, y, selectionStartOffset, selectionEndOffset + wrapper.LineChars.Length);
}
}
}
}
if (lineNumber == Caret.Line) {
int caretOffset = Caret.Offset;
if (offset <= caretOffset && caretOffset <= offset + length) {
int index = caretOffset - offset;
//This if means we have temporary indent
if (Caret.Column > line.Length + 1) {
using (var wrapper = GetVirtualSpaceLayout (line, Caret.Location)) {
var x = (position + wrapper.Width) + layout.Width;
SetVisibleCaretPosition (x, y, x, y);
xPos = position + layout.Width;
// When drawing virtual space before the selection start paint it as unselected.
var virtualSpaceMod = selectionStartOffset < caretOffset ? 0 : wrapper.LineChars.Length;
if ((!textEditor.IsSomethingSelected || (selectionStartOffset >= offset && selectionStartOffset != selectionEndOffset)) && (HighlightCaretLine || textEditor.Options.HighlightCaretLine) && Caret.Line == lineNumber)
DrawCaretLineMarker (cr, position, y, wrapper.Width, _lineHeight);
if (DecorateLineBg != null)
DecorateLineBg (cr, wrapper, offset, length, xPos, y, selectionStartOffset + virtualSpaceMod, selectionEndOffset + wrapper.LineChars.Length);
if (textEditor.Options.ShowWhitespaces == ShowWhitespaces.Always) {
DecorateTabsAndSpaces (cr, wrapper, offset, xPos, y, selectionStartOffset, selectionEndOffset + wrapper.LineChars.Length);
}
}
} else if (index == length && string.IsNullOrEmpty (textEditor.preeditString)) {
var x = position + layout.Width;
SetVisibleCaretPosition (x, y, x, y);
} else if (index >= 0 && index <= length) {
Pango.Rectangle strong_pos, weak_pos;
curIndex = byteIndex = 0;
int utf8ByteIndex = (int)TranslateToUTF8Index (layout.LineChars, (uint)index, ref curIndex, ref byteIndex);
layout.Layout.GetCursorPos (utf8ByteIndex, out strong_pos, out weak_pos);
var cx = xPos + (strong_pos.X / Pango.Scale.PangoScale);
var cy = y + (strong_pos.Y / Pango.Scale.PangoScale);
if (textEditor.preeditCursorCharIndex == 0) {
SetVisibleCaretPosition (cx, cy, cx, cy);
} else {
var preeditIndex = (uint)(index + textEditor.preeditCursorCharIndex);
utf8ByteIndex = (int)TranslateToUTF8Index (layout.LineChars, preeditIndex, ref curIndex, ref byteIndex);
layout.Layout.GetCursorPos (utf8ByteIndex, out strong_pos, out weak_pos);
var pcx = xPos + (strong_pos.X / Pango.Scale.PangoScale);
var pcy = y + (strong_pos.Y / Pango.Scale.PangoScale);
SetVisibleCaretPosition (pcx, pcy, cx, cy);
}
}
}
}
foreach (TextLineMarker marker in line.Markers.Where (m => m.IsVisible)) {
if (layout.Layout != null)
marker.Draw (textEditor, cr, metrics);
}
foreach (var marker in textSegmentMarkers) {
if (layout.Layout != null)
marker.Draw (textEditor, cr, metrics, offset, offset + length);
}
position += System.Math.Floor (layout.LastLineWidth);
if (layout.IsUncached)
layout.Dispose ();
}
public override void Draw (MonoTextEditor editor, Cairo.Context cr, LineMetrics layout, int startOffset, int endOffset)
{
if (DebuggingService.IsDebugging)
return;
int markerStart = Segment.Offset;
int markerEnd = Segment.EndOffset;
if (markerEnd < startOffset || markerStart > endOffset)
return;
double drawFrom;
double drawTo;
double y = layout.LineYRenderStartPosition;
double startXPos = layout.TextRenderStartPosition;
double endXPos = layout.TextRenderEndPosition;
if (markerStart < startOffset && endOffset < markerEnd) {
drawTo = endXPos;
var line = editor.GetLineByOffset (startOffset);
int offset = line.GetIndentation (editor.Document).Length;
drawFrom = startXPos + (layout.Layout.Layout.IndexToPos (offset).X / Pango.Scale.PangoScale);
} else {
int start;
if (startOffset < markerStart) {
start = markerStart;
} else {
var line = editor.GetLineByOffset (startOffset);
int offset = line.GetIndentation (editor.Document).Length;
start = startOffset + offset;
}
int end = endOffset < markerEnd ? endOffset : markerEnd;
int x_pos;
x_pos = layout.Layout.Layout.IndexToPos (start - startOffset).X;
drawFrom = startXPos + (int)(x_pos / Pango.Scale.PangoScale);
x_pos = layout.Layout.Layout.IndexToPos (end - startOffset).X;
drawTo = startXPos + (int)(x_pos / Pango.Scale.PangoScale);
}
drawFrom = Math.Max (drawFrom, editor.TextViewMargin.XOffset);
drawTo = Math.Max (drawTo, editor.TextViewMargin.XOffset);
if (drawFrom >= drawTo)
return;
double height = editor.LineHeight / 5;
cr.SetSourceColor (color);
if (effect == MonoDevelop.Ide.Editor.TextSegmentMarkerEffect.WavedLine) {
Pango.CairoHelper.ShowErrorUnderline (cr, drawFrom, y + editor.LineHeight - height, drawTo - drawFrom, height);
} else if (effect == MonoDevelop.Ide.Editor.TextSegmentMarkerEffect.DottedLine) {
cr.Save ();
cr.LineWidth = 1;
cr.MoveTo (drawFrom + 1, y + editor.LineHeight - 1 + 0.5);
cr.RelLineTo (Math.Min (drawTo - drawFrom, 4 * 3), 0);
cr.SetDash (new double[] { 2, 2 }, 0);
cr.Stroke ();
cr.Restore ();
} else {
cr.MoveTo (drawFrom, y + editor.LineHeight - 1);
cr.LineTo (drawTo, y + editor.LineHeight - 1);
cr.Stroke ();
}
}
public void DrawRectangleWithRuler (Cairo.Context cr, double x, Cairo.Rectangle area, Cairo.Color color, bool drawDefaultBackground)
{
bool isDefaultColor = color.R == defaultBgColor.R && color.G == defaultBgColor.G && color.B == defaultBgColor.B;
if (isDefaultColor && !drawDefaultBackground)
return;
cr.SetSourceColor (color);
var left = (int)(area.X);
var width = (int)area.Width + 1;
if (textEditor.GetTextEditorData ().ShowRuler) {
var right = left + width;
var divider = (int) (System.Math.Max (left, System.Math.Min (x + TextStartPosition + rulerX, right)));
if (divider < right) {
var beforeDividerWidth = divider - left;
if (beforeDividerWidth > 0) {
cr.Rectangle (left, area.Y, beforeDividerWidth, area.Height);
cr.Fill ();
}
cr.Rectangle (divider, area.Y, right - divider, area.Height);
cr.SetSourceColor (color);
cr.Fill ();
if (beforeDividerWidth > 0) {
cr.DrawLine (
ColorStyle.Ruler.Color,
divider + 0.5, area.Y,
divider + 0.5, area.Y + area.Height);
}
return;
}
}
cr.Rectangle (left, area.Y, System.Math.Ceiling (area.Width), area.Height);
cr.Fill ();
}
protected void DrawCaret (Cairo.Context cr)
{
if (TextEditor.ColorStyle == null || caretLine < 0)
return;
double y = GetYPosition (caretLine);
cr.MoveTo (0, y - 4);
cr.LineTo (7, y);
cr.LineTo (0, y + 4);
cr.ClosePath ();
cr.SetSourceColor (TextEditor.ColorStyle.PlainText.Foreground);
cr.Fill ();
}
protected internal override void Draw (Cairo.Context cr, Cairo.Rectangle area, DocumentLine line, int lineNr, double x, double y, double _lineHeight)
{
// double xStart = System.Math.Max (area.X, XOffset);
// xStart = System.Math.Max (0, xStart);
var correctedXOffset = System.Math.Floor (XOffset) - 1;
var lineArea = new Cairo.Rectangle (correctedXOffset, y, textEditor.Allocation.Width - correctedXOffset, _lineHeight);
double position = x - textEditor.HAdjustment.Value + TextStartPosition;
defaultBgColor = Document.ReadOnly ? ColorStyle.BackgroundReadOnly.Color : ColorStyle.PlainText.Background;
var startLineNr = lineNr;
// Draw the default back color for the whole line. Colors other than the default
// background will be drawn when rendering the text chunks.
if (BackgroundRenderer == null)
DrawRectangleWithRuler (cr, x, lineArea, defaultBgColor, true);
bool isSelectionDrawn = false;
// Check if line is beyond the document length
if (line == null) {
DrawScrollShadow (cr, x, y, _lineHeight);
var marker = Document.GetExtendingTextMarker (lineNr);
if (marker != null)
marker.Draw (textEditor, cr, lineNr, lineArea);
return;
}
IEnumerable<FoldSegment> foldings = Document.GetStartFoldings (line);
int offset = line.Offset;
int caretOffset = Caret.Offset;
bool isEolFolded = false;
restart:
int logicalRulerColumn = line.GetLogicalColumn (textEditor.GetTextEditorData (), textEditor.Options.RulerColumn);
if ((HighlightCaretLine || textEditor.GetTextEditorData ().HighlightCaretLine) && Caret.Line == lineNr)
DrawCaretLineMarker (cr, x, y, TextStartPosition, _lineHeight);
foreach (FoldSegment folding in foldings) {
int foldOffset = folding.StartLine.Offset + folding.Column - 1;
if (foldOffset < offset)
continue;
if (folding.IsFolded) {
DrawLinePart (cr, line, lineNr, logicalRulerColumn, offset, foldOffset - offset, ref position, ref isSelectionDrawn, y, area.X + area.Width, _lineHeight);
offset = folding.EndLine.Offset + folding.EndColumn - 1;
markerLayout.SetText (folding.Description);
int width, height;
markerLayout.GetPixelSize (out width, out height);
bool isFoldingSelected = !this.HideSelection && textEditor.IsSomethingSelected && textEditor.SelectionRange.Contains (folding.Segment);
double pixelX = 0.5 + System.Math.Floor (position);
double foldXMargin = foldMarkerXMargin * textEditor.Options.Zoom;
double pixelWidth = System.Math.Floor (position + width - pixelX + foldXMargin * 2);
var foldingRectangle = new Cairo.Rectangle (
pixelX,
y,
pixelWidth,
this.LineHeight);
if (BackgroundRenderer == null && isFoldingSelected) {
cr.SetSourceColor (SelectionColor.Background);
cr.Rectangle (foldingRectangle);
cr.Fill ();
}
if (isFoldingSelected && SelectionColor.TransparentForeground) {
cr.SetSourceColor (ColorStyle.CollapsedText.Foreground);
} else {
cr.SetSourceColor (isFoldingSelected ? SelectionColor.Foreground : ColorStyle.CollapsedText.Foreground);
}
var boundingRectangleHeight = foldingRectangle.Height - 1;
var boundingRectangleY = System.Math.Floor (foldingRectangle.Y + (foldingRectangle.Height - boundingRectangleHeight) / 2);
RoundedRectangle (cr,
System.Math.Floor (foldingRectangle.X) + 0.5,
boundingRectangleY + 0.5,
System.Math.Floor (foldingRectangle.Width - cr.LineWidth),
System.Math.Floor (boundingRectangleHeight - cr.LineWidth),
LineHeight / 8, CairoCorners.All, false);
cr.Stroke ();
cr.Save ();
cr.Translate (
position + foldXMargin,
System.Math.Floor (boundingRectangleY + System.Math.Max (0, boundingRectangleHeight - height) / 2));
cr.ShowLayout (markerLayout);
cr.Restore ();
if (caretOffset == foldOffset && !string.IsNullOrEmpty (folding.Description)) {
var cx = (int)position;
SetVisibleCaretPosition (cx, y, cx, y);
}
position += foldingRectangle.Width;
if (caretOffset == foldOffset + folding.Length && !string.IsNullOrEmpty (folding.Description)) {
var cx = (int)position;
SetVisibleCaretPosition (cx, y, cx, y);
}
if (folding.EndLine != line) {
line = folding.EndLine;
lineNr = line.LineNumber;
foldings = Document.GetStartFoldings (line);
isEolFolded = line.Length <= folding.EndColumn;
goto restart;
}
isEolFolded = line.Length <= folding.EndColumn;
}
}
// Draw remaining line - must be called for empty line parts as well because the caret may be at this positon
// and the caret position is calculated in DrawLinePart.
if (line.EndOffsetIncludingDelimiter - offset >= 0) {
DrawLinePart (cr, line, lineNr, logicalRulerColumn, offset, line.Offset + line.Length - offset, ref position, ref isSelectionDrawn, y, area.X + area.Width, _lineHeight);
}
bool isEolSelected =
!this.HideSelection &&
textEditor.IsSomethingSelected &&
textEditor.SelectionMode == SelectionMode.Normal &&
textEditor.MainSelection.ContainsLine (lineNr) &&
textEditor.MainSelection.Contains (lineNr + 1, 1);
var lx = (int)position;
lineArea = new Cairo.Rectangle (lx,
lineArea.Y,
textEditor.Allocation.Width - lx,
lineArea.Height);
if (textEditor.SelectionMode == SelectionMode.Block && textEditor.IsSomethingSelected && textEditor.SelectionRange.Contains (line.Offset + line.Length)) {
DocumentLocation start = textEditor.MainSelection.Anchor;
DocumentLocation end = textEditor.MainSelection.Lead;
DocumentLocation visStart = textEditor.LogicalToVisualLocation (start);
DocumentLocation visEnd = textEditor.LogicalToVisualLocation (end);
double x1 = this.ColumnToX (line, visStart.Column);
double x2 = this.ColumnToX (line, visEnd.Column);
if (x1 > x2) {
var tmp = x1;
x1 = x2;
x2 = tmp;
}
x1 += correctedXOffset - textEditor.HAdjustment.Value;
x2 += correctedXOffset - textEditor.HAdjustment.Value;
if (x2 > lineArea.X && BackgroundRenderer == null) {
if (x1 - lineArea.X > 0) {
DrawRectangleWithRuler (cr, x, new Cairo.Rectangle (lineArea.X, lineArea.Y, x1 - lineArea.X, lineArea.Height), defaultBgColor, false);
lineArea = new Cairo.Rectangle (x1, lineArea.Y, lineArea.Width, lineArea.Height);
}
DrawRectangleWithRuler (cr, x, new Cairo.Rectangle (lineArea.X, lineArea.Y, x2 - lineArea.X, lineArea.Height), this.SelectionColor.Background, false);
lineArea = new Cairo.Rectangle (x2, lineArea.Y, textEditor.Allocation.Width - lineArea.X, lineArea.Height);
}
}
LayoutWrapper wrapper = null;
if (!isSelectionDrawn && BackgroundRenderer == null) {
if (isEolSelected) {
// prevent "gaps" in the selection drawing ('fuzzy' lines problem)
wrapper = GetLayout (line);
if (lineNr == textEditor.MainSelection.Start.Line && line.Length == 0 && textEditor.MainSelection.Start.Column > 1) {
using (var vwrapper = GetVirtualSpaceLayout (line, textEditor.MainSelection.Start)) {
lineArea = new Cairo.Rectangle (
lineArea.X + vwrapper.Width,
lineArea.Y + System.Math.Max (0, wrapper.Height - LineHeight),
textEditor.Allocation.Width - (lineArea.X + vwrapper.Width),
LineHeight
);
}
} else {
var eolStartX = System.Math.Floor (position);
lineArea = new Cairo.Rectangle (
eolStartX,
lineArea.Y + System.Math.Max (0, wrapper.Height - LineHeight),
textEditor.Allocation.Width - eolStartX,
LineHeight);
}
if (lineNr != textEditor.MainSelection.End.Line)
DrawRectangleWithRuler (cr, x, lineArea, this.SelectionColor.Background, false);
if (line.Length == 0)
DrawIndent (cr, wrapper, line, lx, y);
} else if (!(HighlightCaretLine || textEditor.GetTextEditorData ().HighlightCaretLine) || Caret.Line != lineNr && Caret.Line != startLineNr) {
wrapper = GetLayout (line);
if (wrapper.EolSpanStack != null) {
foreach (var span in wrapper.EolSpanStack) {
var spanStyle = textEditor.ColorStyle.GetChunkStyle (span.Color);
if (spanStyle == null)
continue;
if (!spanStyle.TransparentBackground && GetPixel (ColorStyle.PlainText.Background) != GetPixel (spanStyle.Background)) {
DrawRectangleWithRuler (cr, x, lineArea, spanStyle.Background, false);
break;
}
}
}
} else {
double xPos = position;
DrawCaretLineMarker (cr, xPos, y, lineArea.X + lineArea.Width - xPos, _lineHeight);
}
}
if (textEditor.Options.ShowWhitespaces != ShowWhitespaces.Never) {
switch (textEditor.Options.ShowWhitespaces) {
case ShowWhitespaces.Selection:
if (!isEolFolded && isEolSelected)
if (!(BackgroundRenderer != null && textEditor.Options.ShowWhitespaces == ShowWhitespaces.Selection))
if (textEditor.MainSelection.Contains (lineNr, 2 + line.Length) &&
!(lineNr == Caret.Line && Caret.Column > 1 && textEditor.MainSelection.Anchor.Line < textEditor.MainSelection.Lead.Line) &&
textEditor.MainSelection.Anchor.Line != textEditor.MainSelection.Lead.Line)
goto case ShowWhitespaces.Always;
break;
case ShowWhitespaces.Always:
if (wrapper == null)
wrapper = GetLayout (line);
DrawEolMarker (cr, line, isEolSelected, position, y + System.Math.Max (0, wrapper.Height - LineHeight));
break;
}
}
var extendingMarker = Document.GetExtendingTextMarker (lineNr);
if (extendingMarker != null)
extendingMarker.Draw (textEditor, cr, lineNr, lineArea);
if (BackgroundRenderer == null) {
var metrics = new EndOfLineMetrics {
LineSegment = line,
TextRenderEndPosition = TextStartPosition + position,
LineHeight = _lineHeight,
LineYRenderStartPosition = y
};
foreach (var marker in line.Markers) {
marker.DrawAfterEol (textEditor, cr, metrics);
}
}
lastLineRenderWidth = position;
DrawScrollShadow (cr, x, y, _lineHeight);
if (wrapper != null && wrapper.IsUncached)
wrapper.Dispose ();
}
protected void DrawLeftBorder (Cairo.Context cr)
{
cr.MoveTo (0.5, 0);
cr.LineTo (0.5, Allocation.Height);
if (TextEditor.ColorStyle != null) {
var col = (HslColor)TextEditor.ColorStyle.PlainText.Background;
if (!Platform.IsWindows) {
col.L *= 0.88;
}
cr.SetSourceColor (col);
}
cr.Stroke ();
}
void DrawValue (Cairo.Context ctx, Gdk.GC gc, DateTime initialTime, int ytop, int lx, int tx, ref int ty, ref int maxx, ref int maxy, int indent, CounterValueInfo val)
{
Gdk.Color color;
if (val.Counter != null)
color = val.Counter.GetColor ();
else
color = Style.Black;
// Draw text
gc.RgbFgColor = color;
double ms = (val.Time - initialTime).TotalMilliseconds;
string txt = (ms / 1000).ToString ("0.00000") + ": " + (val.Duration.TotalMilliseconds / 1000).ToString ("0.00000") + " " + val.Trace;
layout.SetText (txt);
GdkWindow.DrawLayout (gc, tx + indent, ty, layout);
int tw, th;
layout.GetPixelSize (out tw, out th);
if (tx + tw + indent > maxx)
maxx = tx + tw + indent;
HotSpot hp = AddHotSpot (tx + indent, ty, tw, th);
int tempTy = ty;
hp.Action = delegate {
int ytm = ytop + (int) ((ms * scale) / 1000);
SetBaseTime ((int) (tempTy + (th / 2) + 0.5) - ytm);
};
hp.OnMouseOver += delegate {
overValue = val;
QueueDraw ();
};
hp.Action += delegate {
focusedValue = val;
QueueDraw ();
};
// Draw time marker
int ytime = ytop + (int) ((ms * scale) / 1000) + baseTime;
if (val == focusedValue || val == overValue) {
ctx.NewPath ();
double dx = val == focusedValue ? 0 : 2;
ctx.Rectangle (lx + 0.5 + dx - SelectedValuePadding, ytime + 0.5, LineEndWidth - dx*2 + SelectedValuePadding, ((val.Duration.TotalMilliseconds * scale) / 1000));
Mono.TextEditor.HslColor hsl = color;
hsl.L = val == focusedValue ? 0.9 : 0.8;
ctx.SetSourceColor (hsl);
ctx.Fill ();
}
ctx.NewPath ();
ctx.LineWidth = 1;
ctx.MoveTo (lx + 0.5, ytime + 0.5);
ctx.LineTo (lx + LineEndWidth + 0.5, ytime + 0.5);
ctx.LineTo (tx - 3 - LineEndWidth + 0.5, ty + (th / 2) + 0.5);
ctx.LineTo (tx + indent - 3 + 0.5, ty + (th / 2) + 0.5);
ctx.SetSourceColor (color.ToCairoColor ());
ctx.Stroke ();
// Expander
bool incLine = true;
if (val.CanExpand) {
double ex = tx + indent - 3 - ExpanderSize - 2 + 0.5;
double ey = ty + (th / 2) - (ExpanderSize/2) + 0.5;
hp = AddHotSpot (ex, ey, ExpanderSize, ExpanderSize);
DrawExpander (ctx, ex, ey, val.Expanded, false);
hp.OnMouseOver = delegate {
using (Cairo.Context c = CairoHelper.Create (GdkWindow)) {
DrawExpander (c, ex, ey, val.Expanded, true);
}
};
hp.OnMouseLeave = delegate {
using (Cairo.Context c = CairoHelper.Create (GdkWindow)) {
DrawExpander (c, ex, ey, val.Expanded, false);
}
};
hp.Action = delegate {
ToggleExpand (val);
};
if (val.Expanded && val.ExpandedTimerTraces.Count > 0) {
ty += th + LineSpacing;
foreach (CounterValueInfo cv in val.ExpandedTimerTraces)
DrawValue (ctx, gc, initialTime, ytop, lx, tx, ref ty, ref maxx, ref maxy, indent + ChildIndent, cv);
incLine = false;
}
}
if (incLine)
ty += th + LineSpacing;
if (ytime > maxy)
maxy = ytime;
}
protected void DrawSearchResults (Cairo.Context cr)
{
foreach (var region in TextEditor.TextViewMargin.SearchResults) {
int line = TextEditor.OffsetToLineNumber (region.Offset);
double y = GetYPosition (line);
bool isMainSelection = false;
if (!TextEditor.TextViewMargin.MainSearchResult.IsInvalid)
isMainSelection = region.Offset == TextEditor.TextViewMargin.MainSearchResult.Offset;
cr.SetSourceColor (isMainSelection ? TextEditor.ColorStyle.SearchResultMain.Color : TextEditor.ColorStyle.SearchResult.Color);
cr.Rectangle (barPadding, Math.Round (y) - 1, Allocation.Width - barPadding * 2, 2);
cr.Fill ();
}
}
void DrawExpander (Cairo.Context ctx, double ex, double ey, bool expanded, bool hilight)
{
ctx.NewPath ();
ctx.LineWidth = 1;
ctx.Rectangle (ex, ey, ExpanderSize, ExpanderSize);
if (hilight)
ctx.SetSourceColor (Style.Background (Gtk.StateType.Normal).ToCairoColor ());
else
ctx.SetSourceColor (Style.White.ToCairoColor ());
ctx.FillPreserve ();
ctx.SetSourceColor (Style.Foreground (Gtk.StateType.Normal).ToCairoColor ());
ctx.Stroke ();
ctx.NewPath ();
ctx.MoveTo (ex + 2, ey + (ExpanderSize/2));
ctx.RelLineTo (ExpanderSize - 4, 0);
if (!expanded) {
ctx.MoveTo (ex + (ExpanderSize/2), ey + 2);
ctx.RelLineTo (0, ExpanderSize - 4);
}
ctx.Stroke ();
}
