public RPlotDeviceCommands(IRInteractiveWorkflow interactiveWorkflow, IRPlotDeviceVisualComponent visualComponent) {
if (interactiveWorkflow == null) {
throw new ArgumentNullException(nameof(interactiveWorkflow));
}
if (visualComponent == null) {
throw new ArgumentNullException(nameof(visualComponent));
}
_interactiveWorkflow = interactiveWorkflow;
_visualComponent = visualComponent;
ActivatePlotDevice = new PlotDeviceActivateCommand(_interactiveWorkflow, _visualComponent);
ExportAsImage = new PlotDeviceExportAsImageCommand(_interactiveWorkflow, _visualComponent);
ExportAsPdf = new PlotDeviceExportAsPdfCommand(_interactiveWorkflow, _visualComponent);
Cut = new PlotDeviceCutCopyCommand(_interactiveWorkflow, _visualComponent, cut: true);
Copy = new PlotDeviceCutCopyCommand(_interactiveWorkflow, _visualComponent, cut: false);
Paste = new PlotDevicePasteCommand(_interactiveWorkflow, _visualComponent);
CopyAsBitmap = new PlotDeviceCopyAsBitmapCommand(_interactiveWorkflow, _visualComponent);
CopyAsMetafile = new PlotDeviceCopyAsMetafileCommand(_interactiveWorkflow, _visualComponent);
RemoveAllPlots = new PlotDeviceRemoveAllCommand(_interactiveWorkflow, _visualComponent);
RemoveCurrentPlot = new PlotDeviceRemoveCurrentCommand(_interactiveWorkflow, _visualComponent);
NextPlot = new PlotDeviceMoveNextCommand(_interactiveWorkflow, _visualComponent);
PreviousPlot = new PlotDeviceMovePreviousCommand(_interactiveWorkflow, _visualComponent);
EndLocator = new PlotDeviceEndLocatorCommand(_interactiveWorkflow, _visualComponent);
}
public ShowHelpOnCurrentCommand(
IRInteractiveWorkflow workflow,
IActiveWpfTextViewTracker textViewTracker,
IActiveRInteractiveWindowTracker activeReplTracker) :
base(RGuidList.RCmdSetGuid, RPackageCommandId.icmdHelpOnCurrent,
workflow, textViewTracker, activeReplTracker, Resources.OpenFunctionHelp) {
}
public LoadWorkspaceCommand(IApplicationShell appShell, IRInteractiveWorkflow interactiveWorkflow, IProjectServiceAccessor projectServiceAccessor) :
base(RGuidList.RCmdSetGuid, RPackageCommandId.icmdLoadWorkspace) {
_appShell = appShell;
_interactiveWorkflow = interactiveWorkflow;
_rSession = interactiveWorkflow.RSession;
_projectServiceAccessor = projectServiceAccessor;
}
public ConnectionManager(IStatusBar statusBar, IRSettings settings, IRInteractiveWorkflow interactiveWorkflow) {
_statusBar = statusBar;
_sessionProvider = interactiveWorkflow.RSessions;
_settings = settings;
_interactiveWorkflow = interactiveWorkflow;
_shell = interactiveWorkflow.Shell;
_securityService = _shell.Services.Security;
_statusBarViewModel = new ConnectionStatusBarViewModel(this, interactiveWorkflow.Shell);
_hostLoadIndicatorViewModel = new HostLoadIndicatorViewModel(_sessionProvider, interactiveWorkflow.Shell);
_disposableBag = DisposableBag.Create<ConnectionManager>()
.Add(_statusBarViewModel)
.Add(_hostLoadIndicatorViewModel)
.Add(() => _sessionProvider.BrokerStateChanged -= BrokerStateChanged)
.Add(() => _interactiveWorkflow.ActiveWindowChanged -= ActiveWindowChanged);
_sessionProvider.BrokerStateChanged += BrokerStateChanged;
_interactiveWorkflow.ActiveWindowChanged += ActiveWindowChanged;
// Get initial values
var connections = CreateConnectionList();
_connections = new ConcurrentDictionary<string, IConnection>(connections);
UpdateRecentConnections(save: false);
CompleteInitializationAsync().DoNotWait();
}
public SessionInformationCommand(IRInteractiveWorkflow interactiveWorkflow, IConsole console) {
_interactiveWorkflow = interactiveWorkflow;
_console = console;
_interactiveWorkflow.RSession.Interactive += OnRSessionInteractive;
_interactiveWorkflow.RSession.Disposed += OnRSessionDisposed;
}
public CurrentDirectoryTest() {
var sessionProvider = VsAppShell.Current.ExportProvider.GetExportedValue<IRSessionProvider>();
var historyProvider = VsAppShell.Current.ExportProvider.GetExportedValue<IRHistoryProvider>();
var activeTextViewTracker = new ActiveTextViewTrackerMock(string.Empty, string.Empty);
var debuggerModeTracker = new TestDebuggerModeTracker();
_interactiveWorkflow = new RInteractiveWorkflow(sessionProvider, historyProvider, activeTextViewTracker, debuggerModeTracker, null, VsAppShell.Current, RToolsSettings.Current, () => {});
}
public IRHistory CreateRHistory(IRInteractiveWorkflow interactiveWorkflow) {
var contentType = _contentTypeRegistryService.GetContentType(RHistoryContentTypeDefinition.ContentType);
var textBuffer = _textBufferFactory.CreateTextBuffer(contentType);
var history = new RHistory(interactiveWorkflow, textBuffer, new FileSystem(), _settings, _editorOperationsFactory, _rtfBuilderService, () => RemoveRHistory(textBuffer));
_histories[textBuffer] = history;
return history;
}
public InteractiveWorkflowAsyncCommand(IRInteractiveWorkflow interactiveWorkflow) {
if (interactiveWorkflow == null) {
throw new ArgumentNullException(nameof(interactiveWorkflow));
}
InteractiveWorkflow = interactiveWorkflow;
}
public ShowMainPlotWindowCommand(IRInteractiveWorkflow workflow) {
if (workflow == null) {
throw new ArgumentNullException(nameof(workflow));
}
_workflow = workflow;
}
public ReplCommandTest() {
_debuggerModeTracker = new VsDebuggerModeTracker();
_componentContainerFactory = new InteractiveWindowComponentContainerFactoryMock();
_workflowProvider = TestRInteractiveWorkflowProviderFactory.Create(debuggerModeTracker: _debuggerModeTracker);
_workflow = _workflowProvider.GetOrCreate();
}
public RPackageManagerViewModelTest(RComponentsMefCatalogFixture catalog, TestMethodFixture testMethod, TestFilesFixture testFiles) {
_exportProvider = catalog.CreateExportProvider();
var workflowProvider = _exportProvider.GetExportedValue<TestRInteractiveWorkflowProvider>();
_workflow = UIThreadHelper.Instance.Invoke(() => workflowProvider.GetOrCreate());
_testMethod = testMethod.MethodInfo;
_testFiles = testFiles;
}
protected FunctionIndexBasedTest(AssemblyMefCatalogFixture catalog) {
ExportProvider = catalog.CreateExportProvider();
Workflow = UIThreadHelper.Instance.Invoke(() => ExportProvider.GetExportedValue<IRInteractiveWorkflowProvider>().GetOrCreate());
EditorShell = ExportProvider.GetExportedValue<IEditorShell>();
FunctionIndex = ExportProvider.GetExportedValue<IFunctionIndex>();
PackageIndex = ExportProvider.GetExportedValue<IPackageIndex>();
}
public PlotDeviceNewCommand(IRInteractiveWorkflow workflow) {
if (workflow == null) {
throw new ArgumentNullException(nameof(workflow));
}
_workflow = workflow;
}
public ReplCommandTest() {
_debuggerModeTracker = new VsDebuggerModeTracker();
_workflowProvider = TestRInteractiveWorkflowProviderFactory.Create(
connectionsProvider: new ConnectionManagerProvider(new TestStatusBar(), RToolsSettings.Current),
debuggerModeTracker: _debuggerModeTracker);
_workflow = _workflowProvider.GetOrCreate();
}
public PlotHistoryCommand(IRInteractiveWorkflow interactiveWorkflow, IRPlotHistoryVisualComponent visualComponent) :
base(interactiveWorkflow) {
if (visualComponent == null) {
throw new ArgumentNullException(nameof(visualComponent));
}
VisualComponent = visualComponent;
}
public SendToReplCommand(ITextView textView, IRInteractiveWorkflow interactiveWorkflow) :
base(textView, new[] {
new CommandId(VSConstants.VsStd11, (int)VSConstants.VSStd11CmdID.ExecuteLineInInteractive),
new CommandId(VSConstants.VsStd11, (int)VSConstants.VSStd11CmdID.ExecuteSelectionInInteractive)
}, false) {
_interactiveWorkflow = interactiveWorkflow;
}
public SearchWebForCurrentCommand(
IRInteractiveWorkflow workflow,
IActiveWpfTextViewTracker textViewTracker,
IActiveRInteractiveWindowTracker activeReplTracker,
IWebBrowserServices webBrowserServices) :
base(RGuidList.RCmdSetGuid, RPackageCommandId.icmdSearchWebForCurrent,
workflow, textViewTracker, activeReplTracker, Resources.SearchWebFor) {
_webBrowserServices = webBrowserServices;
}
public RInteractiveEvaluatorTest(RComponentsMefCatalogFixture catalog) {
_exportProvider = catalog.CreateExportProvider();
var settings = _exportProvider.GetExportedValue<IRSettings>();
settings.RCodePage = 1252;
_workflowProvider = _exportProvider.GetExportedValue<IRInteractiveWorkflowProvider>();
_workflow = UIThreadHelper.Instance.Invoke(() => _workflowProvider.GetOrCreate());
}
public RPlotIntegrationTest(RComponentsMefCatalogFixture catalog, TestMethodFixture testMethod, TestFilesFixture testFiles) {
_exportProvider = catalog.CreateExportProvider();
_workflowProvider = _exportProvider.GetExportedValue<TestRInteractiveWorkflowProvider>();
_workflow = _workflowProvider.GetOrCreate();
_plotDeviceVisualComponentContainerFactory = _exportProvider.GetExportedValue<TestRPlotDeviceVisualComponentContainerFactory>();
_plotHistoryVisualComponentContainerFactory = _exportProvider.GetExportedValue<IRPlotHistoryVisualComponentContainerFactory>();
_testMethod = testMethod.MethodInfo;
_testFiles = testFiles;
}
public SendHistoryToSourceCommand(ITextView textView, IRHistoryProvider historyProvider, IRInteractiveWorkflow interactiveWorkflow, IContentTypeRegistryService contentTypeRegistry, IActiveWpfTextViewTracker textViewTracker)
: base(textView, RGuidList.RCmdSetGuid, RPackageCommandId.icmdSendHistoryToSource, false) {
_textViewTracker = textViewTracker;
_interactiveWorkflow = interactiveWorkflow;
_history = historyProvider.GetAssociatedRHistory(textView);
_contentTypes.Add(contentTypeRegistry.GetContentType(RContentTypeDefinition.ContentType));
_contentTypes.Add(contentTypeRegistry.GetContentType(MdProjectionContentTypeDefinition.ContentType));
}
public ConfigurationSettingCommand(
int id, string settingNameTemplate,
IProjectSystemServices pss,
IProjectConfigurationSettingsProvider pcsp,
IRInteractiveWorkflow workflow) : base(id, workflow) {
_id = id;
_settingNameTemplate = settingNameTemplate;
_projectSystemServices = pss;
_projectConfigurationSettingsProvider = pcsp;
}
public RSessionCallback(IInteractiveWindow interactiveWindow, IRSession session, IRSettings settings, ICoreShell coreShell, IFileSystem fileSystem) {
_interactiveWindow = interactiveWindow;
_session = session;
_settings = settings;
_coreShell = coreShell;
_fileSystem = fileSystem;
var workflowProvider = _coreShell.ExportProvider.GetExportedValue<IRInteractiveWorkflowProvider>();
_workflow = workflowProvider.GetOrCreate();
}
public VsRHistoryCommandFactory(IRHistoryProvider historyProvider,
IRInteractiveWorkflowProvider interactiveWorkflowProvider,
IContentTypeRegistryService contentTypeRegistry,
IActiveWpfTextViewTracker textViewTracker) {
_historyProvider = historyProvider;
_interactiveWorkflow = interactiveWorkflowProvider.GetOrCreate();
_contentTypeRegistry = contentTypeRegistry;
_textViewTracker = textViewTracker;
}
public InterruptRCommand(IRInteractiveWorkflow interactiveWorkflow, IDebuggerModeTracker debuggerModeTracker) {
_interactiveWorkflow = interactiveWorkflow;
_session = interactiveWorkflow.RSession;
_debuggerModeTracker = debuggerModeTracker;
_session.Connected += OnConnected;
_session.Disconnected += OnDisconnected;
_session.BeforeRequest += OnBeforeRequest;
_session.AfterRequest += OnAfterRequest;
}
public RSessionCallback(IInteractiveWindow interactiveWindow, IRSession session, IRSettings settings, IServiceContainer services, IFileSystem fileSystem)
{
_interactiveWindow = interactiveWindow;
_session = session;
_settings = settings;
_services = services;
_fileSystem = fileSystem;
var workflowProvider = _services.GetService <IRInteractiveWorkflowProvider>();
_workflow = workflowProvider.GetOrCreate();
}
public HelpOnCurrentCommandBase(
Guid group, int id,
IRInteractiveWorkflow workflow,
IActiveWpfTextViewTracker textViewTracker,
IActiveRInteractiveWindowTracker activeReplTracker,
string baseCommandName) :
base(group, id) {
_activeReplTracker = activeReplTracker;
_workflow = workflow;
_textViewTracker = textViewTracker;
_baseCommandName = baseCommandName;
}
public FilesCompletionProvider(string directoryCandidate, IServiceContainer services, bool forceR = false)
{
Check.ArgumentNull(nameof(directoryCandidate), directoryCandidate);
_fs = services.GetService <IFileSystem>();
_workflow = services.GetService <IRInteractiveWorkflowProvider>().GetOrCreate();
_imageService = services.GetService <IImageService>();
_forceR = forceR;
_enteredDirectory = ExtractDirectory(directoryCandidate);
_task = GetRootDirectoryAsync(_enteredDirectory);
}
public AD7Engine()
{
var compModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel));
if (compModel == null)
{
throw new InvalidOperationException(Invariant($"{typeof(AD7Engine).FullName} requires {nameof(IComponentModel)} global service"));
}
compModel.DefaultCompositionService.SatisfyImportsOnce(this);
_workflow = WorkflowProvider.GetOrCreate();
}
public RSessionCallback(IInteractiveWindow interactiveWindow, IRSession session, IRSettings settings, ICoreShell coreShell, IFileSystem fileSystem)
{
_interactiveWindow = interactiveWindow;
_session = session;
_settings = settings;
_coreShell = coreShell;
_fileSystem = fileSystem;
var workflowProvider = _coreShell.ExportProvider.GetExportedValue <IRInteractiveWorkflowProvider>();
_workflow = workflowProvider.GetOrCreate();
}
public RPlotManager(IRSettings settings, IRInteractiveWorkflow interactiveWorkflow, IFileSystem fileSystem)
{
_interactiveWorkflow = interactiveWorkflow;
_fileSystem = fileSystem;
_disposableBag = DisposableBag.Create <RPlotManager>()
.Add(() => interactiveWorkflow.RSession.Connected -= RSession_Connected)
.Add(() => interactiveWorkflow.RSession.Mutated -= RSession_Mutated);
interactiveWorkflow.RSession.Connected += RSession_Connected;
interactiveWorkflow.RSession.Mutated += RSession_Mutated;
}
public RPlotManager(IRSettings settings, IRInteractiveWorkflow interactiveWorkflow, IFileSystem fileSystem) {
_interactiveWorkflow = interactiveWorkflow;
_fileSystem = fileSystem;
_shell = _interactiveWorkflow.Shell;
_disposableBag = DisposableBag.Create<RPlotManager>()
.Add(() => interactiveWorkflow.RSession.Connected -= RSession_Connected)
.Add(() => interactiveWorkflow.RSession.Mutated -= RSession_Mutated);
interactiveWorkflow.RSession.Connected += RSession_Connected;
interactiveWorkflow.RSession.Mutated += RSession_Mutated;
}
public HelpOnCurrentCommandBase(
Guid group, int id,
IRInteractiveWorkflow workflow,
IActiveWpfTextViewTracker textViewTracker,
IActiveRInteractiveWindowTracker activeReplTracker,
string baseCommandName) :
base(group, id)
{
_activeReplTracker = activeReplTracker;
_workflow = workflow;
_textViewTracker = textViewTracker;
_baseCommandName = baseCommandName;
}
public CurrentDirectoryTest() {
var connectionsProvider = VsAppShell.Current.ExportProvider.GetExportedValue<IConnectionManagerProvider>();
var historyProvider = VsAppShell.Current.ExportProvider.GetExportedValue<IRHistoryProvider>();
var packagesProvider = VsAppShell.Current.ExportProvider.GetExportedValue<IRPackageManagerProvider>();
var plotsProvider = VsAppShell.Current.ExportProvider.GetExportedValue<IRPlotManagerProvider>();
var activeTextViewTracker = new ActiveTextViewTrackerMock(string.Empty, string.Empty);
var debuggerModeTracker = new TestDebuggerModeTracker();
_interactiveWorkflow = UIThreadHelper.Instance.Invoke(() => new RInteractiveWorkflow(
connectionsProvider, historyProvider, packagesProvider, plotsProvider, activeTextViewTracker,
debuggerModeTracker, VsAppShell.Current, RToolsSettings.Current));
_sessionProvider = _interactiveWorkflow.RSessions;
}
public RPlotIntegrationUITest(RComponentsMefCatalogFixture catalog, ContainerHostMethodFixture containerHost) {
_containerHost = containerHost;
_exportProvider = catalog.CreateExportProvider();
_exportProvider.GetExportedValue<TestRInteractiveWorkflowProvider>();
_plotDeviceVisualComponentContainerFactory = _exportProvider.GetExportedValue<TestRPlotDeviceVisualComponentContainerFactory>();
// Don't override the standard behavior of using the control size
_plotDeviceVisualComponentContainerFactory.DeviceProperties = null;
_plotHistoryVisualComponentContainerFactory = _exportProvider.GetExportedValue<IRPlotHistoryVisualComponentContainerFactory>();
_workflow = _exportProvider.GetExportedValue<IRInteractiveWorkflowProvider>().GetOrCreate();
_plotVisualComponent = UIThreadHelper.Instance.Invoke(() => _workflow.Plots.GetOrCreateVisualComponent(_plotDeviceVisualComponentContainerFactory, PlotWindowInstanceId));
UIThreadHelper.Instance.Invoke(() => _workflow.Plots.RegisterVisualComponent(_plotVisualComponent));
}
public SourceRScriptCommand(IRInteractiveWorkflow interactiveWorkflow, IActiveWpfTextViewTracker activeTextViewTracker)
: base(RGuidList.RCmdSetGuid, RPackageCommandId.icmdSourceRScript) {
_interactiveWorkflow = interactiveWorkflow;
_activeTextViewTracker = activeTextViewTracker;
_operations = interactiveWorkflow.Operations;
_monitorSelection = VsAppShell.Current.GetGlobalService<IVsMonitorSelection>(typeof(SVsShellMonitorSelection));
if (_monitorSelection != null) {
var debugUIContextGuid = new Guid(UIContextGuids.Debugging);
if (ErrorHandler.Failed(_monitorSelection.GetCmdUIContextCookie(ref debugUIContextGuid, out _debugUIContextCookie))) {
_monitorSelection = null;
}
}
}
public async Task InitializeProjectFromDiskAsync()
{
await Project.CreateInMemoryImport();
_fileWatcher.Start();
await _threadHandling.SwitchToUIThread();
// Make sure R package is loaded
VsAppShell.EnsurePackageLoaded(RGuidList.RPackageGuid);
// Verify project is not on a network share and give warning if it is
CheckRemoteDrive(_projectDirectory);
_workflow = _workflowProvider.GetOrCreate();
_session = _workflow.RSession;
_history = _workflow.History;
if (_workflow.ActiveWindow == null)
{
var window = await _workflow.GetOrCreateVisualComponentAsync();
window.Container.Show(focus: true, immediate: false);
}
try {
await _session.HostStarted;
} catch (Exception) {
return;
}
// TODO: need to compute the proper paths for remote, but they might not even exist if the project hasn't been deployed.
// https://github.com/Microsoft/RTVS/issues/2223
if (!_session.IsRemote)
{
var rdataPath = Path.Combine(_projectDirectory, DefaultRDataName);
bool loadDefaultWorkspace = _coreShell.Services.FileSystem.FileExists(rdataPath) && await GetLoadDefaultWorkspace(rdataPath);
if (loadDefaultWorkspace)
{
await _session.LoadWorkspaceAsync(rdataPath);
}
await _session.SetWorkingDirectoryAsync(_projectDirectory);
_toolsSettings.WorkingDirectory = _projectDirectory;
}
_history.TryLoadFromFile(Path.Combine(_projectDirectory, DefaultRHistoryName));
CheckSurveyNews();
}
public RPlotIntegrationUITest(IExportProvider exportProvider, ContainerHostMethodFixture containerHost)
{
_containerHost = containerHost;
_exportProvider = exportProvider;
_exportProvider.GetExportedValue <TestRInteractiveWorkflowProvider>();
_plotDeviceVisualComponentContainerFactory = _exportProvider.GetExportedValue <TestRPlotDeviceVisualComponentContainerFactory>();
// Don't override the standard behavior of using the control size
_plotDeviceVisualComponentContainerFactory.DeviceProperties = null;
_plotHistoryVisualComponentContainerFactory = _exportProvider.GetExportedValue <IRPlotHistoryVisualComponentContainerFactory>();
_workflow = _exportProvider.GetExportedValue <IRInteractiveWorkflowProvider>().GetOrCreate();
_plotVisualComponent = UIThreadHelper.Instance.Invoke(() => _workflow.Plots.GetOrCreateVisualComponent(_plotDeviceVisualComponentContainerFactory, PlotWindowInstanceId));
UIThreadHelper.Instance.Invoke(() => _workflow.Plots.RegisterVisualComponent(_plotVisualComponent));
}
public async Task InitializeProjectFromDiskAsync()
{
await Project.CreateInMemoryImport();
_fileWatcher.Start();
// Force REPL window up and continue only when it is shown
await _threadHandling.SwitchToUIThread();
// Make sure R package is loaded
VsAppShell.EnsurePackageLoaded(RGuidList.RPackageGuid);
// Verify project is not on a network share and give warning if it is
CheckRemoteDrive(_projectDirectory);
_workflow = _workflowProvider.GetOrCreate();
_session = _workflow.RSession;
_history = _workflow.History;
if (_workflow.ActiveWindow == null)
{
var window = await _workflow.GetOrCreateVisualComponent(_componentContainerFactory);
window.Container.Show(true);
}
try {
await _session.HostStarted;
} catch (Exception) {
return;
}
var rdataPath = Path.Combine(_projectDirectory, DefaultRDataName);
bool loadDefaultWorkspace = _fileSystem.FileExists(rdataPath) && await GetLoadDefaultWorkspace(rdataPath);
using (var evaluation = await _session.BeginEvaluationAsync()) {
if (loadDefaultWorkspace)
{
await evaluation.LoadWorkspace(rdataPath);
}
await evaluation.SetWorkingDirectory(_projectDirectory);
}
_toolsSettings.WorkingDirectory = _projectDirectory;
_history.TryLoadFromFile(Path.Combine(_projectDirectory, DefaultRHistoryName));
CheckSurveyNews();
}
private async Task ConnectAsync(CancellationToken ct)
{
var provider = _services.GetService <IRInteractiveWorkflowProvider>();
_workflow = provider.GetOrCreate();
_ui = _services.GetService <IHostUIService>();
_ui.SetLogLevel(MessageType.Info);
var e = GetREngine();
if (e == null)
{
return;
}
var log = _services.Log();
var info = BrokerConnectionInfo.Create("(local)", e.InstallPath, e.Architecture, string.Empty);
var start = DateTime.Now;
_ui.LogMessageAsync($"Starting R Process with {e.InstallPath}...", MessageType.Info).DoNotWait();
try {
if (await _workflow.RSessions.TrySwitchBrokerAsync("(local)", info, ct))
{
try {
await _workflow.RSession.StartHostAsync(new RHostStartupInfo(), new RSessionCallback(), _services.UI(), Debugger.IsAttached? 1000000 : 20000, ct);
} catch (Exception ex) {
_ui.ShowMessageAsync($"Unable to start Microsoft.R.Host process. Exception: {ex.Message}", MessageType.Error).DoNotWait();
return;
}
// Start package building
_ui.LogMessageAsync($"complete in {FormatElapsed(DateTime.Now - start)}", MessageType.Info).DoNotWait();
start = DateTime.Now;
_ui.LogMessageAsync("Building IntelliSense index...", MessageType.Info).DoNotWait();
_packageIndex = _services.GetService <IPackageIndex>();
_packageIndex.BuildIndexAsync(ct).ContinueWith(t => {
_ui.LogMessageAsync($"complete in {FormatElapsed(DateTime.Now - start)}", MessageType.Info).DoNotWait();
}, ct, TaskContinuationOptions.None, TaskScheduler.Default).DoNotWait();
}
else
{
_ui.ShowMessageAsync($"Unable to connect to broker.", MessageType.Error).DoNotWait();
}
} catch (Exception ex) {
_ui.ShowMessageAsync($"Unable to connect to broker. Exception: {ex.Message}", MessageType.Error).DoNotWait();
}
}
public CurrentDirectoryTest()
{
_sessionProvider = new RSessionProvider(TestCoreServices.CreateReal());
var connectionsProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IConnectionManagerProvider>();
var historyProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IRHistoryProvider>();
var packagesProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IRPackageManagerProvider>();
var plotsProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IRPlotManagerProvider>();
var activeTextViewTracker = new ActiveTextViewTrackerMock(string.Empty, string.Empty);
var debuggerModeTracker = new TestDebuggerModeTracker();
_interactiveWorkflow = UIThreadHelper.Instance.Invoke(() => new RInteractiveWorkflow(
_sessionProvider, connectionsProvider, historyProvider, packagesProvider, plotsProvider, activeTextViewTracker,
debuggerModeTracker, VsAppShell.Current, RToolsSettings.Current, null, () => { }));
}
public CurrentDirectoryTest()
{
var connectionsProvider = VsAppShell.Current.GlobalServices.GetService <IConnectionManagerProvider>();
var historyProvider = VsAppShell.Current.GlobalServices.GetService <IRHistoryProvider>();
var packagesProvider = VsAppShell.Current.GlobalServices.GetService <IRPackageManagerProvider>();
var plotsProvider = VsAppShell.Current.GlobalServices.GetService <IRPlotManagerProvider>();
var activeTextViewTracker = new ActiveTextViewTrackerMock(string.Empty, string.Empty);
var debuggerModeTracker = new TestDebuggerModeTracker();
_interactiveWorkflow = UIThreadHelper.Instance.Invoke(() => new RInteractiveWorkflow(
connectionsProvider, historyProvider, packagesProvider, plotsProvider, activeTextViewTracker,
debuggerModeTracker, VsAppShell.Current, RToolsSettings.Current));
_sessionProvider = _interactiveWorkflow.RSessions;
}
public WorkingDirectoryCommand(IRInteractiveWorkflow interactiveWorkflow) :
base(new[] {
new CommandId(RGuidList.RCmdSetGuid, RPackageCommandId.icmdGetDirectoryList),
new CommandId(RGuidList.RCmdSetGuid, RPackageCommandId.icmdSetWorkingDirectory)
}, false) {
_interactiveWorkflow = interactiveWorkflow;
_session = interactiveWorkflow.RSession;
_session.Connected += OnSessionConnected;
_session.DirectoryChanged += OnCurrentDirectoryChanged;
if (InitializationTask == null && _session.IsHostRunning) {
InitializationTask = UpdateRUserDirectoryAsync();
}
}
public FilesCompletionProvider(string directoryCandidate, IRInteractiveWorkflow workflow, IImagesProvider imagesProvider, IGlyphService glyphService, bool forceR = false)
{
if (directoryCandidate == null)
{
throw new ArgumentNullException(nameof(directoryCandidate));
}
_imagesProvider = imagesProvider;
_workflow = workflow;
_glyphService = glyphService;
_forceR = forceR;
_enteredDirectory = ExtractDirectory(directoryCandidate);
_task = GetRootDirectoryAsync(_enteredDirectory);
}
private async Task ConnectAsync(CancellationToken ct)
{
var provider = _services.GetService <IRInteractiveWorkflowProvider>();
_workflow = provider.GetOrCreate();
_ui = _services.GetService <IUIService>();
_ui.SetLogLevel(MessageType.Info);
var e = GetREngine();
if (e == null)
{
return;
}
var log = _services.Log();
var info = BrokerConnectionInfo.Create(_services.Security(), "VSCR", e.InstallPath, string.Empty, false);
var start = DateTime.Now;
var message = $"Starting R Process with {e.InstallPath}...";
_ui.LogMessageAsync(message, MessageType.Info).DoNotWait();
log.Write(LogVerbosity.Normal, MessageCategory.General, $"Switching local broker to {e.InstallPath}");
if (await _workflow.RSessions.TrySwitchBrokerAsync("VSCR", info, ct))
{
try {
await _workflow.RSession.StartHostAsync(new RHostStartupInfo(), new RSessionCallback(), Debugger.IsAttached? 100000 : 20000, ct);
} catch (Exception ex) {
_ui.ShowMessageAsync($"Unable to start R process. Exception: {ex.Message}", MessageType.Error).DoNotWait();
return;
}
// Start package building
_ui.LogMessageAsync($"complete in {FormatElapsed(DateTime.Now - start)}", MessageType.Info).DoNotWait();
start = DateTime.Now;
_ui.LogMessageAsync("Building IntelliSense index...", MessageType.Info).DoNotWait();
_packageIndex = _services.GetService <IPackageIndex>();
_packageIndex.BuildIndexAsync(ct).ContinueWith(t => {
_ui.LogMessageAsync($"complete in {FormatElapsed(DateTime.Now - start)}", MessageType.Info).DoNotWait();
}, ct, TaskContinuationOptions.None, TaskScheduler.Default).DoNotWait();
}
else
{
_ui.ShowMessageAsync("Unable to start R process", MessageType.Error).DoNotWait();
}
}
public CurrentDirectoryTest()
{
var sessionProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IRSessionProvider>();
var connectionsProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IConnectionManagerProvider>();
var historyProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IRHistoryProvider>();
var packagesProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IRPackageManagerProvider>();
var plotsProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IRPlotManagerProvider>();
var activeTextViewTracker = new ActiveTextViewTrackerMock(string.Empty, string.Empty);
var debuggerModeTracker = new TestDebuggerModeTracker();
var brokerConnector = new RHostBrokerConnector();
brokerConnector.SwitchToLocalBroker(nameof(CurrentDirectoryTest));
_interactiveWorkflow = new RInteractiveWorkflow(
sessionProvider, connectionsProvider, historyProvider, packagesProvider, plotsProvider, activeTextViewTracker,
debuggerModeTracker, brokerConnector, VsAppShell.Current, RToolsSettings.Current, () => brokerConnector.Dispose());
}
public WorkingDirectoryCommand(IRInteractiveWorkflow interactiveWorkflow) :
base(new[] {
new CommandId(RGuidList.RCmdSetGuid, RPackageCommandId.icmdGetDirectoryList),
new CommandId(RGuidList.RCmdSetGuid, RPackageCommandId.icmdSetWorkingDirectory)
}, false)
{
_interactiveWorkflow = interactiveWorkflow;
_session = interactiveWorkflow.RSession;
_session.Connected += OnSessionConnected;
_session.DirectoryChanged += OnCurrentDirectoryChanged;
if (InitializationTask == null && _session.IsHostRunning)
{
InitializationTask = UpdateRUserDirectoryAsync();
}
}
public SourceRScriptCommand(IRInteractiveWorkflow interactiveWorkflow, IActiveWpfTextViewTracker activeTextViewTracker)
: base(RGuidList.RCmdSetGuid, RPackageCommandId.icmdSourceRScript)
{
_interactiveWorkflow = interactiveWorkflow;
_activeTextViewTracker = activeTextViewTracker;
_operations = interactiveWorkflow.Operations;
_monitorSelection = VsAppShell.Current.GetGlobalService <IVsMonitorSelection>(typeof(SVsShellMonitorSelection));
if (_monitorSelection != null)
{
var debugUIContextGuid = new Guid(UIContextGuids.Debugging);
if (ErrorHandler.Failed(_monitorSelection.GetCmdUIContextCookie(ref debugUIContextGuid, out _debugUIContextCookie)))
{
_monitorSelection = null;
}
}
}
public CurrentDirectoryTest(BrokerFixture broker)
{
_broker = broker;
_sessionProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IRSessionProvider>();
var connectionsProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IConnectionManagerProvider>();
var historyProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IRHistoryProvider>();
var packagesProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IRPackageManagerProvider>();
var plotsProvider = VsAppShell.Current.ExportProvider.GetExportedValue <IRPlotManagerProvider>();
var activeTextViewTracker = new ActiveTextViewTrackerMock(string.Empty, string.Empty);
var debuggerModeTracker = new TestDebuggerModeTracker();
_interactiveWorkflow = new RInteractiveWorkflow(
_sessionProvider, connectionsProvider, historyProvider, packagesProvider, plotsProvider, activeTextViewTracker,
debuggerModeTracker, _broker.BrokerConnector, VsAppShell.Current, RToolsSettings.Current, null, () => { });
}
public HistoryNavigationCommand(ITextView textView, IRInteractiveWorkflow interactiveWorkflow, ICompletionBroker completionBroker, IEditorOperationsFactoryService editorFactory) :
base(textView, new[] {
new CommandId(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.UP),
new CommandId(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.DOWN),
new CommandId(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.LEFT),
new CommandId(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.RIGHT),
new CommandId(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.UP_EXT),
new CommandId(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.DOWN_EXT),
new CommandId(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.LEFT_EXT),
new CommandId(VSConstants.VSStd2K, (int)VSConstants.VSStd2KCmdID.RIGHT_EXT)
}, false)
{
_completionBroker = completionBroker;
_editorFactory = editorFactory;
_interactiveWorkflow = interactiveWorkflow;
_history = interactiveWorkflow.History;
}
public RPlotIntegrationUITest(RComponentsMefCatalogFixture catalog, ContainerHostMethodFixture containerHost, TestMethodFixture testMethod, TestFilesFixture testFiles)
{
_containerHost = containerHost;
_exportProvider = catalog.CreateExportProvider();
_workflowProvider = _exportProvider.GetExportedValue <TestRInteractiveWorkflowProvider>();
_workflowProvider.BrokerName = nameof(RPlotIntegrationTest);
_plotDeviceVisualComponentContainerFactory = _exportProvider.GetExportedValue <TestRPlotDeviceVisualComponentContainerFactory>();
// Don't override the standard behavior of using the control size
_plotDeviceVisualComponentContainerFactory.DeviceProperties = null;
_plotHistoryVisualComponentContainerFactory = _exportProvider.GetExportedValue <IRPlotHistoryVisualComponentContainerFactory>();
_workflow = _exportProvider.GetExportedValue <IRInteractiveWorkflowProvider>().GetOrCreate();
_componentContainerFactory = _exportProvider.GetExportedValue <IInteractiveWindowComponentContainerFactory>();
_testMethod = testMethod.MethodInfo;
_testFiles = testFiles;
_plotVisualComponent = UIThreadHelper.Instance.Invoke(() => _workflow.Plots.GetOrCreateVisualComponent(_plotDeviceVisualComponentContainerFactory, PlotWindowInstanceId));
UIThreadHelper.Instance.Invoke(() => _workflow.Plots.RegisterVisualComponent(_plotVisualComponent));
}
public PackageIndex(
IRInteractiveWorkflowProvider interactiveWorkflowProvider, ICoreShell shell, IIntellisenseRSession host, IFunctionIndex functionIndex)
{
_shell = shell;
_host = host;
_functionIndex = functionIndex;
_workflow = interactiveWorkflowProvider.GetOrCreate();
_interactiveSession = _workflow.RSession;
_interactiveSession.Connected += OnSessionConnected;
_interactiveSession.PackagesRemoved += OnPackagesRemoved;
_workflow.RSessions.BrokerStateChanged += OnBrokerStateChanged;
if (_workflow.RSession.IsHostRunning)
{
BuildIndexAsync().DoNotWait();
}
}
private bool _forceR; // for tests
public FilesCompletionProvider(string directoryCandidate, IRInteractiveWorkflow workflow, IImagesProvider imagesProvider, IGlyphService glyphService, bool forceR = false)
{
if (directoryCandidate == null)
{
throw new ArgumentNullException(nameof(directoryCandidate));
}
_imagesProvider = imagesProvider;
_workflow = workflow;
_glyphService = glyphService;
_forceR = forceR;
_directory = ExtractDirectory(directoryCandidate);
if (_directory.Length == 0 || _directory.StartsWithOrdinal("~\\"))
{
_directory = _directory.Length > 1 ? _directory.Substring(2) : _directory;
_userDirectoryFetchingTask = _workflow.RSession.GetRUserDirectoryAsync();
}
}
public RPackageManager(IRSettings settings, IRInteractiveWorkflow interactiveWorkflow, Action dispose)
{
_session = interactiveWorkflow.RSessions.GetOrCreate(SessionNames.PackageManager);
_settings = settings;
_interactiveWorkflow = interactiveWorkflow;
_loadedPackagesEvent = new DirtyEventSource(this);
_installedPackagesEvent = new DirtyEventSource(this);
_availablePackagesEvent = new DirtyEventSource(this);
_disposableBag = DisposableBag.Create <RPackageManager>(dispose)
.Add(() => _interactiveWorkflow.RSessions.BrokerChanged -= BrokerChanged)
.Add(() => _interactiveWorkflow.RSession.Mutated -= RSessionMutated)
.Add(() => _interactiveWorkflow.RSession.PackagesInstalled -= PackagesInstalled)
.Add(() => _interactiveWorkflow.RSession.PackagesRemoved -= PackagesRemoved);
_interactiveWorkflow.RSessions.BrokerChanged += BrokerChanged;
_interactiveWorkflow.RSession.Mutated += RSessionMutated;
_interactiveWorkflow.RSession.PackagesInstalled += PackagesInstalled;
_interactiveWorkflow.RSession.PackagesRemoved += PackagesRemoved;
}
public RPlotHistoryCommands(IRInteractiveWorkflow interactiveWorkflow, IRPlotHistoryVisualComponent visualComponent)
{
if (interactiveWorkflow == null)
{
throw new ArgumentNullException(nameof(interactiveWorkflow));
}
if (visualComponent == null)
{
throw new ArgumentNullException(nameof(visualComponent));
}
ZoomIn = new PlotHistoryZoomInCommand(interactiveWorkflow, visualComponent);
ZoomOut = new PlotHistoryZoomOutCommand(interactiveWorkflow, visualComponent);
AutoHide = new PlotHistoryAutoHideCommand(interactiveWorkflow, visualComponent);
Cut = new PlotHistoryCutCopyCommand(interactiveWorkflow, visualComponent, cut: true);
Copy = new PlotHistoryCutCopyCommand(interactiveWorkflow, visualComponent, cut: false);
Remove = new PlotHistoryRemoveCommand(interactiveWorkflow, visualComponent);
ActivatePlot = new PlotHistoryActivateCommand(interactiveWorkflow, visualComponent);
}
public async Task <string> ExecuteCodeAsync(string code, CancellationToken ct)
{
await TaskUtilities.SwitchToBackgroundThread();
var result = string.Empty;
_workflow = _workflow ?? _services.GetService <IRInteractiveWorkflowProvider>().GetOrCreate();
try {
ct.ThrowIfCancellationRequested();
var session = await StartSessionAsync(ct);
session.Output += OnSessionOutput;
await ExecuteAndCaptureOutputAsync(session, code, ct);
if (_sessionCallback.PlotResult != null)
{
result = "$$IMAGE " + Convert.ToBase64String(_sessionCallback.PlotResult);
_sessionCallback.PlotResult = null;
}
else if (_output != null && _output.Length > 0)
{
result = _output.ToString();
}
else if (_errors != null && _errors.Length > 0)
{
result = "$$ERROR " + _errors;
}
} catch (Exception ex) when(!ex.IsCriticalException())
{
_output = _errors = null;
result = ex.Message;
} finally {
if (_session != null)
{
_session.Output -= OnSessionOutput;
}
}
return(result);
}
public PackageIndex(IServiceContainer services, IIntellisenseRSession host, IFunctionIndex functionIndex)
{
_host = host;
_functionIndex = functionIndex;
_idleTime = services.GetService <IIdleTimeService>();
var interactiveWorkflowProvider = services.GetService <IRInteractiveWorkflowProvider>();
_workflow = interactiveWorkflowProvider.GetOrCreate();
_interactiveSession = _workflow.RSession;
_interactiveSession.Connected += OnSessionConnected;
_interactiveSession.PackagesInstalled += OnPackagesChanged;
_interactiveSession.PackagesRemoved += OnPackagesChanged;
_workflow.RSessions.BrokerStateChanged += OnBrokerStateChanged;
if (_workflow.RSession.IsHostRunning)
{
BuildIndexAsync().DoNotWait();
}
}
public RHistory(IRInteractiveWorkflow interactiveWorkflow, ITextBuffer textBuffer, IFileSystem fileSystem, IRSettings settings, IEditorOperationsFactoryService editorOperationsFactory, IRtfBuilderService rtfBuilderService, Action dispose)
{
_interactiveWorkflow = interactiveWorkflow;
_historyTextBuffer = textBuffer;
_fileSystem = fileSystem;
_editorOperationsFactory = editorOperationsFactory;
_rtfBuilderService = rtfBuilderService;
_dispose = dispose;
_textBufferIsEditable = new CountdownDisposable(MakeTextBufferReadOnly);
_isMultiline = settings.MultilineHistorySelection;
if (_isMultiline)
{
_entries = new MultilineRHistoryEntries();
}
else
{
_entries = new SinglelineRHistoryEntries();
}
MakeTextBufferReadOnly();
}
public ConnectionManager(IStatusBar statusBar, IRSettings settings, IRInteractiveWorkflow interactiveWorkflow)
{
_statusBar = statusBar;
_sessionProvider = interactiveWorkflow.RSessions;
_settings = settings;
_shell = interactiveWorkflow.Shell;
_statusBarViewModel = new ConnectionStatusBarViewModel(this, interactiveWorkflow.Shell);
_disposableBag = DisposableBag.Create <ConnectionManager>()
.Add(_statusBarViewModel)
.Add(() => _sessionProvider.BrokerStateChanged -= BrokerStateChanged);
_sessionProvider.BrokerStateChanged += BrokerStateChanged;
// Get initial values
var userConnections = CreateConnectionList();
_userConnections = new ConcurrentDictionary <Uri, IConnection>(userConnections);
UpdateRecentConnections(save: false);
CompleteInitializationAsync().DoNotWait();
}
protected AttachDebuggerCommand(IRInteractiveWorkflow interactiveWorkflow, int cmdId, DebuggerCommandVisibility visibility)
: base(interactiveWorkflow, cmdId, visibility)
{
_interactiveWorkflow = interactiveWorkflow;
}
public AttachDebuggerCommand(IRInteractiveWorkflow interactiveWorkflow)
: base(interactiveWorkflow, RPackageCommandId.icmdAttachDebugger, DebuggerCommandVisibility.DesignMode)
{
_interactiveWorkflow = interactiveWorkflow;
}
