public static void DrawFocusedMessage(
LJD.Graphics g,
ViewMetrics viewMetrics,
IViewEvents eventsHandler,
DrawScope scope,
Size sz)
{
var pos = eventsHandler.OnDrawFocusedMessage(scope);
if (pos == null)
{
return;
}
if (pos.Value < 0 || pos.Value > 1)
{
return;
}
var x = (int)(pos.Value * (double)sz.Width);
g.DrawLine(viewMetrics.FocusedMessagePen, x, 0, x, sz.Height);
var img = viewMetrics.FocusedMessageLineTop;
var imgsz = img.GetSize(height: 4f);
g.DrawImage(img, new RectangleF
(x - imgsz.Width / 2, 1, imgsz.Width, imgsz.Height));
}
public static void DrawEvents(
LJD.Graphics g,
ViewMetrics viewMetrics,
IViewEvents eventsHandler)
{
foreach (var evt in Metrics.GetEventMetrics(g, eventsHandler, viewMetrics))
{
if (evt.VertLinePoints != null)
{
g.PushState();
g.EnableAntialiasing(true);
g.DrawLines(viewMetrics.UserEventPen, evt.VertLinePoints);
g.PopState();
}
else
{
g.DrawLine(viewMetrics.UserEventPen, evt.VertLineA, evt.VertLineB);
}
if (evt.Icon != null)
{
g.DrawImage(evt.Icon, evt.IconRect);
}
g.FillRectangle(viewMetrics.EventRectBrush, evt.CaptionRect);
g.DrawRectangle(viewMetrics.EventRectPen, evt.CaptionRect);
g.DrawString(evt.Event.Caption, viewMetrics.EventCaptionFont,
viewMetrics.EventCaptionBrush, evt.CaptionDrawingOrigin,
viewMetrics.EventCaptionStringFormat);
}
}
public static void DrawActivities(LJD.Graphics g, ViewMetrics viewMetrics, IViewEvents eventsHandler)
{
PushGraphicsStateForDrawingActivites(g, viewMetrics, HitTestResult.AreaCode.ActivitiesPanel);
foreach (var a in Metrics.GetActivitiesMetrics(viewMetrics, eventsHandler))
{
g.FillRectangle(GetActivityBrush(viewMetrics, a.Activity.Type), a.ActivityBarRect);
foreach (var ph in a.Phases)
{
var phaseMargin = a.ActivityBarRect.Height / 3;
g.FillRectangle(ph.Brush, ph.X1, a.ActivityBarRect.Top + phaseMargin,
Math.Max(ph.X2 - ph.X1, 2), a.ActivityBarRect.Height - phaseMargin - 2);
}
foreach (var ms in a.Milestones)
{
g.DrawLine(viewMetrics.MilestonePen, ms.X, a.ActivityBarRect.Top, ms.X, a.ActivityBarRect.Bottom);
}
g.DrawRectangle(viewMetrics.ActivityBarBoundsPen, a.ActivityBarRect);
if (a.PairedActivityConnectorBounds != null)
{
var r = a.PairedActivityConnectorBounds.Value;
g.DrawLine(viewMetrics.ActivitiesConnectorPen, r.Left, r.Top, r.Left, r.Bottom);
g.DrawLine(viewMetrics.ActivitiesConnectorPen, r.Right, r.Top, r.Right, r.Bottom);
}
}
g.PopState();
}
ViewMetrics MakeViewMetrics()
{
var viewMetrics = new ViewMetrics(res.Value);
viewMetrics.RulersPanelHeight = (int)searchTextBoxPlaceholder.Frame.Bottom;
viewMetrics.ActivitiesViewWidth = (int)activitiesView.Bounds.Width;
viewMetrics.ActivitiesViewHeight = (int)activitiesView.Bounds.Height;
viewMetrics.ActivitesCaptionsViewWidth = (int)captionsView.Bounds.Width;
viewMetrics.ActivitesCaptionsViewHeight = (int)captionsView.Bounds.Height;
viewMetrics.NavigationPanelWidth = (int)navigatorView.Bounds.Width;
viewMetrics.NavigationPanelHeight = (int)navigatorView.Bounds.Height;
viewMetrics.LineHeight = (int)(NSFont.SystemFontSize * 1.5f);
viewMetrics.ActionLebelHeight = 17;
viewMetrics.MeasurerTop = 25;
viewMetrics.ActivityBarRectPaddingY = 5;
viewMetrics.TriggerLinkWidth = 8;
viewMetrics.DistanceBetweenRulerMarks = 70;
viewMetrics.VisibleRangeResizerWidth = 8;
viewMetrics.VScrollBarValue = (int)(vertScroller.DoubleValue * GetVertScrollerValueRange(viewMetrics));
viewMetrics.SequenceDiagramAreaWidth = captionsMarginMetrics.SequenceDiagramAreaWidth;
viewMetrics.FoldingAreaWidth = captionsMarginMetrics.FoldingAreaWidth;
return(viewMetrics);
}
ViewMetrics GetUpToDateViewMetrics()
{
var viewMetrics = new ViewMetrics(res);
var vm = viewMetrics;
vm.ActivitiesViewWidth = activitiesViewPanel.Width;
vm.ActivitiesViewHeight = activitiesViewPanel.Height;
vm.ActivitesCaptionsViewWidth = activitesCaptionsPanel.Width;
vm.ActivitesCaptionsViewHeight = activitesCaptionsPanel.Height;
vm.NavigationPanelWidth = navigationPanel.Width;
vm.NavigationPanelHeight = navigationPanel.Height;
vm.VScrollBarValue = activitiesScrollBar.Value;
vm.LineHeight = UIUtils.Dpi.Scale(20, 120);
vm.DPIScale = UIUtils.Dpi.Scale(1f);
vm.ActivityBarRectPaddingY = UIUtils.Dpi.Scale(5, 120);
vm.TriggerLinkWidth = UIUtils.Dpi.ScaleUp(5, 120);
vm.DistanceBetweenRulerMarks = UIUtils.Dpi.ScaleUp(50, 120);;
vm.MeasurerTop = 25;
vm.VisibleRangeResizerWidth = 8;
vm.RulersPanelHeight = UIUtils.Dpi.Scale(53, 120);
vm.ActionLebelHeight = UIUtils.Dpi.Scale(20, 120);
vm.SequenceDiagramAreaWidth = captionsMarginMetrics.SequenceDiagramAreaWidth;
vm.FoldingAreaWidth = captionsMarginMetrics.FoldingAreaWidth;
return(viewMetrics);
}
public void DrawCaptionsView(
LJD.Graphics g,
ViewMetrics viewMetrics,
IViewModel eventsHandler,
Action <string, Rectangle, int, int, bool> drawCaptionWithHighlightedRegion
)
{
PushGraphicsStateForDrawingActivites(g, viewMetrics, HitTestResult.AreaCode.CaptionsPanel);
int availableHeight = viewMetrics.ActivitiesViewHeight;
bool darkMode = eventsHandler.ColorTheme == Presenters.ColorThemeMode.Dark;
foreach (var a in eventsHandler.OnDrawActivities())
{
int y = viewMetrics.GetActivityY(a.Index);
if (y < 0)
{
continue;
}
if (y > availableHeight)
{
break;
}
var h = viewMetrics.LineHeight - 1;
var sequenceDiagramTextRect = new Rectangle(0, y, viewMetrics.SequenceDiagramAreaWidth, h);
var foldingAreaRect = new Rectangle(
sequenceDiagramTextRect.Right + 1 /* box padding */, y + (h - viewMetrics.FoldingAreaWidth) / 2, viewMetrics.FoldingAreaWidth, viewMetrics.FoldingAreaWidth);
var textRect = new Rectangle(
foldingAreaRect.Right + 3 /* text padding */, y, viewMetrics.ActivitesCaptionsViewWidth - foldingAreaRect.Right, h);
var lineRect = new Rectangle(0, y, viewMetrics.ActivitesCaptionsViewWidth, h);
if (a.IsSelected)
{
g.FillRectangle(res.SelectedActivityBackgroundBrush, lineRect);
}
else if (!darkMode && a.Color.HasValue)
{
using (var bgBrush = MakeBrush(a.Color.Value))
g.FillRectangle(bgBrush, lineRect);
}
if (!string.IsNullOrEmpty(a.SequenceDiagramText))
{
g.DrawString(a.SequenceDiagramText, res.ActivitesCaptionsFont, res.ActivitesCaptionsBrush, sequenceDiagramTextRect);
}
if (a.IsFolded.HasValue)
{
g.DrawRectangle(res.FoldingSignPen, foldingAreaRect);
int pad = 2;
g.DrawLine(res.FoldingSignPen, foldingAreaRect.Left + pad, foldingAreaRect.MidY(), foldingAreaRect.Right - pad, foldingAreaRect.MidY());
if (a.IsFolded == true)
{
g.DrawLine(res.FoldingSignPen, foldingAreaRect.MidX(), foldingAreaRect.Top + pad, foldingAreaRect.MidX(), foldingAreaRect.Bottom - pad);
}
}
drawCaptionWithHighlightedRegion(a.Caption, textRect, a.CaptionSelectionBegin, a.CaptionSelectionLength, a.IsError);
}
g.PopState();
}
public static IEnumerable <TLRulerMark> GetRulerMarks(
ViewMetrics viewMetrics,
IViewEvents eventsHandler,
DrawScope scope
)
{
return(eventsHandler.OnDrawRulers(scope, viewMetrics.ActivitiesViewWidth, viewMetrics.DistnanceBetweenRulerMarks));
}
static int GetActivityByPoint(Point pt, ViewMetrics vm)
{
if (pt.Y < vm.RulersPanelHeight)
{
return(-1);
}
return((pt.Y + vm.VScrollBarValue - vm.RulersPanelHeight) / vm.LineHeight);
}
public static void DrawMeasurer(
LJD.Graphics g,
ViewMetrics viewMetrics,
IViewEvents eventsHandler)
{
var drawInfo = eventsHandler.OnDrawMeasurer();
if (!drawInfo.MeasurerVisible)
{
return;
}
double viewWidth = viewMetrics.ActivitiesViewWidth;
int viewHeight = viewMetrics.ActivitiesViewHeight;
var x1 = Metrics.SafeGetScreenX(drawInfo.X1, viewWidth);
var x2 = Metrics.SafeGetScreenX(drawInfo.X2, viewWidth);
g.DrawLine(viewMetrics.MeasurerPen, x1, viewMetrics.MeasurerTop, x1, viewHeight);
g.DrawLine(viewMetrics.MeasurerPen, x2, viewMetrics.MeasurerTop, x2, viewHeight);
g.DrawLine(viewMetrics.MeasurerPen, x1, viewMetrics.MeasurerTop, x2, viewMetrics.MeasurerTop);
var textSz = g.MeasureString(drawInfo.Text, viewMetrics.MeasurerTextFont);
RectangleF textRect;
int textHPadding = 2;
if (textSz.Width < (x2 - x1 - 5))
{
textRect = new RectangleF(
(x2 + x1 - textSz.Width - textHPadding) / 2,
viewMetrics.MeasurerTop - textSz.Height / 2,
textSz.Width + textHPadding,
textSz.Height
);
}
else
{
textRect = new RectangleF(
x2 + 5,
viewMetrics.MeasurerTop - textSz.Height / 2,
textSz.Width + textHPadding,
textSz.Height
);
if (textRect.Right > viewMetrics.ActivitiesViewWidth)
{
textRect.X = x1 - 5 - textRect.Width;
}
}
g.FillRectangle(viewMetrics.MeasurerTextBoxBrush, textRect);
g.DrawRectangle(viewMetrics.MeasurerTextBoxPen, new RectangleF(textRect.X, textRect.Y, textRect.Width, textRect.Height));
g.DrawString(drawInfo.Text,
viewMetrics.MeasurerTextFont, viewMetrics.MeasurerTextBrush,
new PointF((textRect.X + textRect.Right) / 2, (textRect.Y + textRect.Bottom) / 2),
viewMetrics.MeasurerTextFormat);
}
public static void DrawBookmarks(
LJD.Graphics g,
ViewMetrics viewMetrics,
IViewEvents eventsHandler)
{
foreach (var evt in Metrics.GetBookmarksMetrics(g, viewMetrics, eventsHandler))
{
g.DrawLine(viewMetrics.BookmarkPen, evt.VertLineA, evt.VertLineB);
if (evt.Icon != null)
{
g.DrawImage(evt.Icon, evt.IconRect);
}
}
}
static int?GetActivityByPoint(Point pt, ViewMetrics vm, int activitiesCount)
{
if (pt.Y < vm.RulersPanelHeight)
{
return(null);
}
int idx = (pt.Y + vm.VScrollBarValue - vm.RulersPanelHeight) / vm.LineHeight;
if (idx >= activitiesCount)
{
return(null);
}
return(idx);
}
static LJD.Brush GetActivityBrush(ViewMetrics viewMetrics, ActivityType t)
{
switch (t)
{
case ActivityType.Lifespan: return(viewMetrics.LifetimeBrush);
case ActivityType.Procedure: return(viewMetrics.ProcedureBrush);
case ActivityType.IncomingNetworking: return(viewMetrics.NetworkMessageBrush);
case ActivityType.OutgoingNetworking: return(viewMetrics.NetworkMessageBrush);
default: return(viewMetrics.UnknownActivityBrush);
}
}
public static void DrawActivtiesView(
LJD.Graphics g,
ViewMetrics viewMetrics,
IViewEvents eventsHandler)
{
var viewSz = new Size(viewMetrics.ActivitiesViewWidth, viewMetrics.ActivitiesViewHeight);
Drawing.DrawActivitiesBackground(g, viewMetrics, eventsHandler);
Drawing.DrawRulerLines(g, viewMetrics, eventsHandler, DrawScope.VisibleRange, viewSz);
Drawing.DrawActivitiesTopBound(g, viewMetrics);
Drawing.DrawEvents(g, viewMetrics, eventsHandler);
Drawing.DrawBookmarks(g, viewMetrics, eventsHandler);
Drawing.DrawFocusedMessage(g, viewMetrics, eventsHandler, DrawScope.VisibleRange, viewSz);
Drawing.DrawActivities(g, viewMetrics, eventsHandler);
Drawing.DrawMeasurer(g, viewMetrics, eventsHandler);
}
public static void DrawCaptionsView(
LJD.Graphics g,
ViewMetrics viewMetrics,
IViewEvents eventsHandler,
int sequenceDiagramAreaWidth,
Action <string, Rectangle, int, int, bool> drawCaptionWithHighlightedRegion
)
{
PushGraphicsStateForDrawingActivites(g, viewMetrics, HitTestResult.AreaCode.CaptionsPanel);
int availableHeight = viewMetrics.ActivitiesViewHeight;
foreach (var a in eventsHandler.OnDrawActivities())
{
int y = Metrics.GetActivityY(viewMetrics, a.Index);
if (y < 0)
{
continue;
}
if (y > availableHeight)
{
break;
}
var h = viewMetrics.LineHeight - 1;
var sequenceDiagramTextRect = new Rectangle(0, y, sequenceDiagramAreaWidth, h);
var textRect = new Rectangle(
sequenceDiagramTextRect.Right + 3 /* text padding */, y, viewMetrics.ActivitesCaptionsViewWidth - sequenceDiagramTextRect.Right, h);
var lineRect = new Rectangle(0, y, viewMetrics.ActivitesCaptionsViewWidth, h);
if (a.IsSelected)
{
g.FillRectangle(viewMetrics.SelectedLineBrush, lineRect);
}
else if (a.Color.HasValue)
{
using (var bgBrush = MakeBrush(a.Color.Value))
g.FillRectangle(bgBrush, lineRect);
}
if (!string.IsNullOrEmpty(a.SequenceDiagramText))
{
g.DrawString(a.SequenceDiagramText, viewMetrics.ActivitesCaptionsFont, viewMetrics.ActivitesCaptionsBrush, sequenceDiagramTextRect);
}
drawCaptionWithHighlightedRegion(a.Caption, textRect, a.CaptionSelectionBegin, a.CaptionSelectionLength, a.IsError);
}
g.PopState();
}
public static void DrawRulerLines(
LJD.Graphics g,
ViewMetrics viewMetrics,
IViewEvents eventHandler,
DrawScope scope,
Size viewSize
)
{
double availableWidth = viewSize.Width;
foreach (var m in Metrics.GetRulerMarks(viewMetrics, eventHandler, scope))
{
int x = (int)(m.X * availableWidth);
g.DrawString(m.Label, viewMetrics.RulerMarkFont, viewMetrics.RulerMarkBrush, new Point(x, 2));
g.DrawLine(viewMetrics.RulerLinePen, x, 0, x, viewSize.Height);
}
}
public static void DrawNavigationPanel(
LJD.Graphics g,
ViewMetrics viewMetrics,
IViewEvents eventsHandler)
{
var panelClientRect = new Rectangle(0, 0, viewMetrics.NavigationPanelWidth, viewMetrics.NavigationPanelHeight);
g.FillRectangle(viewMetrics.NavigationPanel_InvisibleBackground, panelClientRect);
var m = Metrics.GetNavigationPanelMetrics(viewMetrics, eventsHandler);
g.FillRectangle(viewMetrics.NavigationPanel_VisibleBackground, m.VisibleRangeBox);
DrawRulerLines(g, viewMetrics, eventsHandler, DrawScope.AvailableRange, panelClientRect.Size);
double width = (double)viewMetrics.NavigationPanelWidth;
foreach (var evt in eventsHandler.OnDrawEvents(DrawScope.AvailableRange))
{
int x = (int)(evt.X * width);
g.DrawLine(viewMetrics.UserEventPen, x, 0, x, viewMetrics.NavigationPanelHeight);
}
foreach (var evt in eventsHandler.OnDrawBookmarks(DrawScope.AvailableRange))
{
int x = (int)(evt.X * width);
g.DrawLine(viewMetrics.BookmarkPen, x, 0, x, viewMetrics.NavigationPanelHeight);
}
var focusedMessagePos = eventsHandler.OnDrawFocusedMessage(DrawScope.AvailableRange);
if (focusedMessagePos.HasValue && focusedMessagePos.Value >= 0 && focusedMessagePos.Value <= 1)
{
int x = (int)(focusedMessagePos.Value * width);
g.DrawLine(viewMetrics.FocusedMessagePen, x, 0, x, viewMetrics.NavigationPanelHeight);
}
ResizerDrawing.DrawResizer(g, m.Resizer1, viewMetrics.SystemControlBrush);
ResizerDrawing.DrawResizer(g, m.Resizer2, viewMetrics.SystemControlBrush);
Rectangle visibleRangeBox = m.VisibleRangeBox;
visibleRangeBox.Width = Math.Max(visibleRangeBox.Width, 1);
g.DrawRectangle(viewMetrics.VisibleRangePen, visibleRangeBox);
}
public CursorType GetNavigationPanelCursor(
Point pt,
IViewModel eventsHandler
)
{
ViewMetrics vm = this;
var m = GetNavigationPanelMetrics(eventsHandler);
if (m.Resizer1.Contains(pt) || m.Resizer2.Contains(pt))
{
return(CursorType.SizeWE);
}
else if (m.VisibleRangeBox.Contains(pt))
{
return(CursorType.SizeAll);
}
return(CursorType.Default);
}
public static void DrawActivitiesBackground(
LJD.Graphics g,
ViewMetrics viewMetrics,
IViewEvents eventsHandler
)
{
PushGraphicsStateForDrawingActivites(g, viewMetrics, HitTestResult.AreaCode.ActivitiesPanel);
foreach (var a in Metrics.GetActivitiesMetrics(viewMetrics, eventsHandler))
{
if (a.Activity.IsSelected)
{
g.FillRectangle(viewMetrics.SelectedLineBrush, a.ActivityLineRect);
}
else if (a.Activity.Color.HasValue)
{
using (var bgBrush = MakeBrush(a.Activity.Color.Value))
g.FillRectangle(bgBrush, a.ActivityLineRect);
}
}
g.PopState();
}
public static int GetSequenceDiagramAreaMetrics(
LJD.Graphics g,
ViewMetrics viewMetrics,
IViewEvents eventsHandler
)
{
float maxTextWidth = 0;
if (eventsHandler != null)
{
foreach (var a in eventsHandler.OnDrawActivities())
{
if (!string.IsNullOrEmpty(a.SequenceDiagramText))
{
var w = g.MeasureString(a.SequenceDiagramText, viewMetrics.ActivitesCaptionsFont).Width;
maxTextWidth = Math.Max(maxTextWidth, w);
}
}
}
return(Math.Min((int)Math.Ceiling(maxTextWidth), viewMetrics.ActivitesCaptionsViewWidth / 2));
}
public void DrawActivities(LJD.Graphics g, ViewMetrics viewMetrics, IViewModel eventsHandler)
{
PushGraphicsStateForDrawingActivites(g, viewMetrics, HitTestResult.AreaCode.ActivitiesPanel);
var darkMode = eventsHandler.ColorTheme == Presenters.ColorThemeMode.Dark;
foreach (var a in viewMetrics.GetActivitiesMetrics(eventsHandler))
{
if (a.Activity.Type == ActivityDrawType.Group)
{
continue;
}
float round = 2;
g.FillRoundRectangle(GetActivityBrush(a.Activity.Type), a.ActivityBarRect, round);
foreach (var ph in a.Phases)
{
var phaseMargin = a.ActivityBarRect.Height / 3;
g.FillRectangle(ph.Brush, ph.X1, a.ActivityBarRect.Top + phaseMargin,
Math.Max(ph.X2 - ph.X1, 2), a.ActivityBarRect.Height - phaseMargin - 2);
}
foreach (var ms in a.Milestones)
{
g.DrawLine(res.MilestonePen, ms.X, a.ActivityBarRect.Top, ms.X, a.ActivityBarRect.Bottom);
}
g.DrawRoundRectangle(res.ActivityBarBoundsPen, a.ActivityBarRect, round);
if (a.PairedActivityConnectorBounds != null)
{
var r = a.PairedActivityConnectorBounds.Value;
g.DrawLine(res.ActivitiesConnectorPen, r.Left, r.Top, r.Left, r.Bottom);
g.DrawLine(res.ActivitiesConnectorPen, r.Right, r.Top, r.Right, r.Bottom);
}
}
g.PopState();
}
public void DrawActivitiesBackground(
LJD.Graphics g,
ViewMetrics viewMetrics,
IViewModel eventsHandler
)
{
PushGraphicsStateForDrawingActivites(g, viewMetrics, HitTestResult.AreaCode.ActivitiesPanel);
var darkMode = eventsHandler.ColorTheme == Presenters.ColorThemeMode.Dark;
foreach (var a in viewMetrics.GetActivitiesMetrics(eventsHandler))
{
if (a.Activity.IsSelected)
{
g.FillRectangle(res.SelectedActivityBackgroundBrush, a.ActivityLineRect);
}
else if (!darkMode && a.Activity.Color.HasValue)
{
using (var bgBrush = MakeBrush(a.Activity.Color.Value))
g.FillRectangle(bgBrush, a.ActivityLineRect);
}
}
g.PopState();
}
public static CursorType GetCursor(
Point pt,
ViewMetrics vm,
IViewEvents eventsHandler,
Func <LJD.Graphics> graphicsFactory
)
{
foreach (var a in Metrics.GetActivitiesMetrics(vm, eventsHandler))
{
bool overLink = false;
overLink = overLink || (a.BeginTriggerLinkRect.HasValue && a.BeginTriggerLinkRect.Value.Contains(pt));
overLink = overLink || (a.EndTriggerLinkRect.HasValue && a.EndTriggerLinkRect.Value.Contains(pt));
overLink = overLink || a.Milestones.Any(ms => ms.Bounds.HasValue && ms.Bounds.Value.Contains(pt));
if (overLink)
{
return(CursorType.Hand);
}
}
using (var g = graphicsFactory())
{
foreach (var bmk in Metrics.GetBookmarksMetrics(g, vm, eventsHandler))
{
if (bmk.IsOverLink(pt))
{
return(CursorType.Hand);
}
}
foreach (var evt in Metrics.GetEventMetrics(g, eventsHandler, vm))
{
if (evt.IsOverLink(pt))
{
return(CursorType.Hand);
}
}
}
return(CursorType.Default);
}
public static NavigationPanelMetrics GetNavigationPanelMetrics(
ViewMetrics viewMetrics,
IViewEvents eventsHandler)
{
NavigationPanelDrawInfo drawInfo = eventsHandler.OnDrawNavigationPanel();
double width = (double)viewMetrics.NavigationPanelWidth;
int x1 = (int)(width * drawInfo.VisibleRangeX1);
int x2 = (int)(width * drawInfo.VisibleRangeX2);
var visibleRangeBox = new Rectangle(x1, 1, x2 - x1, viewMetrics.NavigationPanelHeight - 4);
var resizerWidth = Math.Min(viewMetrics.VisibleRangeResizerWidth, Math.Abs(x2 - x1));
var resizer1 = new Rectangle(visibleRangeBox.Left + 1, visibleRangeBox.Top + 1,
resizerWidth, visibleRangeBox.Height - 1);
var resizer2 = new Rectangle(visibleRangeBox.Right - resizerWidth,
visibleRangeBox.Top + 1, resizerWidth, visibleRangeBox.Height - 1);
return(new NavigationPanelMetrics()
{
VisibleRangeBox = visibleRangeBox,
Resizer1 = resizer1,
Resizer2 = resizer2
});
}
static void PushGraphicsStateForDrawingActivites(LJD.Graphics g, ViewMetrics vm, HitTestResult.AreaCode area)
{
g.PushState();
g.IntsersectClip(new Rectangle(0, vm.RulersPanelHeight,
area == HitTestResult.AreaCode.CaptionsPanel ? vm.ActivitesCaptionsViewWidth : vm.ActivitiesViewWidth, vm.ActivitiesViewHeight));
}
public static HitTestResult HitTest(
Point pt,
ViewMetrics viewMetrics,
IViewEvents eventsHandler,
bool isCaptionsView,
Func <LJD.Graphics> graphicsFactory
)
{
HitTestResult ret = new HitTestResult();
double viewWidth = viewMetrics.ActivitiesViewWidth;
ret.RelativeX = (double)pt.X / viewWidth;
ret.ActivityIndex = GetActivityByPoint(pt, viewMetrics);
if (isCaptionsView)
{
ret.Area = HitTestResult.AreaCode.CaptionsPanel;
return(ret);
}
using (var g = graphicsFactory())
{
foreach (var bmk in GetBookmarksMetrics(g, viewMetrics, eventsHandler))
{
if (bmk.IsOverLink(pt))
{
ret.Area = HitTestResult.AreaCode.BookmarkTrigger;
ret.Trigger = bmk.Bookmark.Trigger;
return(ret);
}
}
foreach (var evt in GetEventMetrics(g, eventsHandler, viewMetrics).Reverse())
{
if (evt.IsOverLink(pt))
{
ret.Area = HitTestResult.AreaCode.EventTrigger;
ret.Trigger = evt.Event.Trigger;
return(ret);
}
}
}
if (pt.Y < viewMetrics.RulersPanelHeight)
{
ret.Area = HitTestResult.AreaCode.RulersPanel;
return(ret);
}
foreach (var a in GetActivitiesMetrics(viewMetrics, eventsHandler))
{
foreach (var ms in a.Milestones)
{
if (ms.Bounds.HasValue && ms.Bounds.Value.Contains(pt))
{
ret.Area = HitTestResult.AreaCode.ActivityTrigger;
ret.Trigger = ms.Trigger;
return(ret);
}
}
if (a.BeginTriggerLinkRect.HasValue && a.BeginTriggerLinkRect.Value.Contains(pt))
{
ret.Area = HitTestResult.AreaCode.ActivityTrigger;
ret.Trigger = a.Activity.BeginTrigger;
return(ret);
}
if (a.EndTriggerLinkRect.HasValue && a.EndTriggerLinkRect.Value.Contains(pt))
{
ret.Area = HitTestResult.AreaCode.ActivityTrigger;
ret.Trigger = a.Activity.EndTrigger;
return(ret);
}
}
ret.Area = HitTestResult.AreaCode.ActivitiesPanel;
return(ret);
}
public static int GetActivityY(ViewMetrics viewMetrics, int index)
{
return(viewMetrics.RulersPanelHeight - viewMetrics.VScrollBarValue + index * viewMetrics.LineHeight);
}
public static IEnumerable <BookmarkMetrics> GetBookmarksMetrics(LJD.Graphics g, ViewMetrics viewMetrics, IViewEvents eventsHandler)
{
double availableWidth = viewMetrics.ActivitiesViewWidth;
foreach (var bmk in eventsHandler.OnDrawBookmarks(DrawScope.VisibleRange))
{
if (bmk.X < 0 || bmk.X > 1)
{
continue;
}
BookmarkMetrics m = new BookmarkMetrics()
{
Bookmark = bmk
};
int x = SafeGetScreenX(bmk.X, availableWidth);
int bmkLineTop = viewMetrics.RulersPanelHeight - 7;
m.VertLineA = new Point(x, bmkLineTop);
m.VertLineB = new Point(x, viewMetrics.ActivitiesViewHeight);
m.Icon = viewMetrics.BookmarkIcon;
var sz = m.Icon.GetSize(height: 5.1f).Scale(viewMetrics.DPIScale);
m.IconRect = new RectangleF(
x - sz.Width / 2, bmkLineTop - sz.Height, sz.Width, sz.Height);
yield return(m);
}
}
public static IEnumerable <EventMetrics> GetEventMetrics(LJD.Graphics g, IViewEvents eventsHandler, ViewMetrics viewMetrics)
{
double availableWidth = viewMetrics.ActivitiesViewWidth;
int lastEventRight = int.MinValue;
int overlappingEventsCount = 0;
foreach (var evt in eventsHandler.OnDrawEvents(DrawScope.VisibleRange))
{
if (evt.X < 0 || evt.X > 1)
{
continue;
}
EventMetrics m = new EventMetrics()
{
Event = evt
};
int eventLineTop = viewMetrics.RulersPanelHeight - 2;
var szF = g.MeasureString(evt.Caption, viewMetrics.ActionCaptionFont);
var sz = new Size((int)szF.Width, (int)szF.Height);
int x = SafeGetScreenX(evt.X, availableWidth);
var bounds = new Rectangle(x - sz.Width / 2, eventLineTop - sz.Height, sz.Width, sz.Height);
bounds.Inflate(2, 0);
if (bounds.Left < lastEventRight)
{
++overlappingEventsCount;
bounds.Offset(lastEventRight - bounds.Left + 2, 0);
var mid = (bounds.Left + bounds.Right) / 2;
var y2 = eventLineTop + 5 * overlappingEventsCount;
m.VertLinePoints = new Point[]
{
new Point(mid, eventLineTop),
new Point(mid, y2),
new Point(x, y2),
new Point(x, viewMetrics.ActivitiesViewHeight)
};
}
else
{
overlappingEventsCount = 0;
m.VertLineA = new Point(x, eventLineTop);
m.VertLineB = new Point(x, viewMetrics.ActivitiesViewHeight);
}
m.CaptionRect = bounds;
m.CaptionDrawingOrigin = new Point((bounds.Left + bounds.Right) / 2, eventLineTop);
if (evt.Type == EventType.UserAction)
{
m.Icon = viewMetrics.UserIcon;
}
else if (evt.Type == EventType.APICall)
{
m.Icon = viewMetrics.APIIcon;
}
if (m.Icon != null)
{
var imgsz = m.Icon.GetSize(height: 14f).Scale(viewMetrics.DPIScale);
m.IconRect = new RectangleF(
m.CaptionDrawingOrigin.X - imgsz.Width / 2,
viewMetrics.RulersPanelHeight - imgsz.Height - viewMetrics.ActionLebelHeight,
imgsz.Width, imgsz.Height
);
}
lastEventRight = bounds.Right;
yield return(m);
}
}
public static IEnumerable <ActivityMetrics> GetActivitiesMetrics(ViewMetrics viewMetrics, IViewEvents eventsHandler)
{
double availableWidth = viewMetrics.ActivitiesViewWidth;
int availableHeight = viewMetrics.ActivitiesViewHeight;
foreach (var a in eventsHandler.OnDrawActivities())
{
int y = GetActivityY(viewMetrics, a.Index);
if (y < 0 || y > availableHeight)
{
continue;
}
var activityLineRect = new Rectangle(0, y, (int)availableWidth, viewMetrics.LineHeight);
var x1 = SafeGetScreenX(a.X1, availableWidth);
var x2 = SafeGetScreenX(a.X2, availableWidth);
var activityBarRect = new Rectangle(x1, y, Math.Max(1, x2 - x1), viewMetrics.LineHeight);
activityBarRect.Inflate(0, -viewMetrics.ActivityBarRectPaddingY);
var ret = new ActivityMetrics()
{
Activity = a,
ActivityLineRect = activityLineRect,
ActivityBarRect = activityBarRect
};
var limitedTriggerLinkWidth = Math.Min(viewMetrics.TriggerLinkWidth, ret.ActivityBarRect.Width);
if (a.BeginTrigger != null)
{
ret.BeginTriggerLinkRect = new Rectangle(activityBarRect.Location, new Size(limitedTriggerLinkWidth, activityBarRect.Height));
}
if (a.EndTrigger != null)
{
ret.EndTriggerLinkRect = new Rectangle(activityBarRect.Right - limitedTriggerLinkWidth, activityBarRect.Top, limitedTriggerLinkWidth, activityBarRect.Height);
}
if (a.BeginTrigger != null && a.EndTrigger != null && // if both links are to be displayed
ret.ActivityBarRect.Width < viewMetrics.TriggerLinkWidth * 2) // but no room available for both
{
// show only link for 'begin' trigger
ret.EndTriggerLinkRect = null;
}
bool milestonesWillFit = ret.ActivityBarRect.Width > viewMetrics.TriggerLinkWidth * a.MilestonesCount;
ret.Milestones = a.Milestones.Select(ms =>
{
var msX = SafeGetScreenX(ms.X, availableWidth);
Rectangle?bounds = null;
if (ms.Trigger != null && milestonesWillFit)
{
var boundsX1 = Math.Max(msX - viewMetrics.TriggerLinkWidth / 2, activityBarRect.Left);
var boundsX2 = Math.Min(msX + viewMetrics.TriggerLinkWidth / 2, activityBarRect.Right);
bounds = new Rectangle(
boundsX1,
activityBarRect.Y,
boundsX2 - boundsX1,
activityBarRect.Height
);
}
return(new ActivityMilestoneMetrics()
{
X = msX, Bounds = bounds, Trigger = ms.Trigger
});
});
if (a.PairedActivityIndex != null)
{
int pairedY = GetActivityY(viewMetrics, a.PairedActivityIndex.Value);
if (y < pairedY)
{
ret.PairedActivityConnectorBounds = new Rectangle(
activityBarRect.X, activityBarRect.Bottom,
activityBarRect.Width, pairedY - activityBarRect.Bottom + viewMetrics.ActivityBarRectPaddingY
);
}
else
{
int y2 = pairedY + viewMetrics.LineHeight - viewMetrics.ActivityBarRectPaddingY;
ret.PairedActivityConnectorBounds = new Rectangle(
activityBarRect.X, y2,
activityBarRect.Width, activityBarRect.Y - y2
);
}
}
yield return(ret);
}
}
double GetVertScrollerValueRange(ViewMetrics viewMetrics)
{
return(Math.Max(0, model.ActivitiesCount * viewMetrics.LineHeight - (viewMetrics.ActivitiesViewHeight - viewMetrics.RulersPanelHeight)));
}
