protected override void OnPaint(PaintEventArgs pe)
{
if (presentationDataAccess == null)
{
base.OnPaint(pe);
return;
}
try
{
DrawContext dc = drawContext;
dc.Canvas.FillRectangle(dc.DefaultBackgroundBrush, pe.ClipRectangle);
UpdateDrawContextScrollPos();
int maxRight;
DrawingUtils.PaintControl(drawContext, presentationDataAccess, presentationDataAccess.Selection, this.Focused,
pe.ClipRectangle, out maxRight);
backBufferCanvas.Render(pe.Graphics);
UpdateScrollSize(dc, maxRight, pe.ClipRectangle.Height == ClientSize.Height);
}
catch (Exception e)
{
if (viewEvents != null)
{
viewEvents.OnDrawingError(e);
}
throw;
}
base.OnPaint(pe);
}
protected override void HandleMessageText(IMessage msg, float textXPos)
{
DrawContext dc = ctx;
LineTextPosition = DrawingUtils.ScreenPositionToMessageTextCharIndex(dc.Canvas, msg, dc.ShowRawMessages, TextLineIndex, dc.Font, dc.TextFormat,
(int)(ClickedPointX - textXPos - m.OffsetTextRect.X));
}
private void DoInplaceHighlighting(
IMessage msg,
Font font,
PointF location,
StringFormat format,
StringSlice text,
int lineBegin, int lineEnd,
Func <IMessage, IEnumerable <Tuple <int, int> > > handler,
Brush brush)
{
if (handler != null)
{
foreach (var hlRange in handler(msg))
{
int?hlBegin = null;
int?hlEnd = null;
if (hlRange.Item1 >= lineBegin && hlRange.Item1 <= lineEnd)
{
hlBegin = hlRange.Item1;
}
if (hlRange.Item2 >= lineBegin && hlRange.Item2 <= lineEnd)
{
hlEnd = hlRange.Item2;
}
if (hlBegin != null || hlEnd != null)
{
var tmp = DrawingUtils.GetTextSubstringBounds(
ctx.Canvas, m.MessageRect, text.Value, hlBegin.GetValueOrDefault(lineBegin), hlEnd.GetValueOrDefault(lineEnd),
font, location.X, format);
tmp.Inflate(0, -1);
FillInplaceHightlightRectangle(ctx, tmp, brush);
}
}
}
}
protected override void OnMouseMove(MouseEventArgs e)
{
DrawingUtils.CursorType newCursor;
DrawingUtils.MouseMoveHelper(presentationDataAccess, drawContext, ClientRectangle, viewEvents, e.Location,
e.Button == MouseButtons.Left && this.Capture, out newCursor);
Cursor newNativeCursor = Cursors.Arrow;
if (newCursor == DrawingUtils.CursorType.Arrow)
{
newNativeCursor = Cursors.Arrow;
}
else if (newCursor == DrawingUtils.CursorType.IBeam)
{
newNativeCursor = Cursors.IBeam;
}
else if (newCursor == DrawingUtils.CursorType.RightToLeftArrow)
{
newNativeCursor = rightCursor;
}
if (Cursor != newNativeCursor)
{
Cursor = newNativeCursor;
}
base.OnMouseMove(e);
}
public static void MouseMoveHelper(
IPresentationDataAccess presentationDataAccess,
DrawContext drawContext,
Rectangle clientRectangle,
IViewEvents viewEvents,
Point pt,
bool isLeftDrag,
out CursorType newCursor
)
{
newCursor = CursorType.Arrow;
if (presentationDataAccess != null)
{
foreach (var i in DrawingUtils.GetVisibleMessagesIterator(drawContext, presentationDataAccess, clientRectangle))
{
DrawingUtils.Metrics mtx = DrawingUtils.GetMetrics(i, drawContext);
if (pt.Y >= mtx.MessageRect.Top && pt.Y < mtx.MessageRect.Bottom)
{
if (isLeftDrag)
{
var hitTester = new HitTestingVisitor(drawContext, mtx, pt.X, i.TextLineIndex);
i.Message.Visit(hitTester);
MessageMouseEventFlag flags = MessageMouseEventFlag.ShiftIsHeld
| MessageMouseEventFlag.CapturedMouseMove;
if (pt.X < drawContext.CollapseBoxesAreaSize)
{
flags |= MessageMouseEventFlag.OulineBoxesArea;
}
viewEvents.OnMessageMouseEvent(i, hitTester.LineTextPosition, flags, pt);
}
if (i.Message.IsStartFrame() && mtx.OulineBox.Contains(pt))
{
newCursor = CursorType.Arrow;
}
else if (pt.X < drawContext.CollapseBoxesAreaSize)
{
newCursor = CursorType.RightToLeftArrow;
}
else if (pt.X >= drawContext.GetTextOffset(0, 0).X)
{
newCursor = CursorType.IBeam;
}
else
{
newCursor = CursorType.Arrow;
}
}
}
}
}
private void DoInplaceHighlighting(
IMessage msg,
PointF location,
StringSlice text,
int lineBegin, int lineEnd,
IHighlightingHandler handler,
Brush brush)
{
if (handler != null)
{
foreach (var hlRange in handler.GetHighlightingRanges(msg))
{
int?hlBegin = null;
int?hlEnd = null;
if (hlRange.Item1 >= lineBegin && hlRange.Item1 <= lineEnd)
{
hlBegin = hlRange.Item1;
}
if (hlRange.Item2 >= lineBegin && hlRange.Item2 <= lineEnd)
{
hlEnd = hlRange.Item2;
}
if (hlBegin != null || hlEnd != null)
{
var tmp = DrawingUtils.GetLineSubstringBounds(
text.SubString(lineBegin, lineEnd - lineBegin).Value,
hlBegin.GetValueOrDefault(lineBegin) - lineBegin,
hlEnd.GetValueOrDefault(lineEnd) - lineBegin,
ctx.Canvas,
ctx.Font,
ctx.TextFormat,
m.MessageRect, location.X);
tmp.Inflate(0, -1);
if (brush == null)
{
var cl = hlRange.Item3.GetBackgroundColor();
if (cl != null)
{
using (var tmpBrush = new Brush(cl.Value.ToColor()))
{
FillInplaceHightlightRectangle(ctx, tmp, tmpBrush);
}
}
}
else
{
FillInplaceHightlightRectangle(ctx, tmp, brush);
}
}
}
}
}
internal void OnMouseMove(NSEvent e, bool dragging)
{
DrawingUtils.CursorType cursor;
DrawingUtils.MouseMoveHelper(
presentationDataAccess,
drawContext,
ClientRectangle,
viewEvents,
InnerView.ConvertPointFromView(e.LocationInWindow, null).ToPoint(),
dragging,
out cursor
);
}
public static void PaintControl(DrawContext drawContext, IPresentationDataAccess presentationDataAccess,
SelectionInfo selection, bool controlIsFocused, Rectangle dirtyRect, out int maxRight)
{
var drawingVisitor = new DrawingVisitor();
drawingVisitor.ctx = drawContext;
drawingVisitor.SearchResultHighlightingHandler = presentationDataAccess.CreateSearchResultHighlightingHandler();
drawingVisitor.SelectionHighlightingHandler = presentationDataAccess.CreateSelectionHighlightingHandler();
drawingVisitor.HighlightingFiltersHandler = presentationDataAccess.CreateHighlightingFiltersHandler();
maxRight = 0;
var sel = selection;
bool needToDrawCursor = drawContext.CursorState == true && controlIsFocused && sel.First.Message != null;
var messagesToDraw = DrawingUtils.GetVisibleMessages(drawContext, presentationDataAccess, dirtyRect);
var displayLinesEnum = presentationDataAccess.GetViewLines(messagesToDraw.begin, messagesToDraw.end);
foreach (var il in displayLinesEnum)
{
drawingVisitor.DisplayIndex = il.LineIndex;
drawingVisitor.TextLineIdx = il.TextLineIndex;
drawingVisitor.IsBookmarked = il.IsBookmarked;
DrawingUtils.Metrics m = DrawingUtils.GetMetrics(il, drawContext);
drawingVisitor.m = m;
if (needToDrawCursor && sel.First.DisplayIndex == il.LineIndex)
{
drawingVisitor.CursorPosition = sel.First;
}
else
{
drawingVisitor.CursorPosition = null;
}
il.Message.Visit(drawingVisitor);
maxRight = Math.Max(maxRight, m.OffsetTextRect.Right);
}
DrawFocusedMessageMark(drawContext, presentationDataAccess, messagesToDraw);
drawingVisitor.SearchResultHighlightingHandler?.Dispose();
drawingVisitor.SelectionHighlightingHandler?.Dispose();
drawingVisitor.HighlightingFiltersHandler?.Dispose();
}
public static void MouseDownHelper(
IPresentationDataAccess presentationDataAccess,
DrawContext drawContext,
Rectangle clientRectangle,
IViewEvents viewEvents,
Point pt,
MessageMouseEventFlag flags,
out bool captureTheMouse
)
{
captureTheMouse = true;
if (presentationDataAccess != null)
{
foreach (var i in DrawingUtils.GetVisibleMessagesIterator(drawContext, presentationDataAccess, clientRectangle))
{
DrawingUtils.Metrics mtx = DrawingUtils.GetMetrics(i, drawContext);
// if user clicked line's outline box (collapse/expand cross)
if (i.Message.IsStartFrame() && mtx.OulineBox.Contains(pt.X, pt.Y) && i.TextLineIndex == 0)
//if (viewEvents.OnOulineBoxClicked(i.Message, (flags & MessageMouseEventFlag.CtrlIsHeld) != 0))
{
captureTheMouse = false;
break;
}
// if user clicked line area
if (mtx.MessageRect.Contains(pt.X, pt.Y))
{
var hitTester = new HitTestingVisitor(drawContext, mtx, pt.X, i.TextLineIndex);
i.Message.Visit(hitTester);
if ((flags & MessageMouseEventFlag.DblClick) != 0)
{
captureTheMouse = false;
}
if (pt.X < drawContext.CollapseBoxesAreaSize)
{
flags |= MessageMouseEventFlag.OulineBoxesArea;
}
viewEvents.OnMessageMouseEvent(i, hitTester.LineTextPosition, flags, pt);
break;
}
}
}
}
protected override void HandleMessageText(IMessage msg, float textXPos)
{
DrawContext dc = ctx;
var line = dc.GetTextToDisplay(msg).GetNthTextLine(pos.TextLineIndex);
var lineCharIdx = pos.LineCharIndex;
if (lineCharIdx > line.Value.Length)
{
return; // defensive measure to avoid crash in UI thread
}
RectangleF tmp = DrawingUtils.GetTextSubstringBounds(
dc.Canvas, m.MessageRect, line.Value + '*',
lineCharIdx, lineCharIdx + 1, dc.Font,
m.OffsetTextRect.X + textXPos, ctx.TextFormat);
dc.Canvas.DrawLine(dc.CursorPen, tmp.X, tmp.Top, tmp.X, tmp.Bottom);
}
internal void OnMouseDown(NSEvent e)
{
MessageMouseEventFlag flags = MessageMouseEventFlag.None;
if (e.Type == NSEventType.RightMouseDown)
{
flags |= MessageMouseEventFlag.RightMouseButton;
}
if ((e.ModifierFlags & NSEventModifierMask.ShiftKeyMask) != 0)
{
flags |= MessageMouseEventFlag.ShiftIsHeld;
}
if ((e.ModifierFlags & NSEventModifierMask.AlternateKeyMask) != 0)
{
flags |= MessageMouseEventFlag.AltIsHeld;
}
if ((e.ModifierFlags & NSEventModifierMask.ControlKeyMask) != 0)
{
flags |= MessageMouseEventFlag.CtrlIsHeld;
}
if (e.ClickCount == 2)
{
flags |= MessageMouseEventFlag.DblClick;
}
else
{
flags |= MessageMouseEventFlag.SingleClick;
}
bool captureTheMouse;
DrawingUtils.MouseDownHelper(
presentationDataAccess,
drawContext,
ClientRectangle,
viewEvents,
InnerView.ConvertPointFromView(e.LocationInWindow, null).ToPoint(),
flags,
out captureTheMouse
);
}
protected override void OnMouseDown(MouseEventArgs e)
{
this.Focus();
bool captureTheMouse = true;
MessageMouseEventFlag flags = MessageMouseEventFlag.None;
if (e.Button == MouseButtons.Right)
{
flags |= MessageMouseEventFlag.RightMouseButton;
}
if (Control.ModifierKeys == Keys.Shift)
{
flags |= MessageMouseEventFlag.ShiftIsHeld;
}
if (Control.ModifierKeys == Keys.Alt)
{
flags |= MessageMouseEventFlag.AltIsHeld;
}
if (Control.ModifierKeys == Keys.Control)
{
flags |= MessageMouseEventFlag.CtrlIsHeld;
}
if (e.Clicks == 2)
{
flags |= MessageMouseEventFlag.DblClick;
}
else
{
flags |= MessageMouseEventFlag.SingleClick;
}
DrawingUtils.MouseDownHelper(presentationDataAccess, drawContext, ClientRectangle, viewEvents, e.Location, flags, out captureTheMouse);
base.OnMouseDown(e);
this.Capture = captureTheMouse;
}
internal void OnPaint(RectangleF dirtyRect)
{
if (presentationDataAccess == null)
{
return;
}
UpdateClientSize();
drawContext.Canvas = new LJD.Graphics();
drawContext.ScrollPos = new Point(0,
(int)(presentationDataAccess.GetFirstDisplayMessageScrolledLines() * (double)drawContext.LineHeight));
int maxRight;
DrawingUtils.PaintControl(drawContext, presentationDataAccess, selection, isFocused,
dirtyRect.ToRectangle(), out maxRight);
if (maxRight > viewWidth)
{
viewWidth = maxRight;
UpdateInnerViewSize();
}
}
void IView.InvalidateLine(ViewLine line)
{
Rectangle r = DrawingUtils.GetMetrics(line, drawContext).MessageRect;
InnerView.SetNeedsDisplayInRect(r.ToRectangleF().ToCGRect());
}
void IView.InvalidateLine(ViewLine line)
{
Rectangle r = DrawingUtils.GetMetrics(line, drawContext).MessageRect;
this.Invalidate(r);
}
void DrawMessageBackground(IMessage msg, float textXPos)
{
DrawContext dc = ctx;
Rectangle r = m.MessageRect;
r.Offset(ctx.CollapseBoxesAreaSize, 0);
Brush b = null;
Brush tmpBrush = null;
if (msg.Thread != null)
{
var coloring = dc.Coloring;
if (coloring == Settings.Appearance.ColoringMode.None)
{
b = dc.DefaultBackgroundBrush;
}
else if (msg.Thread.IsDisposed)
{
b = dc.DefaultBackgroundBrush;
}
else if (coloring == Settings.Appearance.ColoringMode.Threads)
{
b = tmpBrush = new Brush(msg.Thread.ThreadColor.ToColor());
}
else if (coloring == Settings.Appearance.ColoringMode.Sources)
{
b = (msg.LogSource == null || msg.LogSource.IsDisposed) ? dc.DefaultBackgroundBrush : (tmpBrush = new Brush(msg.LogSource.Color.ToColor()));
}
}
if (b == null)
{
b = dc.DefaultBackgroundBrush;
}
dc.Canvas.FillRectangle(b, r);
var normalizedSelection = dc.NormalizedSelection;
if (!normalizedSelection.IsEmpty &&
DisplayIndex >= normalizedSelection.First.DisplayIndex &&
DisplayIndex <= normalizedSelection.Last.DisplayIndex)
{
int selectionStartIdx;
int selectionEndIdx;
var line = dc.GetTextToDisplay(msg).GetNthTextLine(TextLineIdx);
if (DisplayIndex == normalizedSelection.First.DisplayIndex)
{
selectionStartIdx = normalizedSelection.First.LineCharIndex;
}
else
{
selectionStartIdx = 0;
}
if (DisplayIndex == normalizedSelection.Last.DisplayIndex)
{
selectionEndIdx = normalizedSelection.Last.LineCharIndex;
}
else
{
selectionEndIdx = line.Length;
}
if (selectionStartIdx < selectionEndIdx && selectionStartIdx >= 0 && selectionEndIdx <= line.Value.Length)
{
RectangleF tmp = DrawingUtils.GetLineSubstringBounds(
line.Value, selectionStartIdx, selectionEndIdx,
ctx.Canvas, dc.Font, ctx.TextFormat,
m.MessageRect, m.OffsetTextRect.X + textXPos);
dc.Canvas.FillRectangle(dc.SelectedBkBrush, tmp);
}
}
if (ctx.ShowTime)
{
float x = ctx.CollapseBoxesAreaSize + ctx.TimeAreaSize - ctx.ScrollPos.X - 2;
if (x > ctx.CollapseBoxesAreaSize)
{
ctx.Canvas.DrawLine(ctx.TimeSeparatorLine, x, m.MessageRect.Y, x, m.MessageRect.Bottom);
}
}
if (tmpBrush != null)
{
tmpBrush.Dispose();
}
}
public static IEnumerable <ViewLine> GetVisibleMessagesIterator(DrawContext drawContext, IPresentationDataAccess presentationDataAccess, Rectangle viewRect)
{
var vl = DrawingUtils.GetVisibleMessages(drawContext, presentationDataAccess, viewRect);
return(presentationDataAccess.GetViewLines(vl.begin, vl.end));
}
