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 WorkspacesManager(
ILogSourcesManager logSources,
ILogProviderFactoryRegistry logProviderFactoryRegistry,
IStorageManager storageManager,
Backend.IBackendAccess backend,
ITempFilesManager tempFilesManager,
MRU.IRecentlyUsedEntities recentlyUsedEntities,
IShutdown shutdown,
ITraceSourceFactory traceSourceFactory
)
{
this.tracer = traceSourceFactory.CreateTraceSource("Workspaces", "ws");
this.logSources = logSources;
this.backendAccess = backend;
this.tempFilesManager = tempFilesManager;
this.logProviderFactoryRegistry = logProviderFactoryRegistry;
this.storageManager = storageManager;
this.recentlyUsedEntities = recentlyUsedEntities;
if (backend.IsConfigured)
{
this.status = WorkspacesManagerStatus.NoWorkspace;
}
else
{
this.status = WorkspacesManagerStatus.Unavailable;
}
shutdown.Cleanup += (s, e) => shutdown.AddCleanupTask(
WaitUploadCompletion().WithTimeout(TimeSpan.FromSeconds(10)));
}
public Presenter(
IBookmarks bookmarks,
ILogSourcesManager sourcesManager,
IView view,
IHeartBeatTimer heartbeat,
LoadedMessages.IPresenter loadedMessagesPresenter,
IClipboardAccess clipboardAccess)
{
this.bookmarks = bookmarks;
this.view = view;
this.loadedMessagesPresenter = loadedMessagesPresenter;
this.clipboardAccess = clipboardAccess;
this.trace = new LJTraceSource("UI", "bmks");
bookmarks.OnBookmarksChanged += (sender, evt) => updateTracker.Invalidate();
heartbeat.OnTimer += (sender, evt) =>
{
if (evt.IsNormalUpdate && updateTracker.Validate())
{
UpdateViewInternal(null, ViewUpdateFlags.None);
}
};
sourcesManager.OnLogSourceVisiblityChanged += (sender, evt) => updateTracker.Invalidate();
loadedMessagesPresenter.LogViewerPresenter.ColoringModeChanged += (sender, evt) => view.Invalidate();
view.SetPresenter(this);
}
public PluginTabPagePresenter(
IView view,
IPostprocessorsManager postprocessorsManager,
IPostprocessorOutputFormFactory outputFormsFactory,
ILogSourcesManager logSourcesManager,
ITempFilesManager tempFiles,
IShellOpen shellOpen,
NewLogSourceDialog.IPresenter newLogSourceDialog,
Telemetry.ITelemetryCollector telemetry
)
{
this.view = view;
this.view.SetEventsHandler(this);
this.postprocessorsManager = postprocessorsManager;
this.outputFormsFactory = outputFormsFactory;
this.tempFiles = tempFiles;
this.shellOpen = shellOpen;
this.newLogSourceDialog = newLogSourceDialog;
this.telemetry = telemetry;
logSourcesManager.OnLogSourceAnnotationChanged += (sender, e) =>
{
RefreshView();
};
}
public LogSourcesController(
ILogSourcesManager logSources,
Preprocessing.ILogSourcesPreprocessingManager logSourcesPreprocessings,
IRecentlyUsedEntities mruLogsList,
IShutdown shutdown
)
{
this.logSources = logSources;
this.logSourcesPreprocessings = logSourcesPreprocessings;
this.mruLogsList = mruLogsList;
this.logSources.OnLogSourceAnnotationChanged += (s, e) =>
{
var source = (ILogSource)s;
mruLogsList.UpdateRecentLogEntry(source.Provider, source.Annotation);
};
this.logSourcesPreprocessings.ProviderYielded += (sender, yieldedProvider) =>
{
CreateLogSourceInternal(yieldedProvider.Factory, yieldedProvider.ConnectionParams, yieldedProvider.IsHiddenLog);
};
shutdown.Cleanup += (sender, e) =>
{
shutdown.AddCleanupTask(Dispose());
};
}
public LoadedMessagesViewModeStrategy(
ILogSourcesManager logSourcesManager,
IChangeNotification changeNotification
)
{
this.logSourcesManager = logSourcesManager;
this.changeNotification = changeNotification;
this.rawModeAllowed = Selectors.Create(
() => logSourcesManager.VisibleItems,
sources => sources.Any(s => s.Provider.Factory.ViewOptions.RawViewAllowed)
);
this.isRawMode = Selectors.Create(
rawModeAllowed,
() => manuallySetRawMode,
() => logSourcesManager.VisibleItems,
(allowed, set, sources) =>
{
return
(!allowed ? false :
set != null ? set.Value :
sources.All(s => s.Provider.Factory.ViewOptions.PreferredView == PreferredViewMode.Raw));
}
);
logSourceRemovedHandler = (s, e) =>
{
if (logSourcesManager.Items.Count == 0 && manuallySetRawMode.HasValue)
{
manuallySetRawMode = null; // reset automatic mode when last source is gone
changeNotification.Post();
}
};
logSourcesManager.OnLogSourceRemoved += logSourceRemovedHandler;
}
public SearchResultMessagesModel(
ILogSourcesManager logSources,
ISearchManager searchManager,
IFiltersFactory filtersFactory
)
{
this.searchManager = searchManager;
logSources.OnLogSourceColorChanged += (s, e) =>
{
OnLogSourceColorChanged?.Invoke(s, e);
};
int searchFiltersListVersion = 0;
searchManager.SearchResultsChanged += (s, e) => ++ searchFiltersListVersion;
searchManager.SearchResultChanged += (s, e) => searchFiltersListVersion += ((e.Flags & SearchResultChangeFlag.VisibleChanged) != 0 ? 1 : 0);
this.getSearchFiltersList = Selectors.Create(
() => searchFiltersListVersion,
_ =>
{
var list = filtersFactory.CreateFiltersList(FilterAction.Exclude, FiltersListPurpose.Search);
foreach (var f in searchManager
.Results
.Where(r => r.Visible && r.OptionsFilter != null)
.Select(r => r.OptionsFilter))
{
list.Insert(list.Items.Count, f.Clone());
}
return(list);
}
);
}
public LogSourcesPreprocessingManager(
ISynchronizationContext invokeSynchronize,
IFormatAutodetect formatAutodetect,
IExtensionsRegistry extensions,
IPreprocessingManagerExtension builtinStepsExtension,
Telemetry.ITelemetryCollector telemetry,
ITempFilesManager tempFilesManager,
ILogSourcesManager logSourcesManager,
IShutdown shutdown,
ITraceSourceFactory traceSourceFactory,
IChangeNotification changeNotification
)
{
this.traceSourceFactory = traceSourceFactory;
this.trace = traceSourceFactory.CreateTraceSource("PreprocessingManager", "prepr");
this.invokeSynchronize = invokeSynchronize;
this.formatAutodetect = formatAutodetect;
this.providerYieldedCallback = prov => logSourcesManager.Create(prov.Factory, prov.ConnectionParams).Visible = !prov.IsHiddenLog;
this.extensions = extensions;
this.telemetry = telemetry;
this.tempFilesManager = tempFilesManager;
this.logSourcesManager = logSourcesManager;
this.changeNotification = changeNotification;
extensions.Register(builtinStepsExtension);
shutdown.Cleanup += (sender, e) =>
{
shutdown.AddCleanupTask(this.DeleteAllPreprocessings());
};
}
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,
ILogSourcesManager sourcesManager,
IView view,
IHeartBeatTimer heartbeat,
LoadedMessages.IPresenter loadedMessagesPresenter,
IClipboardAccess clipboardAccess,
IColorTheme colorTheme,
IChangeNotification changeNotification,
ITraceSourceFactory traceSourceFactory
)
{
this.bookmarks = bookmarks;
this.view = view;
this.loadedMessagesPresenter = loadedMessagesPresenter;
this.clipboardAccess = clipboardAccess;
this.colorTheme = colorTheme;
this.changeNotification = changeNotification;
this.trace = traceSourceFactory.CreateTraceSource("UI", "bmks");
itemsSelector = Selectors.Create(
() => bookmarks.Items,
() => selectedBookmarks,
() => colorTheme.ThreadColors,
() => loadedMessagesPresenter.LogViewerPresenter.Coloring,
CreateViewItems
);
focusedMessagePositionSelector = Selectors.Create(
() => loadedMessagesPresenter.LogViewerPresenter.FocusedMessageBookmark,
() => bookmarks.Items,
FindFocusedMessagePosition
);
view.SetViewModel(this);
}
public StateInspectorVisualizerModel(
IManagerInternal postprocessorsManager,
ILogSourcesManager logSourcesManager,
IChangeNotification changeNotification,
IUserNamesProvider shortNamesManager)
{
this.postprocessorsManager = postprocessorsManager;
this.shortNamesManager = shortNamesManager;
int postprocessorsVersion = 0;
postprocessorsManager.Changed += (sender, args) =>
{
postprocessorsVersion++;
changeNotification.Post();
};
var updateGroups = Updaters.Create(
() => logSourcesManager.VisibleItems,
() => postprocessorsVersion,
(visibleSources, _) =>
{
UpdateOutputs();
UpdateOutputGroups();
}
);
this.getGroupsList = Selectors.Create(
() =>
{
updateGroups();
return(groups);
},
dict => (IReadOnlyList <IStateInspectorOutputsGroup>)dict.Values.ToImmutableArray()
);
}
public PostprocessorsManager(
ILogSourcesManager logSources,
Telemetry.ITelemetryCollector telemetry,
IInvokeSynchronization modelInvoke,
IHeartBeatTimer heartbeat,
Progress.IProgressAggregator progressAggregator,
IPostprocessorsManagerUserInteractions userInteractions,
Settings.IGlobalSettingsAccessor settingsAccessor
)
{
this.userInteractions = userInteractions;
this.logSources = logSources;
this.telemetry = telemetry;
this.progressAggregator = progressAggregator;
this.settingsAccessor = settingsAccessor;
logSources.OnLogSourceAdded += (sender, args) => { lazyUpdateTracker.Invalidate(); };
logSources.OnLogSourceRemoved += (sender, args) => { lazyUpdateTracker.Invalidate(); };
logSources.OnLogSourceAnnotationChanged += (sender, args) => { lazyUpdateTracker.Invalidate(); };
logSources.OnLogSourceStatsChanged += (object sender, LogSourceStatsEventArgs e) =>
{
if ((e.Flags & LogProviderStatsFlag.ContentsEtag) != 0)
{
modelInvoke.Invoke(() => RefreshInternal(assumeSourceChanged: sender as ILogSource));
}
};
heartbeat.OnTimer += (sender, args) =>
{
if (lazyUpdateTracker.Validate())
{
RefreshInternal();
}
};
RefreshInternal();
}
public PostprocessorsManager(
ILogSourcesManager logSources,
Telemetry.ITelemetryCollector telemetry,
ISynchronizationContext modelSyncContext,
ISynchronizationContext threadPoolSyncContext,
IHeartBeatTimer heartbeat,
Progress.IProgressAggregator progressAggregator,
Settings.IGlobalSettingsAccessor settingsAccessor,
IOutputDataDeserializer outputDataDeserializer,
ITraceSourceFactory traceSourceFactory
)
{
this.logSources = logSources;
this.telemetry = telemetry;
this.progressAggregator = progressAggregator;
this.settingsAccessor = settingsAccessor;
this.modelSyncContext = modelSyncContext;
this.threadPoolSyncContext = threadPoolSyncContext;
this.heartbeat = heartbeat;
this.outputDataDeserializer = outputDataDeserializer;
this.tracer = traceSourceFactory.CreateTraceSource("App", "ppm");
this.updater = new AsyncInvokeHelper(modelSyncContext, Refresh);
logSources.OnLogSourceAdded += (sender, args) => updater.Invoke();
logSources.OnLogSourceRemoved += (sender, args) => updater.Invoke();
logSources.OnLogSourceAnnotationChanged += (sender, args) => updater.Invoke();
logSources.OnLogSourceStatsChanged += (object sender, LogSourceStatsEventArgs e) =>
{
if ((e.Flags & LogProviderStatsFlag.ContentsEtag) != 0)
{
updater.Invoke();
}
};
Refresh();
}
public void BeforeEach()
{
logSources = Substitute.For <ILogSourcesManager>();
telemetry = Substitute.For <Telemetry.ITelemetryCollector>();
mockedSyncContext = new ManualSynchronizationContext();
heartbeat = Substitute.For <IHeartBeatTimer>();
progressAggregator = Substitute.For <Progress.IProgressAggregator>();
settingsAccessor = Substitute.For <Settings.IGlobalSettingsAccessor>();
logSource1 = Substitute.For <ILogSource>();
logProviderFac1 = Substitute.For <ILogProviderFactory>();
logSource1.Provider.Factory.Returns(logProviderFac1);
logSource1.Provider.ConnectionParams.Returns(new ConnectionParams($"{ConnectionParamsKeys.PathConnectionParam}=/log.txt"));
logSource1.Provider.Stats.Returns(new LogProviderStats()
{
ContentsEtag = null
});
logSourcePP1 = Substitute.For <ILogSourcePostprocessor>();
logSourcePP1.Kind.Returns(PostprocessorKind.SequenceDiagram);
pp1outputXmlSection = Substitute.For <Persistence.ISaxXMLStorageSection>();
logSource1.LogSourceSpecificStorageEntry.OpenSaxXMLSection("postproc-sequencediagram.xml", Persistence.StorageSectionOpenFlag.ReadOnly).Returns(pp1outputXmlSection);
pp1outputXmlSection.Reader.Returns(Substitute.For <XmlReader>());
pp1PostprocessorOutput = Substitute.For <IPostprocessorOutputETag>();
outputDataDeserializer = Substitute.For <IOutputDataDeserializer>();
outputDataDeserializer.Deserialize(PostprocessorKind.SequenceDiagram, Arg.Any <LogSourcePostprocessorDeserializationParams>()).Returns(pp1PostprocessorOutput);
pp1RunSummary = Substitute.For <IPostprocessorRunSummary>();
logSourcePP1.Run(null).ReturnsForAnyArgs(Task.FromResult(pp1RunSummary));
pp1RunSummary.GetLogSpecificSummary(null).ReturnsForAnyArgs((IPostprocessorRunSummary)null);
manager = new LogJoint.Postprocessing.PostprocessorsManager(
logSources, telemetry, mockedSyncContext, mockedSyncContext, heartbeat, progressAggregator, settingsAccessor, outputDataDeserializer, new TraceSourceFactory());
manager.RegisterLogType(new LogSourceMetadata(logProviderFac1, logSourcePP1));
}
public Presenter(IView view, ILogProviderFactory factory, ILogSourcesManager model)
{
this.view = view;
this.factory = (WindowsEventLog.Factory)factory;
this.model = model;
view.SetEventsHandler(this);
}
public Presenter(
IView view,
IManager postprocessorsManager,
IPostprocessorOutputFormFactory outputFormsFactory,
ILogSourcesManager logSourcesManager,
ITempFilesManager tempFiles,
IShellOpen shellOpen,
NewLogSourceDialog.IPresenter newLogSourceDialog,
Telemetry.ITelemetryCollector telemetry,
IChangeNotification changeNotification,
MainForm.IPresenter mainFormPresenter
)
{
this.view = view;
this.postprocessorsManager = postprocessorsManager;
this.outputFormsFactory = outputFormsFactory;
this.tempFiles = tempFiles;
this.shellOpen = shellOpen;
this.newLogSourceDialog = newLogSourceDialog;
this.telemetry = telemetry;
this.changeNotification = changeNotification.CreateChainedChangeNotification(false);
this.view.SetViewModel(this);
logSourcesManager.OnLogSourceAnnotationChanged += (sender, e) =>
{
RefreshView();
};
// todo: create when there a least one postprocessor exists. Postprocessors may come from plugins or it can be internal trace.
mainFormPresenter.AddCustomTab(view.UIControl, TabCaption, this);
mainFormPresenter.TabChanging += (sender, e) => OnTabPageSelected(e.CustomTabTag == this);
}
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 FiltersManager(
IFiltersFactory filtersFactory,
Settings.IGlobalSettingsAccessor globalSettingsAccessor,
ILogSourcesManager logSourcesManager,
IAdjustingColorsGenerator threadColors,
IShutdown shutdown
)
{
this.globalSettings = globalSettingsAccessor;
this.logSources = logSourcesManager;
this.highlightFilters = filtersFactory.CreateFiltersList(FilterAction.Exclude, FiltersListPurpose.Highlighting);
this.globalSettings.Changed += (sender, args) =>
{
if ((args.ChangedPieces & Settings.SettingsPiece.Appearance) != 0)
{
threadColors.Brightness = globalSettings.Appearance.ColoringBrightness;
}
};
this.logSources.OnLogSourceRemoved += (s, e) =>
{
highlightFilters.PurgeDisposedFiltersAndFiltersHavingDisposedThreads();
};
shutdown.Cleanup += (sender, args) =>
{
highlightFilters.Dispose();
};
}
public PresentationObjectsFactory(
IPostprocessorsManager ppm,
ILogSourcesManager lsm
)
{
this.ppm = ppm;
this.lsm = lsm;
}
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 DragDropHandler(
Preprocessing.IManager preprocessingManager,
Preprocessing.IStepsFactory preprocessingStepsFactory,
ILogSourcesManager logSourcesManager)
{
this.preprocessingManager = preprocessingManager;
this.preprocessingStepsFactory = preprocessingStepsFactory;
this.logSourcesManager = logSourcesManager;
}
public DragDropHandler(
ILogSourcesManager logSourcesManager,
IManager preprocessingManager,
IStepsFactory preprocessingStepsFactory)
{
this.logSourcesManager = logSourcesManager;
this.preprocessingManager = preprocessingManager;
this.preprocessingStepsFactory = preprocessingStepsFactory;
}
public Model(
IInvokeSynchronization threadSync,
Telemetry.ITelemetryCollector telemetryCollector,
Persistence.IWebContentCache webCache,
Persistence.IContentCache contentCache,
Persistence.IStorageManager storageManager,
IBookmarks bookmarks,
ILogSourcesManager sourcesManager,
IModelThreads threads,
ITempFilesManager tempFilesManager,
Preprocessing.IPreprocessingManagerExtensionsRegistry preprocessingManagerExtentionsRegistry,
Preprocessing.ILogSourcesPreprocessingManager logSourcesPreprocessingManager,
Preprocessing.IPreprocessingStepsFactory preprocessingStepsFactory,
Progress.IProgressAggregator progressAggregator,
ILogProviderFactoryRegistry logProviderFactoryRegistry,
IUserDefinedFormatsManager userDefinedFormatsManager,
MRU.IRecentlyUsedEntities mru,
Progress.IProgressAggregatorFactory progressAggregatorsFactory,
IHeartBeatTimer heartbeat,
ILogSourcesController logSourcesController,
IShutdown shutdown,
WebBrowserDownloader.IDownloader webBrowserDownloader,
AppLaunch.ICommandLineHandler commandLineHandler,
Postprocessing.IPostprocessorsManager postprocessorsManager,
Postprocessing.IUserNamesProvider analyticsShortNames,
Analytics.TimeSeries.ITimeSeriesTypesAccess timeSeriesTypes,
Postprocessing.IAggregatingLogSourceNamesProvider logSourceNamesProvider
)
{
this.ModelThreadSynchronization = threadSync;
this.Telemetry = telemetryCollector;
this.WebContentCache = webCache;
this.ContentCache = contentCache;
this.StorageManager = storageManager;
this.Bookmarks = bookmarks;
this.SourcesManager = sourcesManager;
this.Threads = threads;
this.TempFilesManager = tempFilesManager;
this.PreprocessingManagerExtensionsRegistry = preprocessingManagerExtentionsRegistry;
this.PreprocessingStepsFactory = preprocessingStepsFactory;
this.LogSourcesPreprocessingManager = logSourcesPreprocessingManager;
this.ProgressAggregator = progressAggregator;
this.LogProviderFactoryRegistry = logProviderFactoryRegistry;
this.UserDefinedFormatsManager = userDefinedFormatsManager;
this.ProgressAggregatorsFactory = progressAggregatorsFactory;
this.MRU = mru;
this.Heartbeat = heartbeat;
this.LogSourcesController = logSourcesController;
this.Shutdown = shutdown;
this.WebBrowserDownloader = webBrowserDownloader;
this.CommandLineHandler = commandLineHandler;
this.PostprocessorsManager = postprocessorsManager;
this.ShortNames = analyticsShortNames;
this.TimeSeriesTypes = timeSeriesTypes;
this.LogSourceNamesProvider = logSourceNamesProvider;
}
public static async Task DeleteLogs(this ILogSourcesManager lsm, ILogSource[] sources)
{
var tasks = sources.Where(s => !s.IsDisposed).Select(s => s.Dispose()).ToArray();
if (tasks.Length == 0)
{
return;
}
await Task.WhenAll(tasks);
}
public CorrelatorToastNotification(
IPostprocessorsManager ppm,
ILogSourcesManager lsm
)
{
this.ppm = ppm;
ppm.Changed += (s, e) => Update();
lsm.OnLogSourceTimeOffsetChanged += (s, e) => Update();
Update();
}
public CodenameUserNamesProvider(ILogSourcesManager logSources)
{
logSources.OnLogSourceRemoved += (s, e) =>
{
if (!logSources.Items.Any())
{
Reset();
}
};
}
public Presenter(
ILogSourcesManager logSourcesManager,
IChangeNotification changeNotification,
IView view,
Preprocessing.IManager sourcesPreprocessingManager,
Preprocessing.IStepsFactory preprocessingStepsFactory,
MRU.IRecentlyUsedEntities mru,
QuickSearchTextBox.IPresenter searchBoxPresenter,
IAlertPopup alerts,
ITraceSourceFactory traceSourceFactory
)
{
this.view = view;
this.changeNotification = changeNotification;
this.logSourcesManager = logSourcesManager;
this.sourcesPreprocessingManager = sourcesPreprocessingManager;
this.preprocessingStepsFactory = preprocessingStepsFactory;
this.mru = mru;
this.searchBoxPresenter = searchBoxPresenter;
this.trace = traceSourceFactory.CreateTraceSource("UI", "hist-dlg");
this.alerts = alerts;
items = Selectors.Create(() => visible, () => acceptedFilter, MakeItems);
actuallySelected = Selectors.Create(() => items().displayItems, () => selected,
(items, selected) => items.SelectMany(i => i.Flatten()).Where(i => selected.Contains(i.key)).ToImmutableList());
openButtonEnabled = Selectors.Create(actuallySelected, selected => selected.Any(IsOpenable));
rootViewItem = Selectors.Create(() => items().displayItems, () => selected, () => expanded, MakeRootItem);
searchBoxPresenter.OnSearchNow += (s, e) =>
{
acceptedFilter = searchBoxPresenter.Text;
FocusItemsListAndSelectFirstItem();
changeNotification.Post();
};
searchBoxPresenter.OnRealtimeSearch += (s, e) =>
{
acceptedFilter = searchBoxPresenter.Text;
changeNotification.Post();
};
searchBoxPresenter.OnCancelled += (s, e) =>
{
if (acceptedFilter != "")
{
acceptedFilter = "";
searchBoxPresenter.Focus(null);
}
else
{
visible = false;
}
changeNotification.Post();
};
view.SetViewModel(this);
}
public UnprocessedLogsToastNotification(
IManager ppm,
ILogSourcesManager lsm,
PostprocessorKind postprocessorKind
)
{
this.ppm = ppm;
this.postprocessorKind = postprocessorKind;
ppm.Changed += (s, e) => Update();
Update();
}
public PresentationObjectsFactory(
IManager ppm,
ILogSourcesManager lsm,
IChangeNotification changeNotification,
IAlertPopup alerts
)
{
this.ppm = ppm;
this.lsm = lsm;
this.alerts = alerts;
}
public UnprocessedLogsToastNotification(
IPostprocessorsManager ppm,
ILogSourcesManager lsm,
string postprocessorId
)
{
this.ppm = ppm;
this.postprocessorId = postprocessorId;
ppm.Changed += (s, e) => Update();
Update();
}
