public Presenter(
IBookmarks bookmarks,
IFiltersList hlFilters,
IView view,
LogViewer.IPresenter viewerPresenter,
IPresentersFacade navHandler)
{
this.hlFilters = hlFilters;
this.bookmarks = bookmarks;
this.view = view;
this.viewerPresenter = viewerPresenter;
this.navHandler = navHandler;
viewerPresenter.FocusedMessageChanged += delegate(object sender, EventArgs args)
{
if (GetPropertiesForm() != null)
{
GetPropertiesForm().UpdateView(viewerPresenter.FocusedMessage);
}
};
bookmarks.OnBookmarksChanged += (sender, args) =>
{
var focused = viewerPresenter.FocusedMessage;
if (GetPropertiesForm() != null && focused != null)
{
if (args.AffectedBookmarks.Any(b => b.Position == focused.Position))
{
GetPropertiesForm().UpdateView(focused);
}
}
};
}
public ThreadPropertiesForm(IThread thread, IPresentersFacade handler)
{
this.thread = thread;
this.handler = handler;
InitializeComponent();
UpdateView();
}
void IView.ExecuteThreadPropertiesDialog(IThread thread, IPresentersFacade navHandler, IColorTheme theme)
{
using (UI.ThreadPropertiesForm f = new UI.ThreadPropertiesForm(thread, navHandler, theme))
{
f.ShowDialog();
}
}
public Presenter(
ILogSourcesManager logSources,
IView view,
ILogSourcesPreprocessingManager logSourcesPreprocessings,
SourcePropertiesWindow.IPresenter propertiesWindowPresenter,
LogViewer.IPresenter logViewerPresenter,
IPresentersFacade navHandler,
IAlertPopup alerts,
IFileDialogs fileDialogs,
IClipboardAccess clipboard,
IShellOpen shellOpen,
SaveJointLogInteractionPresenter.IPresenter saveJointLogInteractionPresenter
)
{
this.logSources = logSources;
this.view = view;
this.propertiesWindowPresenter = propertiesWindowPresenter;
this.logViewerPresenter = logViewerPresenter;
this.logSourcesPreprocessings = logSourcesPreprocessings;
this.alerts = alerts;
this.fileDialogs = fileDialogs;
this.clipboard = clipboard;
this.shellOpen = shellOpen;
this.saveJointLogInteractionPresenter = saveJointLogInteractionPresenter;
logViewerPresenter.FocusedMessageChanged += (sender, args) =>
{
view.InvalidateFocusedMessageArea();
};
view.SetPresenter(this);
}
public Presenter(
IBookmarks bookmarks,
IView view,
LogViewer.IPresenter viewerPresenter,
SearchResult.IPresenter searchResultPresenter,
BookmarksList.IPresenter listPresenter,
StatusReports.IPresenter statusReportFactory,
IPresentersFacade navHandler,
IAlertPopup alerts,
ITraceSourceFactory traceSourceFactory
)
{
this.bookmarks = bookmarks;
this.view = view;
this.viewerPresenter = viewerPresenter;
this.tracer = traceSourceFactory.CreateTraceSource("UI", "ui.bmkm");
this.statusReportFactory = statusReportFactory;
this.searchResultPresenter = searchResultPresenter;
this.navHandler = navHandler;
this.listPresenter = listPresenter;
this.alerts = alerts;
listPresenter.Click += (s, bmk) =>
{
IPresenter myPublicIntf = this;
myPublicIntf.NavigateToBookmark(bmk, BookmarkNavigationOptions.EnablePopups | BookmarkNavigationOptions.BookmarksStringsSet);
};
view.SetPresenter(this);
}
public Presenter(
IBookmarks bookmarks,
IView view,
LogViewer.IPresenter viewerPresenter,
SearchResult.IPresenter searchResultPresenter,
BookmarksList.IPresenter listPresenter,
StatusReports.IPresenter statusReportFactory,
IPresentersFacade navHandler,
IViewUpdates viewUpdates,
IAlertPopup alerts)
{
this.bookmarks = bookmarks;
this.view = view;
this.viewerPresenter = viewerPresenter;
this.tracer = new LJTraceSource("UI", "ui.bmkm");
this.statusReportFactory = statusReportFactory;
this.searchResultPresenter = searchResultPresenter;
this.viewUpdates = viewUpdates;
this.navHandler = navHandler;
this.listPresenter = listPresenter;
this.alerts = alerts;
viewerPresenter.FocusedMessageBookmarkChanged += delegate(object sender, EventArgs args)
{
listPresenter.SetMasterFocusedMessage(viewerPresenter.GetFocusedMessageBookmark());
};
listPresenter.Click += (s, bmk) =>
{
IPresenter myPublicIntf = this;
myPublicIntf.NavigateToBookmark(bmk, BookmarkNavigationOptions.EnablePopups | BookmarkNavigationOptions.BookmarksStringsSet);
};
view.SetPresenter(this);
}
public Presenter(
IBookmarks bookmarks,
IFiltersList hlFilters,
IView view,
LogViewer.IPresenterInternal viewerPresenter,
IPresentersFacade navHandler,
IColorTheme theme,
IChangeNotification parentChangeNotification,
Telemetry.ITelemetryCollector telemetryCollector
)
{
this.hlFilters = hlFilters;
this.bookmarks = bookmarks;
this.view = view;
this.viewerPresenter = viewerPresenter;
this.navHandler = navHandler;
this.changeNotification = parentChangeNotification.CreateChainedChangeNotification(false);
this.getFocusedMessage = Selectors.Create(() => viewerPresenter.FocusedMessage,
message => message?.GetLogSource() == null ? null : message);
var getBookmarkData = bookmarks == null ? () => (null, null) :
Selectors.Create(getFocusedMessage, () => bookmarks.Items, (focused, bmks) =>
{
if (focused == null)
{
return(noSelection, null);
}
var isBookmarked = IsMessageBookmarked(focused);
return(isBookmarked ? "yes" : "no", isBookmarked ? "clear bookmark" : "set bookmark");
});
public Presenter(
IView view,
ILogSourcesManager logSources,
Preprocessing.ILogSourcesPreprocessingManager preprocessings,
IPresentersFacade navHandler,
IAlertPopup alerts,
IClipboardAccess clipboard,
IShellOpen shellOpen
)
{
this.view = view;
this.presentersFacade = navHandler;
this.alerts = alerts;
this.preprocessings = preprocessings;
this.clipboard = clipboard;
this.shellOpen = shellOpen;
this.logSources = logSources;
view.SetEventsHandler(this);
logSources.OnLogSourceColorChanged += (s, e) =>
{
if (object.ReferenceEquals(s, source) && currentWindow != null)
{
UpdateColorPanel();
}
};
}
public PresenterFactory(
IHeartBeatTimer heartbeat,
IPresentersFacade presentationFacade,
IClipboardAccess clipboard,
IBookmarksFactory bookmarksFactory,
Telemetry.ITelemetryCollector telemetry,
ILogSourcesManager logSources,
IInvokeSynchronization modelInvoke,
IModelThreads modelThreads,
IFiltersList hlFilters,
IBookmarks bookmarks,
Settings.IGlobalSettingsAccessor settings,
ISearchManager searchManager,
IFiltersFactory filtersFactory
)
{
this.heartbeat = heartbeat;
this.presentationFacade = presentationFacade;
this.clipboard = clipboard;
this.bookmarksFactory = bookmarksFactory;
this.telemetry = telemetry;
this.logSources = logSources;
this.modelInvoke = modelInvoke;
this.modelThreads = modelThreads;
this.hlFilters = hlFilters;
this.bookmarks = bookmarks;
this.settings = settings;
this.searchManager = searchManager;
this.filtersFactory = filtersFactory;
}
public Presenter(
ILogSourcesManager sourcesManager,
Preprocessing.ILogSourcesPreprocessingManager preprocessingManager,
IInvokeSynchronization invoker,
IHeartBeatTimer heartbeat,
IPresentersFacade presentersFacade,
StatusReports.IPresenter statusReports
)
{
this.preprocessingManager = preprocessingManager;
this.presentersFacade = presentersFacade;
this.statusReports = statusReports;
this.updateInvokeHelper = new AsyncInvokeHelper(invoker, Update)
{
ForceAsyncInvocation = true
};
sourcesManager.OnLogSourceStatsChanged += (sender, e) =>
{
bool?logSourceNeedsFixing = null;
if ((e.Flags & LogProviderStatsFlag.FirstMessageWithTimeConstraintViolation) != 0 ||
(e.Flags & LogProviderStatsFlag.Error) != 0)
{
var badMsg = ((ILogSource)sender).Provider.Stats.FirstMessageWithTimeConstraintViolation;
var failedWithBoundaryDates = ((ILogSource)sender).Provider.Stats.Error is BadBoundaryDatesException;
logSourceNeedsFixing = badMsg != null || failedWithBoundaryDates;
}
if (logSourceNeedsFixing != null)
{
bool updated;
if (logSourceNeedsFixing.Value)
{
updated = logSourcesRequiringReordering.Add((ILogSource)sender);
}
else
{
updated = logSourcesRequiringReordering.Remove((ILogSource)sender);
}
if (updated)
{
updateFlag.Invalidate();
}
}
};
sourcesManager.OnLogSourceRemoved += (sender, e) =>
{
updateFlag.Invalidate();
};
heartbeat.OnTimer += (sender, e) =>
{
if (e.IsNormalUpdate && updateFlag.Validate())
{
Update();
}
};
}
public StateInspectorPresenter(
IView view,
IStateInspectorVisualizerModel model,
IUserNamesProvider shortNames,
ILogSourcesManager logSources,
LoadedMessages.IPresenter loadedMessagesPresenter,
IBookmarks bookmarks,
IModelThreads threads,
IPresentersFacade presentersFacade,
IClipboardAccess clipboardAccess,
SourcesManager.IPresenter sourcesManagerPresenter,
IColorTheme theme
)
{
this.view = view;
this.model = model;
this.shortNames = shortNames;
this.threads = threads;
this.presentersFacade = presentersFacade;
this.bookmarks = bookmarks;
this.clipboardAccess = clipboardAccess;
this.sourcesManagerPresenter = sourcesManagerPresenter;
this.loadedMessagesPresenter = loadedMessagesPresenter;
this.theme = theme;
view.SetEventsHandler(this);
logSources.OnLogSourceAnnotationChanged += (sender, e) =>
{
InvalidateTree();
};
loadedMessagesPresenter.LogViewerPresenter.FocusedMessageChanged += (sender, args) =>
{
HandleFocusedMessageChange();
};
bookmarks.OnBookmarksChanged += (sender, args) =>
{
view.BeginUpdateStateHistoryList(false, false);
view.EndUpdateStateHistoryList(null, false, redrawFocusedMessageMark: true);
};
model.Changed += (sender, args) =>
{
InvalidateTree();
HandleFocusedMessageChange();
RemoveMissingGroupsFromCache();
};
InvalidateTree();
HandleFocusedMessageChange();
}
public Presenter(
IView view,
ILogSourcesManager logSources,
Preprocessing.IManager preprocessings,
IModelThreads threads,
IPresentersFacade navHandler,
IAlertPopup alerts,
IClipboardAccess clipboard,
IShellOpen shellOpen,
IColorTheme theme,
IHeartBeatTimer heartBeat,
IChangeNotification changeNotification
)
{
this.view = view;
this.presentersFacade = navHandler;
this.alerts = alerts;
this.preprocessings = preprocessings;
this.clipboard = clipboard;
this.shellOpen = shellOpen;
this.theme = theme;
this.changeNotification = changeNotification.CreateChainedChangeNotification(initiallyActive: false);
logSources.OnLogSourceStatsChanged += (s, e) =>
{
if (s == logSources)
{
pendingUpdateFlag.Invalidate();
}
};
threads.OnThreadListChanged += (s, e) => pendingUpdateFlag.Invalidate();
threads.OnThreadPropertiesChanged += (s, e) => pendingUpdateFlag.Invalidate();
heartBeat.OnTimer += (s, e) =>
{
if (pendingUpdateFlag.Validate())
{
++forceUpdateRevision;
changeNotification.Post();
}
};
this.getViewState = () => emptyViewState;
view.SetViewModel(this);
}
public Presenter(
IModelThreads threads,
ILogSourcesManager logSources,
IView view,
Presenters.LogViewer.IPresenter viewerPresenter,
IPresentersFacade navHandler,
IViewUpdates viewUpdates,
IHeartBeatTimer heartbeat)
{
this.threads = threads;
this.view = view;
this.viewerPresenter = viewerPresenter;
this.navHandler = navHandler;
this.viewUpdates = viewUpdates;
viewerPresenter.FocusedMessageChanged += delegate(object sender, EventArgs args)
{
view.UpdateFocusedThreadView();
};
threads.OnThreadListChanged += (sender, args) =>
{
updateTracker.Invalidate();
};
threads.OnThreadVisibilityChanged += (sender, args) =>
{
updateTracker.Invalidate();
};
threads.OnPropertiesChanged += (sender, args) =>
{
updateTracker.Invalidate();
};
logSources.OnLogSourceVisiblityChanged += (sender, args) =>
{
updateTracker.Invalidate();
};
heartbeat.OnTimer += (sender, args) =>
{
if (args.IsNormalUpdate && updateTracker.Validate())
{
UpdateView();
}
};
view.SetPresenter(this);
}
public PresenterFactory(
IChangeNotification changeNotification,
IHeartBeatTimer heartbeat,
IPresentersFacade presentationFacade,
IClipboardAccess clipboard,
IBookmarksFactory bookmarksFactory,
Telemetry.ITelemetryCollector telemetry,
ILogSourcesManager logSources,
ISynchronizationContext modelInvoke,
IModelThreads modelThreads,
IFiltersList hlFilters,
IBookmarks bookmarks,
Settings.IGlobalSettingsAccessor settings,
ISearchManager searchManager,
IFiltersFactory filtersFactory,
IColorTheme theme,
ITraceSourceFactory traceSourceFactory,
RegularExpressions.IRegexFactory regexFactory
)
{
this.changeNotification = changeNotification;
this.heartbeat = heartbeat;
this.presentationFacade = presentationFacade;
this.clipboard = clipboard;
this.bookmarksFactory = bookmarksFactory;
this.telemetry = telemetry;
this.logSources = logSources;
this.modelInvoke = modelInvoke;
this.modelThreads = modelThreads;
this.hlFilters = hlFilters;
this.bookmarks = bookmarks;
this.settings = settings;
this.searchManager = searchManager;
this.filtersFactory = filtersFactory;
this.theme = theme;
this.traceSourceFactory = traceSourceFactory;
this.regexFactory = regexFactory;
}
public Factory(
IViewsFactory postprocessingViewsFactory,
IManager postprocessorsManager,
ILogSourcesManager logSourcesManager,
ISynchronizationContext synchronizationContext,
IChangeNotification changeNotification,
IBookmarks bookmarks,
IModelThreads threads,
Persistence.IStorageManager storageManager,
ILogSourceNamesProvider logSourceNamesProvider,
IUserNamesProvider shortNames,
SourcesManager.IPresenter sourcesManagerPresenter,
LoadedMessages.IPresenter loadedMessagesPresenter,
IClipboardAccess clipboardAccess,
IPresentersFacade presentersFacade,
IAlertPopup alerts,
IColorTheme colorTheme
)
{
this.postprocessingViewsFactory = postprocessingViewsFactory;
this.postprocessorsManager = postprocessorsManager;
this.logSourcesManager = logSourcesManager;
this.synchronizationContext = synchronizationContext;
this.changeNotification = changeNotification;
this.bookmarks = bookmarks;
this.threads = threads;
this.storageManager = storageManager;
this.logSourceNamesProvider = logSourceNamesProvider;
this.shortNames = shortNames;
this.sourcesManagerPresenter = sourcesManagerPresenter;
this.loadedMessagesPresenter = loadedMessagesPresenter;
this.clipboardAccess = clipboardAccess;
this.presentersFacade = presentersFacade;
this.alerts = alerts;
this.colorTheme = colorTheme;
}
public StateInspectorPresenter(
IView view,
IStateInspectorVisualizerModel model,
IUserNamesProvider shortNames,
ILogSourcesManager logSources,
LoadedMessages.IPresenter loadedMessagesPresenter,
IBookmarks bookmarks,
IModelThreads threads,
IPresentersFacade presentersFacade,
IClipboardAccess clipboardAccess,
SourcesManager.IPresenter sourcesManagerPresenter,
IColorTheme theme,
IChangeNotification changeNotification
)
{
this.view = view;
this.model = model;
this.shortNames = shortNames;
this.threads = threads;
this.presentersFacade = presentersFacade;
this.bookmarks = bookmarks;
this.clipboardAccess = clipboardAccess;
this.sourcesManagerPresenter = sourcesManagerPresenter;
this.loadedMessagesPresenter = loadedMessagesPresenter;
this.theme = theme;
this.changeNotification = changeNotification.CreateChainedChangeNotification(initiallyActive: false);
var annotationsVersion = 0;
logSources.OnLogSourceAnnotationChanged += (sender, e) =>
{
annotationsVersion++;
changeNotification.Post();
};
var getAnnotationsMap = Selectors.Create(
() => logSources.Items,
() => annotationsVersion,
(sources, _) =>
sources
.Where(s => !s.IsDisposed && !string.IsNullOrEmpty(s.Annotation))
.ToImmutableDictionary(s => s, s => s.Annotation)
);
VisualizerNode rootNode = new VisualizerNode(null, ImmutableList <VisualizerNode> .Empty, true, false, 0, ImmutableDictionary <ILogSource, string> .Empty);
var updateRoot = Updaters.Create(
() => model.Groups,
getAnnotationsMap,
(groups, annotationsMap) => rootNode = MakeRootNode(groups, OnNodeCreated, annotationsMap, rootNode)
);
this.getRootNode = () =>
{
updateRoot();
return(rootNode);
};
this.updateRootNode = reducer =>
{
var oldRoot = getRootNode();
var newRoot = reducer(oldRoot);
if (oldRoot != newRoot)
{
rootNode = newRoot;
changeNotification.Post();
}
};
this.getSelectedNodes = Selectors.Create(
getRootNode,
(root) =>
{
var result = ImmutableArray.CreateBuilder <VisualizerNode>();
void traverse(VisualizerNode n)
{
if (!n.HasSelectedNodes)
{
return;
}
if (n.IsSelected)
{
result.Add(n);
}
foreach (var c in n.Children)
{
traverse(c);
}
}
traverse(root);
return(result.ToImmutable());
}
);
this.getSelectedInspectedObjects = Selectors.Create(
getSelectedNodes,
nodes => ImmutableArray.CreateRange(nodes.Select(n => n.InspectedObject))
);
this.getStateHistoryItems = Selectors.Create(
getSelectedInspectedObjects,
() => selectedHistoryEvents,
MakeSelectedObjectHistory
);
this.getIsHistoryItemBookmarked = Selectors.Create(
() => bookmarks.Items,
boormarksItems =>
{
Predicate <IStateHistoryItem> result = (item) =>
{
var change = (item as StateHistoryItem)?.Event;
if (change == null || change.Output.LogSource.IsDisposed)
{
return(false);
}
var bmk = bookmarks.Factory.CreateBookmark(
change.Trigger.Timestamp.Adjust(change.Output.LogSource.TimeOffsets),
change.Output.LogSource.GetSafeConnectionId(), change.Trigger.StreamPosition, 0);
var pos = boormarksItems.FindBookmark(bmk);
return(pos.Item2 > pos.Item1);
};
return(result);
}
);
this.getFocusedMessageInfo = () => loadedMessagesPresenter.LogViewerPresenter.FocusedMessage;
this.getFocusedMessageEqualRange = Selectors.Create(
getFocusedMessageInfo,
focusedMessageInfo =>
{
var cache = new Dictionary <IStateInspectorOutputsGroup, FocusedMessageEventsRange>();
Func <IStateInspectorOutputsGroup, FocusedMessageEventsRange> result = forGroup =>
{
if (!cache.TryGetValue(forGroup, out FocusedMessageEventsRange eventsRange))
{
eventsRange = new FocusedMessageEventsRange(focusedMessageInfo,
forGroup.Events.CalcFocusedMessageEqualRange(focusedMessageInfo));
cache.Add(forGroup, eventsRange);
}
return(eventsRange);
};
return(result);
}
);
this.getPaintNode = Selectors.Create(
getFocusedMessageEqualRange,
MakePaintNodeDelegate
);
this.getFocusedMessagePositionInHistory = Selectors.Create(
getStateHistoryItems,
getFocusedMessageInfo,
(changes, focusedMessage) =>
{
return
(focusedMessage == null ? null :
new ListUtils.VirtualList <StateInspectorEvent>(changes.Length,
i => changes[i].Event).CalcFocusedMessageEqualRange(focusedMessage));
}
);
this.getCurrentTimeLabelText = Selectors.Create(
getFocusedMessageInfo,
focusedMsg => focusedMsg != null ? $"at {focusedMsg.Time}" : ""
);
this.getCurrentProperties = Selectors.Create(
getSelectedInspectedObjects,
getFocusedMessageEqualRange,
() => selectedProperty,
MakeCurrentProperties
);
this.getPropertyItems = Selectors.Create(
getCurrentProperties,
props => (IReadOnlyList <IPropertyListItem>)props.Cast <IPropertyListItem>().ToImmutableArray()
);
this.getObjectsProperties = Selectors.Create(
getCurrentProperties,
props => (IReadOnlyList <KeyValuePair <string, object> >)props.Select(p => p.ToDataSourceItem()).ToImmutableArray()
);
view.SetViewModel(this);
}
public Presenter(
ILogSourcesManager logSources,
IUserDefinedFormatsManager udfManager,
IRecentlyUsedEntities mru,
Preprocessing.ILogSourcesPreprocessingManager logSourcesPreprocessings,
ILogSourcesController logSourcesController,
IView view,
Preprocessing.IPreprocessingStepsFactory preprocessingStepsFactory,
Workspaces.IWorkspacesManager workspacesManager,
SourcesList.IPresenter sourcesListPresenter,
NewLogSourceDialog.IPresenter newLogSourceDialogPresenter,
IHeartBeatTimer heartbeat,
SharingDialog.IPresenter sharingDialogPresenter,
HistoryDialog.IPresenter historyDialogPresenter,
IPresentersFacade facade,
SourcePropertiesWindow.IPresenter sourcePropertiesWindowPresenter,
IAlertPopup alerts
)
{
this.logSources = logSources;
this.udfManager = udfManager;
this.logSourcesController = logSourcesController;
this.mru = mru;
this.view = view;
this.logSourcesPreprocessings = logSourcesPreprocessings;
this.preprocessingStepsFactory = preprocessingStepsFactory;
this.workspacesManager = workspacesManager;
this.newLogSourceDialogPresenter = newLogSourceDialogPresenter;
this.sourcesListPresenter = sourcesListPresenter;
this.tracer = new LJTraceSource("UI", "smgr-ui");
this.sharingDialogPresenter = sharingDialogPresenter;
this.historyDialogPresenter = historyDialogPresenter;
this.sourcePropertiesWindowPresenter = sourcePropertiesWindowPresenter;
this.alerts = alerts;
this.presentersFacade = facade;
sourcesListPresenter.DeleteRequested += delegate(object sender, EventArgs args)
{
DeleteSelectedSources();
};
logSources.OnLogSourceAdded += (sender, args) =>
{
UpdateRemoveAllButton();
};
logSources.OnLogSourceRemoved += (sender, args) =>
{
updateTracker.Invalidate();
UpdateRemoveAllButton();
};
logSourcesPreprocessings.PreprocessingAdded += (sender, args) =>
{
updateTracker.Invalidate();
UpdateRemoveAllButton();
if ((args.LogSourcePreprocessing.Flags & PreprocessingOptions.HighlightNewPreprocessing) != 0)
{
preprocessingAwaitingHighlighting = args.LogSourcePreprocessing;
}
};
logSourcesPreprocessings.PreprocessingDisposed += (sender, args) =>
{
updateTracker.Invalidate();
UpdateRemoveAllButton();
};
logSourcesPreprocessings.PreprocessingChangedAsync += (sender, args) =>
{
updateTracker.Invalidate();
};
sourcesListPresenter.SelectionChanged += delegate(object sender, EventArgs args)
{
bool anySourceSelected = sourcesListPresenter.SelectedSources.Any();
bool anyPreprocSelected = sourcesListPresenter.SelectedPreprocessings.Any();
view.EnableDeleteSelectedSourcesButton(anySourceSelected || anyPreprocSelected);
view.EnableTrackChangesCheckBox(anySourceSelected);
UpdateTrackChangesCheckBox();
view.SetPropertiesButtonState(
sourcePropertiesWindowPresenter != null && sourcesListPresenter.SelectedSources.Count() == 1);
};
logSources.OnLogSourceVisiblityChanged += (sender, args) =>
{
updateTracker.Invalidate();
};
logSources.OnLogSourceAnnotationChanged += (sender, args) =>
{
updateTracker.Invalidate();
};
logSources.OnLogSourceTrackingFlagChanged += (sender, args) =>
{
updateTracker.Invalidate();
};
logSources.OnLogSourceStatsChanged += (sender, args) =>
{
if ((args.Flags & (LogProviderStatsFlag.Error | LogProviderStatsFlag.CachedMessagesCount | LogProviderStatsFlag.State | LogProviderStatsFlag.BytesCount | LogProviderStatsFlag.BackgroundAcivityStatus)) != 0)
{
updateTracker.Invalidate();
}
};
heartbeat.OnTimer += (sender, args) =>
{
if (updateTracker.Validate())
{
UpdateView();
}
};
this.sharingDialogPresenter.AvailabilityChanged += (sender, args) =>
{
UpdateShareButton();
};
this.sharingDialogPresenter.IsBusyChanged += (sender, args) =>
{
UpdateShareButton();
};
view.SetPresenter(this);
UpdateShareButton();
}
public Presenter(
ISearchManager searchManager,
IBookmarks bookmarks,
IFiltersList hlFilters,
IView view,
IPresentersFacade navHandler,
LoadedMessages.IPresenter loadedMessagesPresenter,
IHeartBeatTimer heartbeat,
ISynchronizationContext uiThreadSynchronization,
StatusReports.IPresenter statusReports,
LogViewer.IPresenterFactory logViewerPresenterFactory,
IColorTheme theme,
IChangeNotification changeNotification
)
{
this.searchManager = searchManager;
this.bookmarks = bookmarks;
this.hlFilters = hlFilters;
this.view = view;
this.loadedMessagesPresenter = loadedMessagesPresenter;
this.statusReports = statusReports;
this.theme = theme;
this.changeNotification = changeNotification;
var(messagesPresenter, messagesModel) = logViewerPresenterFactory.CreateSearchResultsPresenter(
view.MessagesView, loadedMessagesPresenter.LogViewerPresenter);
this.messagesPresenter = messagesPresenter;
this.messagesPresenter.FocusedMessageDisplayMode = LogViewer.FocusedMessageDisplayModes.Slave;
this.messagesPresenter.DblClickAction = Presenters.LogViewer.PreferredDblClickAction.DoDefaultAction;
this.messagesPresenter.DefaultFocusedMessageActionCaption = "Go to message";
this.messagesPresenter.DisabledUserInteractions = LogViewer.UserInteraction.RawViewSwitching;
this.messagesPresenter.DefaultFocusedMessageAction += async(s, e) =>
{
if (messagesPresenter.FocusedMessage != null)
{
if (await navHandler.ShowMessage(messagesPresenter.FocusedMessageBookmark,
BookmarkNavigationOptions.EnablePopups | BookmarkNavigationOptions.SearchResultStringsSet
).IgnoreCancellation())
{
loadedMessagesPresenter.LogViewerPresenter.ReceiveInputFocus();
}
}
};
this.hlFilters.OnPropertiesChanged += (sender, args) =>
{
if (args.ChangeAffectsFilterResult)
{
lazyUpdateFlag.Invalidate();
}
};
this.hlFilters.OnFiltersListChanged += (sender, args) =>
{
lazyUpdateFlag.Invalidate();
};
this.hlFilters.OnFilteringEnabledChanged += (sender, args) =>
{
lazyUpdateFlag.Invalidate();
};
this.searchManager.SearchResultChanged += (sender, e) =>
{
if ((e.Flags & SearchResultChangeFlag.HitCountChanged) != 0 ||
(e.Flags & SearchResultChangeFlag.ProgressChanged) != 0 ||
(e.Flags & SearchResultChangeFlag.PinnedChanged) != 0 ||
(e.Flags & SearchResultChangeFlag.VisibleChanged) != 0)
{
lazyUpdateFlag.Invalidate();
}
if ((e.Flags & SearchResultChangeFlag.StatusChanged) != 0)
{
lazyUpdateFlag.Invalidate();
uiThreadSynchronization.Post(ValidateView);
uiThreadSynchronization.Post(PostSearchActions);
}
};
this.searchManager.CombinedSearchResultChanged += (sender, e) =>
{
uiThreadSynchronization.Post(() => messagesModel.RaiseSourcesChanged());
};
this.searchManager.SearchResultsChanged += (sender, e) =>
{
lazyUpdateFlag.Invalidate();
messagesModel.RaiseSourcesChanged();
uiThreadSynchronization.Post(ValidateView);
uiThreadSynchronization.Post(PreSearchActions);
};
heartbeat.OnTimer += (sender, args) =>
{
if (args.IsNormalUpdate)
{
ValidateView();
}
};
view.SetViewModel(this);
UpdateExpandedState();
}
public Presenter(
ILogSourcesManager logSources,
Preprocessing.IManager preprocessingsManager,
IView view,
LogViewer.IPresenterInternal viewerPresenter,
SearchResult.IPresenter searchResultPresenter,
SearchPanel.IPresenter searchPanelPresenter,
SourcesManager.IPresenter sourcesManagerPresenter,
MessagePropertiesDialog.IPresenter messagePropertiesDialogPresenter,
LoadedMessages.IPresenter loadedMessagesPresenter,
BookmarksManager.IPresenter bookmarksManagerPresenter,
IHeartBeatTimer heartBeatTimer,
ITabUsageTracker tabUsageTracker,
StatusReports.IPresenter statusReportFactory,
IDragDropHandler dragDropHandler,
IPresentersFacade presentersFacade,
IAutoUpdater autoUpdater,
Progress.IProgressAggregator progressAggregator,
IAlertPopup alerts,
SharingDialog.IPresenter sharingDialogPresenter,
IssueReportDialogPresenter.IPresenter issueReportDialogPresenter,
IShutdownSource shutdown,
IColorTheme theme,
IChangeNotification changeNotification,
ITraceSourceFactory traceSourceFactory
)
{
this.tracer = traceSourceFactory.CreateTraceSource("UI", "ui.main");
this.logSources = logSources;
this.preprocessingsManager = preprocessingsManager;
this.view = view;
this.tabUsageTracker = tabUsageTracker;
this.searchPanelPresenter = searchPanelPresenter;
this.searchResultPresenter = searchResultPresenter;
this.bookmarksManagerPresenter = bookmarksManagerPresenter;
this.viewerPresenter = viewerPresenter;
this.presentersFacade = presentersFacade;
this.dragDropHandler = dragDropHandler;
this.heartBeatTimer = heartBeatTimer;
this.autoUpdater = autoUpdater;
this.progressAggregator = progressAggregator;
this.alerts = alerts;
this.sharingDialogPresenter = sharingDialogPresenter;
this.issueReportDialogPresenter = issueReportDialogPresenter;
this.shutdown = shutdown;
this.statusRepors = statusReportFactory;
this.theme = theme;
this.changeNotification = changeNotification;
view.SetViewModel(this);
viewerPresenter.ManualRefresh += delegate(object sender, EventArgs args)
{
using (tracer.NewFrame)
{
tracer.Info("----> User Command: Refresh");
logSources.Refresh();
}
};
viewerPresenter.FocusedMessageBookmarkChanged += delegate(object sender, EventArgs args)
{
if (searchResultPresenter != null)
{
searchResultPresenter.MasterFocusedMessage = viewerPresenter.FocusedMessageBookmark;
}
};
if (messagePropertiesDialogPresenter != null)
{
viewerPresenter.DefaultFocusedMessageActionCaption = "Show properties...";
viewerPresenter.DefaultFocusedMessageAction += (s, e) =>
{
messagePropertiesDialogPresenter.Show();
};
}
if (searchResultPresenter != null)
{
searchResultPresenter.OnClose += (sender, args) => searchPanelPresenter.CollapseSearchResultPanel();
searchResultPresenter.OnResizingStarted += (sender, args) => view.BeginSplittingSearchResults();
}
sourcesManagerPresenter.OnBusyState += (_, evt) => SetWaitState(evt.BusyStateRequired);
searchPanelPresenter.InputFocusAbandoned += delegate(object sender, EventArgs args)
{
loadedMessagesPresenter.LogViewerPresenter.ReceiveInputFocus();
};
loadedMessagesPresenter.OnResizingStarted += (s, e) => view.BeginSplittingTabsPanel();
this.heartBeatTimer.OnTimer += (sender, e) =>
{
if (e.IsRareUpdate)
{
SetAnalyzingIndication(logSources.Items.Any(s => s.TimeGaps.IsWorking));
}
};
logSources.OnLogSourceAdded += (sender, evt) =>
{
UpdateFormCaption();
};
logSources.OnLogSourceRemoved += (sender, evt) =>
{
UpdateFormCaption();
};
progressAggregator.ProgressStarted += (sender, args) =>
{
view.SetTaskbarState(TaskbarState.Progress);
UpdateFormCaption();
};
progressAggregator.ProgressEnded += (sender, args) =>
{
view.SetTaskbarState(TaskbarState.Idle);
UpdateFormCaption();
};
progressAggregator.ProgressChanged += (sender, args) =>
{
view.UpdateTaskbarProgress(args.ProgressPercentage);
UpdateFormCaption();
};
if (sharingDialogPresenter != null)
{
sharingDialogPresenter.AvailabilityChanged += (sender, args) =>
{
UpdateShareButton();
};
sharingDialogPresenter.IsBusyChanged += (sender, args) =>
{
UpdateShareButton();
};
}
;
UpdateFormCaption();
UpdateShareButton();
view.SetIssueReportingMenuAvailablity(issueReportDialogPresenter.IsAvailable);
}
public Factory(
IViewsFactory postprocessingViewsFactory,
IManagerInternal postprocessorsManager,
ILogSourcesManager logSourcesManager,
ISynchronizationContext synchronizationContext,
IChangeNotification changeNotification,
IBookmarks bookmarks,
IModelThreads threads,
Persistence.IStorageManager storageManager,
ILogSourceNamesProvider logSourceNamesProvider,
IUserNamesProvider shortNames,
SourcesManager.IPresenter sourcesManagerPresenter,
LoadedMessages.IPresenter loadedMessagesPresenter,
IClipboardAccess clipboardAccess,
IPresentersFacade presentersFacade,
IAlertPopup alerts,
IColorTheme colorTheme,
Drawing.IMatrixFactory matrixFactory,
ICorrelationManager correlationManager
)
{
stateInspectorVisualizer = new Lazy <StateInspectorVisualizer.IPresenterInternal>(() =>
{
var view = postprocessingViewsFactory.CreateStateInspectorView();
var model = new LogJoint.Postprocessing.StateInspector.StateInspectorVisualizerModel(
postprocessorsManager,
logSourcesManager,
synchronizationContext,
shortNames
);
return(new StateInspectorVisualizer.StateInspectorPresenter(
view,
model,
shortNames,
logSourcesManager,
loadedMessagesPresenter,
bookmarks,
threads,
presentersFacade,
clipboardAccess,
sourcesManagerPresenter,
colorTheme
));
});
timelineVisualizer = new Lazy <TimelineVisualizer.IPresenter>(() =>
{
var view = postprocessingViewsFactory.CreateTimelineView();
var model = new LogJoint.Postprocessing.Timeline.TimelineVisualizerModel(
postprocessorsManager,
logSourcesManager,
shortNames,
logSourceNamesProvider
);
return(new TimelineVisualizer.TimelineVisualizerPresenter(
model,
view,
stateInspectorVisualizer.Value,
new Common.PresentationObjectsFactory(postprocessorsManager, logSourcesManager, changeNotification, alerts, correlationManager),
loadedMessagesPresenter,
bookmarks,
storageManager,
presentersFacade,
shortNames,
changeNotification,
colorTheme
));
});
sequenceDiagramVisualizer = new Lazy <SequenceDiagramVisualizer.IPresenter>(() =>
{
var view = postprocessingViewsFactory.CreateSequenceDiagramView();
var model = new LogJoint.Postprocessing.SequenceDiagram.SequenceDiagramVisualizerModel(
postprocessorsManager,
logSourcesManager,
shortNames,
logSourceNamesProvider,
changeNotification
);
return(new SequenceDiagramVisualizer.SequenceDiagramVisualizerPresenter(
model,
view,
stateInspectorVisualizer.Value,
new Common.PresentationObjectsFactory(postprocessorsManager, logSourcesManager, changeNotification, alerts, correlationManager),
loadedMessagesPresenter,
bookmarks,
storageManager,
presentersFacade,
shortNames,
changeNotification,
colorTheme,
matrixFactory
));
});
timeSeriesVisualizer = new Lazy <TimeSeriesVisualizer.IPresenter>(() =>
{
var view = postprocessingViewsFactory.CreateTimeSeriesView();
var model = new LogJoint.Postprocessing.TimeSeries.TimelineVisualizerModel(
postprocessorsManager,
logSourcesManager,
shortNames,
logSourceNamesProvider
);
return(new TimeSeriesVisualizer.TimeSeriesVisualizerPresenter(
model,
view,
new Common.PresentationObjectsFactory(postprocessorsManager, logSourcesManager, changeNotification, alerts, correlationManager),
loadedMessagesPresenter.LogViewerPresenter,
bookmarks,
presentersFacade,
changeNotification
));
});
}
public Presenter(
ILogSourcesManager logSources,
IUserDefinedFormatsManager udfManager,
IRecentlyUsedEntities mru,
Preprocessing.IManager logSourcesPreprocessings,
IView view,
Preprocessing.IStepsFactory preprocessingStepsFactory,
Workspaces.IWorkspacesManager workspacesManager,
SourcesList.IPresenter sourcesListPresenter,
NewLogSourceDialog.IPresenter newLogSourceDialogPresenter,
IHeartBeatTimer heartbeat,
SharingDialog.IPresenter sharingDialogPresenter,
HistoryDialog.IPresenter historyDialogPresenter,
IPresentersFacade facade,
SourcePropertiesWindow.IPresenter sourcePropertiesWindowPresenter,
IAlertPopup alerts,
ITraceSourceFactory traceSourceFactory,
IChangeNotification changeNotification
)
{
this.logSources = logSources;
this.udfManager = udfManager;
this.mru = mru;
this.view = view;
this.logSourcesPreprocessings = logSourcesPreprocessings;
this.preprocessingStepsFactory = preprocessingStepsFactory;
this.workspacesManager = workspacesManager;
this.newLogSourceDialogPresenter = newLogSourceDialogPresenter;
this.sourcesListPresenter = sourcesListPresenter;
this.tracer = traceSourceFactory.CreateTraceSource("UI", "smgr-ui");
this.sharingDialogPresenter = sharingDialogPresenter;
this.historyDialogPresenter = historyDialogPresenter;
this.sourcePropertiesWindowPresenter = sourcePropertiesWindowPresenter;
this.alerts = alerts;
this.presentersFacade = facade;
this.changeNotification = changeNotification;
sourcesListPresenter.DeleteRequested += (sender, args) =>
{
DeleteSelectedSources();
};
logSourcesPreprocessings.PreprocessingAdded += (sender, args) =>
{
if ((args.LogSourcePreprocessing.Flags & PreprocessingOptions.HighlightNewPreprocessing) != 0)
{
preprocessingAwaitingHighlighting = args.LogSourcePreprocessing;
pendingUpdateFlag.Invalidate();
}
};
heartbeat.OnTimer += (sender, args) =>
{
if (pendingUpdateFlag.Validate())
{
UpdateView();
}
};
view.SetViewModel(this);
}
