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();
}
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 void Init(LegendItemInfo item, Drawing.Resources resources, IViewEvents events)
{
this.item = item;
this.resources = resources;
this.events = events;
previewView.NeedsDisplay = true;
}
void IView.SetEventsHandler(IViewEvents eventsHandler)
{
this.eventsHandler = eventsHandler;
myWebBrowser.Init(eventsHandler);
myWebBrowser.Navigated += (sender, args) => eventsHandler.OnBrowserNavigated(args.Url);
myWebBrowser.Navigating += (sender, args) => eventsHandler.OnBrowserNavigated(args.Url);
}
public static IEnumerable <TLRulerMark> GetRulerMarks(
ViewMetrics viewMetrics,
IViewEvents eventsHandler,
DrawScope scope
)
{
return(eventsHandler.OnDrawRulers(scope, viewMetrics.ActivitiesViewWidth, viewMetrics.DistnanceBetweenRulerMarks));
}
public MainFrame()
{
_ya12306 = new Ya12306(this);
_loginForm = new LoginForm(_client);
InitializeComponent();
WindowsInterop.SecurityAlertDialogWillBeShown += _ => true;
_autoQueryTimer.Tick += AutoQueryTimerTick;
_autoQueryTimer.Interval = 10000;
}
public void Init()
{
view = Substitute.For <IView>();
view.When(v => v.SetPresenter(Arg.Any <IViewEvents>())).Do(
x => eventsHandler = x.Arg <IViewEvents>());
presenter = new Presenter(view);
onSearchNowRaised = 0;
presenter.OnSearchNow += (sender, e) => ++ onSearchNowRaised;
onCurrentSuggestionChanged = 0;
presenter.OnCurrentSuggestionChanged += (sender, e) => ++ onCurrentSuggestionChanged;
}
void IView.SetPresenter(IViewEvents presenter)
{
this.presenter = presenter;
this.presentationDataAccess = presenter as IPresentationDataAccess;
if (presentationDataAccess.FontName != null && (LogJoint.Properties.Settings.Default.MonospaceBookmarks ?? "") == "1")
{
linkDisplayFont.Dispose();
linkDisplayFont = new Font(presentationDataAccess.FontName, 8f, FontStyle.Underline);
}
}
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 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;
}
}
}
}
}
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);
}
}
}
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 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;
}
}
}
}
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 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 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
});
}
public SourceDetailsForm(IViewEvents viewEvents)
{
InitializeComponent();
this.viewEvents = viewEvents;
controls[ControlFlag.NameEditbox] = nameTextBox;
controls[ControlFlag.FormatTextBox] = formatTextBox;
controls[ControlFlag.VisibleCheckBox] = visibleCheckBox;
controls[ControlFlag.ColorPanel] = colorPanel;
controls[ControlFlag.StateDetailsLink] = stateDetailsLink;
controls[ControlFlag.StateLabel] = stateLabel;
controls[ControlFlag.LoadedMessagesTextBox] = loadedMessagesTextBox;
controls[ControlFlag.LoadedMessagesWarningIcon] = loadedMessagesWarningIcon;
controls[ControlFlag.LoadedMessagesWarningLinkLabel] = loadedMessagesWarningLinkLabel;
controls[ControlFlag.TrackChangesLabel] = trackChangesLabel;
controls[ControlFlag.SuspendResumeTrackingLink] = suspendResumeTrackingLink;
controls[ControlFlag.FirstMessageLinkLabel] = firstMessageLinkLabel;
controls[ControlFlag.LastMessageLinkLabel] = lastMessageLinkLabel;
controls[ControlFlag.SaveAsButton] = saveAsButton;
controls[ControlFlag.AnnotationTextBox] = annotationTextBox;
controls[ControlFlag.TimeOffsetTextBox] = timeOffsetTextBox;
controls[ControlFlag.CopyPathButton] = copyPathLink;
}
void IView.SetPresenter(IViewEvents viewEvents)
{
this.viewEvents = viewEvents;
}
void IView.SetEventsHandler(IViewEvents handler)
{
this.eventsHandler = handler;
}
void IView.SetEventsHandler(IViewEvents eventsHandler)
{
this.eventsHandler = eventsHandler;
View.EnsureCreated();
}
void IView.SetPresenter(IViewEvents presenter)
{
this.presenter = presenter;
}
void IView.SetViewEvents(IViewEvents viewEvents)
{
this.viewEvents = viewEvents;
}
void IView.SetEventsHandler(IViewEvents eventsHandler)
{
this.viewEvents = eventsHandler;
}
void IView.SetPresenter(IViewEvents presenter)
{
this.eventsHandler = presenter;
}
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 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);
}
}
