public LoadWorkspaceCommand(IApplicationShell appShell, IRInteractiveWorkflow interactiveWorkflow, IProjectServiceAccessor projectServiceAccessor) :
base(RGuidList.RCmdSetGuid, RPackageCommandId.icmdLoadWorkspace) {
_appShell = appShell;
_interactiveWorkflow = interactiveWorkflow;
_rSession = interactiveWorkflow.RSession;
_projectServiceAccessor = projectServiceAccessor;
}
public SessionCommand(IRSession session, Guid group, int id) :
base(group, id) {
if (session == null) {
throw new ArgumentNullException(nameof(session));
}
RSession = session;
}
public VariableGridHost() {
InitializeComponent();
_aggregator = VsAppShell.Current.ExportProvider.GetExportedValue<IObjectDetailsViewerAggregator>();
_rSession = VsAppShell.Current.ExportProvider.GetExportedValue<IRInteractiveWorkflowProvider>().GetOrCreate().RSession;
_rSession.Mutated += RSession_Mutated;
}
public PlotContentProvider(IRSession session) {
_lastPixelWidth = -1;
_lastPixelHeight = -1;
_rSession = session;
_rSession.Connected += RSession_Connected;
}
internal RValueInfo(
IRSession session,
string environmentExpression,
string expression,
string name,
string representation,
RChildAccessorKind accessorKind,
string typeName,
IReadOnlyList<string> classes,
int? length,
int? attributeCount,
int? slotCount,
int? nameCount,
IReadOnlyList<int> dim,
RValueFlags flags,
bool canCoerceToDataFrame
) : base(session, environmentExpression, expression, name) {
Representation = representation;
AccessorKind = accessorKind;
TypeName = typeName;
Classes = classes;
Length = length;
AttributeCount = attributeCount;
SlotCount = slotCount;
NameCount = nameCount;
Dim = dim;
Flags = flags;
CanCoerceToDataFrame = canCoerceToDataFrame;
}
public GoToDefinitionCommand(ITextView textView, ITextBuffer textBuffer, IObjectViewer objectViewer, IRSession session) :
base(textView, new CommandId(typeof(VSConstants.VSStd97CmdID).GUID,
(int)VSConstants.VSStd97CmdID.GotoDefn), needCheckout: false) {
_textBuffer = textBuffer;
_objectViewer = objectViewer;
_session = session;
}
public void Dispose() {
if (_session != null) {
_session.Disposed -= OnSessionDisposed;
_session.Dispose();
_session = null;
}
}
public void Dispose() {
if (_session != null) {
_session.Connected -= OnSessionConnected;
_session.DirectoryChanged -= OnCurrentDirectoryChanged;
}
_session = null;
}
private void OnSessionDisposed(object sender, EventArgs e) {
if (Session != null) {
Session.Mutated -= OnSessionMutated;
Session.Disposed -= OnSessionDisposed;
Session = null;
}
}
private async Task RMarkdownRenderAsync(IRSession session, IFileSystem fs, string inputFilePath, string outputFilePath, string format, int codePage, IApplicationShell appShell) {
using (var fts = new DataTransferSession(session, fs)) {
string currentStatusText = string.Empty;
uint cookie = 0;
IVsStatusbar statusBar = null;
appShell.DispatchOnUIThread(() => {
statusBar = appShell.GetGlobalService<IVsStatusbar>(typeof(SVsStatusbar));
statusBar.GetText(out currentStatusText);
statusBar.Progress(ref cookie, 1, "", 0, 0);
});
try {
// TODO: progress and cancellation handling
appShell.DispatchOnUIThread(() => { statusBar?.Progress(ref cookie, 1, Resources.Info_MarkdownSendingInputFile.FormatInvariant(Path.GetFileName(inputFilePath)), 0, 3); });
var rmd = await fts.SendFileAsync(inputFilePath, true, null, CancellationToken.None);
appShell.DispatchOnUIThread(() => { statusBar?.Progress(ref cookie, 1, Resources.Info_MarkdownPublishingFile.FormatInvariant(Path.GetFileName(inputFilePath)), 1, 3); });
var publishResult = await session.EvaluateAsync<ulong>($"rtvs:::rmarkdown_publish(blob_id = {rmd.Id}, output_format = {format.ToRStringLiteral()}, encoding = 'cp{codePage}')", REvaluationKind.Normal);
appShell.DispatchOnUIThread(() => { statusBar?.Progress(ref cookie, 1, Resources.Info_MarkdownGetOutputFile.FormatInvariant(Path.GetFileName(outputFilePath)), 2, 3); });
await fts.FetchFileAsync(new RBlobInfo(publishResult), outputFilePath, true, null, CancellationToken.None);
appShell.DispatchOnUIThread(() => { statusBar?.Progress(ref cookie, 1, Resources.Info_MarkdownPublishComplete.FormatInvariant(Path.GetFileName(outputFilePath)), 3, 3); });
} finally {
appShell.DispatchOnUIThread(() => {
statusBar?.Progress(ref cookie, 0, "", 0, 0);
statusBar?.SetText(currentStatusText);
});
}
}
}
private void ConnectToSession() {
if (Session == null) {
Session = Workflow.RSession;
Session.Mutated += OnSessionMutated;
Session.Disposed += OnSessionDisposed;
SessionMutated();
}
}
private void ConnectToSession() {
if (Session == null) {
Session = SessionProvider.GetOrCreate(GuidList.InteractiveWindowRSessionGuid, null);
Session.Mutated += OnSessionMutated;
Session.Disposed += OnSessionDisposed;
SessionMutated();
}
}
internal RActiveBindingInfo(IRSession session, string environmentExpression, string expression, string name, JObject json)
: this(session, environmentExpression, expression, name, (IRValueInfo)null) {
JObject bindingResultJson = json.Value<JObject>(FieldNames.ComputedValue);
if (bindingResultJson != null) {
ComputedValue = new RValueInfo(session, environmentExpression, expression, name, bindingResultJson);
}
}
public RInteractiveEvaluator(IRSession session, IRHistory history, ICoreShell coreShell, IRSettings settings) {
History = history;
Session = session;
Session.Output += SessionOnOutput;
Session.Disconnected += SessionOnDisconnected;
Session.BeforeRequest += SessionOnBeforeRequest;
_coreShell = coreShell;
_settings = settings;
}
private async Task LoadWorkspace(IRSession session, string file) {
try {
await session.LoadWorkspaceAsync(file);
} catch (RException ex) {
var message = string.Format(CultureInfo.CurrentCulture, Resources.LoadWorkspaceFailedMessageFormat, file, ex.Message);
VsAppShell.Current.ShowErrorMessage(message);
} catch (OperationCanceledException) {
}
}
internal RExecutionTracer(IRSession session) {
if (session == null) {
throw new ArgumentNullException(nameof(session));
}
Session = session;
Session.Connected += RSession_Connected;
Session.BeforeRequest += RSession_BeforeRequest;
Session.AfterRequest += RSession_AfterRequest;
}
public void Dispose() {
if (!_disposeToken.TryMarkDisposed()) {
return;
}
if (_rSession != null) {
_rSession.Mutated -= RSession_Mutated;
_rSession = null;
}
}
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();
}
internal RStackFrame(IRSession session, int index, RStackFrame callingFrame, JObject jFrame) {
Session = session;
Index = index;
CallingFrame = callingFrame;
FileName = jFrame.Value<string>("filename");
LineNumber = jFrame.Value<int?>("line_number");
Call = jFrame.Value<string>("call");
EnvironmentName = jFrame.Value<string>("env_name");
}
public async Task PublishAsync(IRSession session, IApplicationShell appShell, IFileSystem fs, string inputFilePath, string outputFilePath, PublishFormat publishFormat, Encoding encoding) {
try {
await RMarkdownRenderAsync(session, fs, inputFilePath, outputFilePath, GetDocumentTypeString(publishFormat), encoding.CodePage, appShell);
} catch (IOException ex) {
await appShell.ShowErrorMessageAsync(ex.Message);
} catch (RException ex) {
await appShell.ShowErrorMessageAsync(ex.Message);
} catch (OperationCanceledException) {
}
}
internal RStackFrame(IRSession session, int index, RStackFrame callingFrame, JObject jFrame)
{
Session = session;
Index = index;
CallingFrame = callingFrame;
FileName = jFrame.Value <string>("filename");
LineNumber = jFrame.Value <int?>("line_number");
Call = jFrame.Value <string>("call");
EnvironmentName = jFrame.Value <string>("env_name");
}
private async Task ExecuteAndCaptureOutputAsync(IRSession session, string expression, CancellationToken cancellationToken)
{
_output = new StringBuilder();
_errors = new StringBuilder();
try {
using (var inter = await session.BeginInteractionAsync(true, cancellationToken)) {
await inter.RespondAsync(expression);
}
} catch (OperationCanceledException) { }
}
public PackageIndex(IRInteractiveWorkflowProvider interactiveWorkflowProvider, ICoreShell shell, IIntellisenseRSession host, IFunctionIndex functionIndex)
{
_shell = shell;
_host = host;
_functionIndex = functionIndex;
_interactiveSession = interactiveWorkflowProvider.GetOrCreate().RSession;
_interactiveSession.PackagesInstalled += OnPackagesChanged;
_interactiveSession.PackagesRemoved += OnPackagesChanged;
}
public async Task PublishAsync(IRSession session, ICoreShell coreShell, IFileSystem fs, string inputFilePath, string outputFilePath, PublishFormat publishFormat, Encoding encoding)
{
try {
await RMarkdownRenderAsync(session, fs, inputFilePath, outputFilePath, GetDocumentTypeString(publishFormat), encoding.CodePage);
} catch (IOException ex) {
coreShell.ShowErrorMessage(ex.Message);
} catch (RException ex) {
coreShell.ShowErrorMessage(ex.Message);
} catch (OperationCanceledException) {
}
}
private async Task LoadWorkspace(IRSession session, string file) {
REvaluationResult result;
using (var evaluation = await session.BeginEvaluationAsync()) {
result = await evaluation.LoadWorkspace(file);
}
if (result.Error != null) {
var message = string.Format(CultureInfo.CurrentCulture, Resources.LoadWorkspaceFailedMessageFormat, file, result.Error);
VsAppShell.Current.ShowErrorMessage(message);
}
}
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, ICoreShell coreShell, IFileSystem fileSystem)
{
_interactiveWindow = interactiveWindow;
_session = session;
_settings = settings;
_coreShell = coreShell;
_fileSystem = fileSystem;
var workflowProvider = _coreShell.GetService <IRInteractiveWorkflowProvider>();
_workflow = workflowProvider.GetOrCreate();
}
private async Task ExportToImageAsync(IRSession session, string format, string filePath, int widthInPixels, int heightInPixels, int resolution)
{
string script = String.Format(@"
device_id <- rtvs:::graphics.ide.getactivedeviceid()
rtvs:::export_to_image(device_id, rtvs:::graphics.ide.getactiveplotid(device_id), {0}, {1}, {2}, {3})
", format, widthInPixels, heightInPixels, resolution);
var blobid = await session.EvaluateAsync <ulong>(script, REvaluationKind.Normal);
using (DataTransferSession dts = new DataTransferSession(session, new FileSystem())) {
await dts.FetchFileAsync(new RBlobInfo(blobid), filePath, true, null, CancellationToken.None);
}
}
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 async Task InitializeAsync(IRSessionCallback clientApp = null)
{
_clientApp = clientApp ?? _clientApp;
Session = SessionProvider.GetOrCreate(SessionNames.InteractiveWindow);
if (Session.IsHostRunning)
{
await Session.StopHostAsync();
}
await Session.StartHostAsync(new RHostStartupInfo(), _clientApp ?? new RHostClientTestApp(), 50000);
}
private async Task LoadWorkspace(IRSession session, string file)
{
using (var evaluation = await session.BeginEvaluationAsync()) {
try {
await evaluation.LoadWorkspaceAsync(file);
} catch (RException ex) {
var message = string.Format(CultureInfo.CurrentCulture, Resources.LoadWorkspaceFailedMessageFormat, file, ex.Message);
VsAppShell.Current.ShowErrorMessage(message);
} catch (OperationCanceledException) {
}
}
}
public PlotManagerWindowPane(IRPlotManager plotManager, IRSession session, IRSettings settings, ICoreShell coreShell)
{
_plotManager = plotManager;
_session = session;
_settings = settings;
_coreShell = coreShell;
// this value matches with icmdShowPlotWindow's Icon in VSCT file
BitmapImageMoniker = KnownMonikers.LineChart;
Caption = Resources.PlotWindowCaption;
ToolBar = new CommandID(RGuidList.RCmdSetGuid, RPackageCommandId.plotWindowToolBarId);
}
internal RExecutionTracer(IRSession session)
{
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
Session = session;
Session.Connected += RSession_Connected;
Session.BeforeRequest += RSession_BeforeRequest;
Session.AfterRequest += RSession_AfterRequest;
}
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 = _coreShell.GetService <IRInteractiveWorkflowVisualProvider>().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;
}
_workflow.RSessions.BeforeDisposed += BeforeRSessionsDisposed;
// 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.FileSystem().FileExists(rdataPath) && await GetLoadDefaultWorkspace(rdataPath);
if (loadDefaultWorkspace)
{
await _session.LoadWorkspaceAsync(rdataPath);
}
await _session.SetWorkingDirectoryAsync(_projectDirectory);
_settings.WorkingDirectory = _projectDirectory;
}
_history.TryLoadFromFile(Path.Combine(_projectDirectory, DefaultRHistoryName));
CheckSurveyNews();
}
public static async Task <string> GetRUserDirectoryAsync(this IRSession session, CancellationToken cancellationToken = default(CancellationToken))
{
if (session.IsHostRunning)
{
await TaskUtilities.SwitchToBackgroundThread();
try {
return(await RSessionEvaluationCommands.GetRUserDirectoryAsync(session, cancellationToken));
} catch (RException) {
} catch (OperationCanceledException) { }
}
return(null);
}
public void Dispose()
{
if (!_disposeToken.TryMarkDisposed())
{
return;
}
if (_rSession != null)
{
_rSession.Mutated -= RSession_Mutated;
_rSession = null;
}
}
private RHostSession(IRSession session)
{
_session = session;
_session.Connected += OnSessionConnected;
_session.Disconnected += OnSessionDisconnected;
_session.Output += OnSessionOutput;
_disposableBag = DisposableBag.Create <RHostSession>()
.Add(() => _session.Output -= OnSessionOutput)
.Add(() => _session.Connected -= OnSessionConnected)
.Add(() => _session.Disconnected -= OnSessionDisconnected);
}
private async Task <REvaluationResult> EvaluateAsyncAsync(string expression)
{
await TaskUtilities.SwitchToBackgroundThread();
IRSession rSession = GetRSession();
REvaluationResult result;
using (var evaluator = await rSession.BeginEvaluationAsync()) {
result = await evaluator.EvaluateAsync(expression, REvaluationKind.Mutating);
}
return(result);
}
public RHostScript(IRSessionProvider sessionProvider, IRHostClientApp clientApp = null) {
SessionProvider = sessionProvider;
Session = SessionProvider.GetOrCreate(GuidList.InteractiveWindowRSessionGuid, clientApp ?? new RHostClientTestApp());
Session.IsHostRunning.Should().BeFalse();
Session.StartHostAsync(new RHostStartupInfo {
Name = "RHostScript",
RBasePath = RToolsSettings.Current.RBasePath,
RHostCommandLineArguments = RToolsSettings.Current.RCommandLineArguments,
CranMirrorName = RToolsSettings.Current.CranMirror
}, 50000).Wait();
}
private async Task <REvaluationResult> CallIconvListAsync()
{
await TaskUtilities.SwitchToBackgroundThread();
IRSession rSession = GetRSession();
REvaluationResult result;
using (var evaluator = await rSession.BeginEvaluationAsync()) {
result = await evaluator.EvaluateAsync("as.list(iconvlist())", REvaluationKind.Json);
}
return(result);
}
public RInteractiveEvaluator(IRSession session, IRHistory history, IConnectionManager connections, ICoreShell coreShell, IRSettings settings)
{
History = history;
Session = session;
Session.Output += SessionOnOutput;
Session.Disconnected += SessionOnDisconnected;
Session.BeforeRequest += SessionOnBeforeRequest;
Session.AfterRequest += SessionOnAfterRequest;
_connections = connections;
_coreShell = coreShell;
_settings = settings;
_evaluatorRequest = new CountdownDisposable();
}
private async Task <IRSession> StartSessionAsync(CancellationToken ct)
{
_session = _session ?? _workflow.RSessions.GetOrCreate("VSCR_Output");
if (!_session.IsHostRunning)
{
await _session.EnsureHostStartedAsync(new RHostStartupInfo(isInteractive : true), _sessionCallback, 3000, ct);
await _session.SetVsGraphicsDeviceAsync();
}
return(_session);
}
public static async Task <string> GetRWorkingDirectoryAsync(this IRSession session)
{
if (session.IsHostRunning)
{
await TaskUtilities.SwitchToBackgroundThread();
try {
return(await session.GetWorkingDirectoryAsync());
} catch (RException) {
} catch (OperationCanceledException) {
}
}
return(null);
}
internal RActiveBindingInfo(IRSession session, string environmentExpression, string expression, string name, JObject json)
: base(session, environmentExpression, expression, name)
{
JObject bindingResultJson = json.Value <JObject>(FieldNames.ComputedValue);
if (bindingResultJson == null)
{
ComputedValue = null;
}
else
{
ComputedValue = new RValueInfo(session, environmentExpression, expression, name, bindingResultJson);
}
}
public RInteractiveEvaluator(IRSessionProvider sessionProvider, IRSession session, IRHistory history, IConnectionManager connections, ICoreShell coreShell, IRSettings settings, IConsole console) {
History = history;
Session = session;
Session.Output += SessionOnOutput;
Session.Disconnected += SessionOnDisconnected;
Session.BeforeRequest += SessionOnBeforeRequest;
Session.AfterRequest += SessionOnAfterRequest;
_sessionProvider = sessionProvider;
_connections = connections;
_coreShell = coreShell;
_settings = settings;
_console = console;
_evaluatorRequest = new CountdownDisposable();
}
public VariableGridHost(IServiceContainer services)
{
InitializeComponent();
_services = services;
_rSession = _services.GetService <IRInteractiveWorkflowProvider>().GetOrCreate().RSession;
_rSession.Mutated += RSession_Mutated;
_disposableBag
.Add(() => _rSession.Mutated -= RSession_Mutated)
.Add(DeleteCachedVariable);
FocusManager.SetFocusedElement(this, VariableGrid);
}
public RHostScript(IRSessionProvider sessionProvider, IRHostClientApp clientApp = null)
{
SessionProvider = sessionProvider;
Session = SessionProvider.GetOrCreate(GuidList.InteractiveWindowRSessionGuid, clientApp ?? new RHostClientTestApp());
Session.IsHostRunning.Should().BeFalse();
Session.StartHostAsync(new RHostStartupInfo {
Name = "RHostScript",
RBasePath = RToolsSettings.Current.RBasePath,
RHostCommandLineArguments = RToolsSettings.Current.RCommandLineArguments,
CranMirrorName = RToolsSettings.Current.CranMirror
}, 50000).Wait();
}
public static async Task <string> GetRUserDirectoryAsync(this IRSession session)
{
if (session.IsHostRunning)
{
await TaskUtilities.SwitchToBackgroundThread();
try {
using (var evaluation = await session.BeginEvaluationAsync()) {
return(await evaluation.GetRUserDirectory());
}
} catch (OperationCanceledException) { }
}
return(null);
}
public HelpWindowVisualComponent() {
_session = VsAppShell.Current.ExportProvider.GetExportedValue<IRSessionProvider>().GetInteractiveWindowRSession();
_session.Disconnected += OnRSessionDisconnected;
_windowContentControl = new ContentControl();
Control = _windowContentControl;
var c = new Controller();
c.AddCommandSet(GetCommands());
Controller = c;
CreateBrowser();
VSColorTheme.ThemeChanged += OnColorThemeChanged;
}
private async Task LoadWorkspace(IRSession session, string file)
{
REvaluationResult result;
using (var evaluation = await session.BeginEvaluationAsync()) {
result = await evaluation.LoadWorkspace(file);
}
if (result.Error != null)
{
var message = string.Format(CultureInfo.CurrentCulture, Resources.LoadWorkspaceFailedMessageFormat, file, result.Error);
VsAppShell.Current.ShowErrorMessage(message);
}
}
private async Task UpdateList()
{
if (_updating)
{
return;
}
try {
_updating = true;
// May be null in tests
IRSession session = Workflow.RSession;
if (session.IsHostRunning)
{
var stackFrames = await session.TracebackAsync();
var globalStackFrame = stackFrames.FirstOrDefault(s => s.IsGlobal);
if (globalStackFrame != null)
{
const REvaluationResultProperties properties =
ExpressionProperty |
AccessorKindProperty |
TypeNameProperty |
ClassesProperty |
LengthProperty |
SlotCountProperty |
AttributeCountProperty |
DimProperty |
FlagsProperty;
var evaluation = await globalStackFrame.TryEvaluateAndDescribeAsync("base::environment()", "Global Environment", properties, RValueRepresentations.Str());
var e = new RSessionDataObject(evaluation, _coreShell.Services); // root level doesn't truncate children and return every variables
_topLevelVariables.Clear();
var children = await e.GetChildrenAsync();
if (children != null)
{
foreach (var x in children)
{
_topLevelVariables[x.Name] = x; // TODO: BUGBUG: this doesn't address removed variables
}
}
}
}
} catch (REvaluationException) { } finally {
_updating = false;
}
}
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();
}
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 async Task InitializeAsync(IRSessionCallback clientApp = null) {
_clientApp = clientApp ?? _clientApp;
Session = SessionProvider.GetOrCreate(SessionGuids.InteractiveWindowRSessionGuid);
if (Session.IsHostRunning) {
await Session.StopHostAsync();
}
await Session.StartHostAsync(new RHostStartupInfo {
Name = "RHostScript",
CranMirrorName = RToolsSettings.Current.CranMirror,
CodePage = RToolsSettings.Current.RCodePage,
RHostCommandLineArguments = RToolsSettings.Current.LastActiveConnection.RCommandLineArguments
}, _clientApp ?? new RHostClientTestApp(), 50000);
}
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 HelpWindowVisualComponent()
{
_session = VsAppShell.Current.ExportProvider.GetExportedValue <IRSessionProvider>().GetInteractiveWindowRSession();
_session.Disconnected += OnRSessionDisconnected;
_windowContentControl = new ContentControl();
Control = _windowContentControl;
var c = new Controller();
c.AddCommandSet(GetCommands());
Controller = c;
CreateBrowser();
VSColorTheme.ThemeChanged += OnColorThemeChanged;
}
public static async Task<IGridData<string>> GetGridDataAsync(IRSession rSession, string expression, GridRange? gridRange, ISortOrder sortOrder = null) {
await TaskUtilities.SwitchToBackgroundThread();
string rows = gridRange?.Rows.ToRString();
string columns = gridRange?.Columns.ToRString();
string rowSelector = (sortOrder != null && !sortOrder.IsEmpty) ? sortOrder.GetRowSelector() : "";
string expr = Invariant($"rtvs:::grid_data({expression}, {rows}, {columns}, {rowSelector})");
try {
return await rSession.EvaluateAsync<GridData>(expr, REvaluationKind.Normal);
} catch (RException ex) {
var message = Invariant($"Grid data evaluation failed:{Environment.NewLine}{ex.Message}");
await VsAppShell.Current.Services.Log.WriteAsync(LogVerbosity.Normal, MessageCategory.Error, message);
return null;
}
}
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.PackagesInstalled += OnPackagesChanged;
_interactiveSession.PackagesRemoved += OnPackagesChanged;
_workflow.RSessions.BrokerStateChanged += OnBrokerStateChanged;
if (_workflow.RSession.IsHostRunning) {
BuildIndexAsync().DoNotWait();
}
}
public async Task<DebugSession> GetDebugSessionAsync(IRSession session, CancellationToken cancellationToken = default(CancellationToken)) {
DebugSession debugSession;
await _sem.WaitAsync(cancellationToken).ConfigureAwait(false);
try {
if (!_debugSessions.TryGetValue(session, out debugSession)) {
debugSession = new DebugSession(session);
await debugSession.InitializeAsync(cancellationToken).ConfigureAwait(false);
_debugSessions.Add(session, debugSession);
}
session.Disposed += Session_Disposed;
} finally {
_sem.Release();
}
return debugSession;
}
