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 (); }