public SwitchRepositoryCommand(
IGitLocalRepositoryService localRepositoryService,
IWorkspaceService workspaceService)
{
_localRepositoryService = localRepositoryService;
_workspaceService = workspaceService;
}
public OpenCommand(Storage storage, IWorkspaceService workspace)
{
_storage = storage;
_worksapce = workspace;
Image = Resources.Folder_48x48;
DisplayStyle = ToolStripItemDisplayStyle.ImageAndText;
ToolTipText = @"Ctrl + O";
ShortcutKeys = Keys.Control | Keys.O;
EventAggregator.Instance.Subscribe <StopAppEvent>(e => Enabled = true);
EventAggregator.Instance.Subscribe <PlayAppEvent>(e => Enabled = false);
EventAggregator.Instance.Subscribe <StorageAppEvent>(e =>
{
if (e.ChangingType == FileChangingType.Loading || e.ChangingType == FileChangingType.Saving)
{
Enabled = false;
}
if (e.ChangingType == FileChangingType.LoadComplete || e.ChangingType == FileChangingType.SaveComplete)
{
Enabled = true;
}
});
_openView = new OpenFileView();
}
public TimerPageViewModel(ITimeEntryService timeEntryService, IAuthService authService,
IProjectService projectService, IWorkspaceService workspaceService)
{
_timeEntryService = timeEntryService;
_authService = authService;
_projectService = projectService;
_workspaceService = workspaceService;
StartTimerCommand = new DelegateCommand(async() =>
{
NewEntry.Start = DateTime.Now;
Current = await _timeEntryService.StartCurrentTimer(_newEntry);
});
StopTimerCommand = new DelegateCommand(async() =>
{
await _timeEntryService.StopCurrentTimer();
LoadCurrentTimeEntry();
});
RefreshCommand = new DelegateCommand(OnNavigatedTo);
PropertyChanged += (sender, args) =>
{
switch (args.PropertyName)
{
case nameof(Workspace):
LoadProjects(Task.FromResult(Workspace));
break;
}
};
}
public CodeEditorViewModel(ICodeEditorView view, IShellService shellService, IWorkspaceService workspaceService, CodeEditorService codeEditorService)
: base(view)
{
ShellService = shellService;
WorkspaceService = workspaceService;
CodeEditorService = codeEditorService;
}
public HandleFileDropCommand(BaseViewModel viewModel, Workspace workspace, IWorkspaceService wsService, IResourceDirectoryService rdService)
{
_viewModel = viewModel;
_workspaceService = wsService;
_resourceDirectoryService = rdService;
_workspace = workspace;
}
public EvaluationService(
IWorkspaceService workspace,
IEvaluationEnvironment evaluationEnvironment)
{
this.workspace = workspace
?? throw new ArgumentNullException(nameof(workspace));
this.evaluationEnvironment = evaluationEnvironment;
}
public SelectTool(IServiceManager services) : base(services)
{
tools = services.GetService <IToolService> ();
workspace = services.GetService <IWorkspaceService> ();
CreateHandler();
workspace.SelectionChanged += AfterSelectionChange;
}
///<inheritdoc/>
public ConfigurationService(
IEnvironmentService environmentService,
IWorkspaceService workspaceService,
ITraceService traceService)
{
this._environmentService = environmentService;
this._workspaceService = workspaceService;
this._traceService = traceService;
}
public ServerAuditService(
IWorkspaceService workspaceService,
IWorkspaceAuditServiceFactory workspaceAuditServiceFactory,
ILogger logger)
{
this.workspaceService = workspaceService;
this.workspaceAuditServiceFactory = workspaceAuditServiceFactory;
this.logger = logger.WithClassName();
}
public OpenExportDialogCommand(
WorkspaceViewModel viewModel,
IWorkspaceService workspaceService)
{
_viewModel = viewModel;
_workspaceService = workspaceService;
worker.DoWork += worker_DoWork;
worker.RunWorkerCompleted += worker_RunWorkerCompleted;
}
public Task <WorkspaceFile> GetFileAsync(
GetFileInput input,
[Service] IWorkspaceService workspaceService,
CancellationToken cancellationToken)
{
return(workspaceService.GetFileAsync(new GetFileRequest(input.FileName)
{
Converter = input.Converter
}, cancellationToken));
}
public async Task <IEnumerable <WorkRoot> > GetWorkRootsAsync(
CancellationToken cancellationToken)
{
IUserSettingsManager settingsManager = _app.GetRequiredService <IUserSettingsManager>();
UserSettings?settings = await settingsManager.GetAsync(cancellationToken);
if (settings.WorkRoots.Count() == 0)
{
_console.WriteLine("No work roots configured!");
_console.WriteLine("You can configure you work roots in the UI or directly in:");
_console.WriteLine($"{SettingsStore.UserSettingsFilePath}.");
var options = new List <string>
{
"Open UI",
"Open User settings in code",
$"Add {Directory.GetCurrentDirectory()} as work root",
"Cancel"
};
var index = _console.ChooseFromList(options);
switch (index)
{
case 0:
IWebServer?webServer = _app.GetRequiredService <IWebServer>();
var url = await webServer.StartAsync(3003);
ProcessHelpers.OpenBrowser(url + "/settings");
break;
case 1:
//first ensure file exists
if (!File.Exists(SettingsStore.UserSettingsFilePath))
{
await AddCurrentWorkroot(settingsManager, cancellationToken);
}
IWorkspaceService workspaceService = _app.GetRequiredService <IWorkspaceService>();
await workspaceService.OpenFileInCode(SettingsStore.UserSettingsFilePath);
break;
case 2:
await AddCurrentWorkroot(settingsManager, cancellationToken);
break;
default:
break;
}
}
return(settings.WorkRoots);
}
public DesignService(IWorkspaceService workspaceService, CompilerService compilerService,Report report)
{
this.WorkspaceService = workspaceService;
this.compilerService = compilerService;
controlViewFactory = new ControlViewFactory (this);
PixbufRepository = new PixbufRepository (){ Report = report};
IsDesign = true;
Zoom = 1;
Render = true;
Report = report;
}
public Toggl(string key)
{
ApiService = new ApiService(key);
Client = new ClientService(ApiService);
Project = new ProjectService(ApiService);
Tag = new TagService(ApiService);
Task = new TaskService(ApiService);
TimeEntry = new TimeEntryService(ApiService);
User = new UserService(ApiService);
Workspace = new WorkspaceService(ApiService);
}
public Toggl(string key)
{
ApiService = new ApiService(key);
Client = new ClientService(ApiService);
Project = new ProjectService(ApiService);
Tag = new TagService(ApiService);
Task = new TaskService(ApiService);
TimeEntry = new TimeEntryService(ApiService);
User = new UserService(ApiService);
Workspace = new WorkspaceService(ApiService);
}
public ServerAuditReporter(
IUserExperienceReportRepository userExperienceReportRepository,
IWorkspaceService workspaceService,
IWorkspaceAuditServiceFactory workspaceAuditServiceFactory,
ISearchAuditBatchRepository searchAuditBatchRepository)
{
this.userExperienceReportRepository = userExperienceReportRepository;
this.workspaceService = workspaceService;
this.workspaceAuditServiceFactory = workspaceAuditServiceFactory;
this.searchAuditBatchRepository = searchAuditBatchRepository;
}
/// <summary>
/// Inserts a new cell into the workspace and sets an initial buffer.
/// The workspace implementation may not need both <see cref="CodeCellId"/>
/// parameters, but they will always be provided, should they exist, by
/// <see cref="EvaluationService"/>.
/// </summary>
/// <param name="initialBuffer">The initial the text content for the cell.</param>
/// <param name="previousCellId">Insert the new cell immediately after this cell.</param>
/// <param name="nextCellId">Insert the new cell immediately before this cell.</param>
/// <returns>
/// Returns the <see cref="CodeCellId"/> of the new cell. The ID must be
/// unique, opaque, and persistent across the cell's lifecycle.
/// </returns>
public static CodeCellId InsertCell(
this IWorkspaceService workspaceService,
string initialBuffer,
CodeCellId previousCellId,
CodeCellId nextCellId)
{
var codeCellId = workspaceService.InsertCell(previousCellId, nextCellId);
workspaceService.SetCellBuffer(codeCellId, initialBuffer);
return(codeCellId);
}
public UserController(
IHttpContextAccessor httpContextAccessor,
IUserService userService,
IWorkspaceService workspaceService,
IMapper mapper)
{
_workspaceService = workspaceService;
_httpContextAccessor = httpContextAccessor;
_userService = userService;
_user = _userService.GetApplicationUser(_httpContextAccessor.HttpContext.GetUserId());
_mapper = mapper;
}
public AuditServerBatcher(
IAuditWorkspaceBatcher auditWorkspaceBatcher,
IWorkspaceService workspaceService,
ISearchAuditBatchRepository searchAuditBatchRepository,
IMetricDataService metricDataService,
ILogger logger)
{
this.auditWorkspaceBatcher = auditWorkspaceBatcher;
this.workspaceService = workspaceService;
this.searchAuditBatchRepository = searchAuditBatchRepository;
this.metricDataService = metricDataService;
this.logger = logger.WithClassName().WithCategory(Names.LogCategory.Audit);
}
public DesignService(IWorkspaceService workspaceService,ReportRenderer renderer,PixbufRepository pixbufRepository,CompilerService compilerService, Report report)
{
this.PixbufRepository = pixbufRepository;
this.WorkspaceService = workspaceService;
this.Compiler = compilerService;
this.renderer = renderer;
controlViewFactory = new ControlViewFactory (renderer);
IsDesign = true;
Report = report;
Zoom = 1;
Render = true;
IsDirty = true;
}
public ViewBridge(IWorkspaceService workspaceService, IViewService viewService, IMessageDisplayService messageDisplayService)
{
this.workspaceService = workspaceService;
this.viewService = viewService;
this.messageDisplayService = messageDisplayService;
this.viewService.ViewOpened += new ViewEventHandler(this.ViewService_ViewOpened);
this.viewService.ViewClosed += new ViewEventHandler(this.ViewService_ViewClosed);
this.viewService.ActiveViewChanged += new ViewChangedEventHandler(this.ViewService_ActiveViewChanged);
this.workspaceService.ActiveWorkspaceChanging += new CancelEventHandler(this.WorkspaceService_ActiveWorkspaceChanging);
this.workspaceService.ActiveWorkspaceChangingCanceled += new EventHandler(this.WorkspaceService_ActiveWorkspaceChangingCanceled);
this.workspaceService.ActiveWorkspaceChanged += new EventHandler(this.WorkspaceService_ActiveWorkspaceChanged);
DockOperations.DockPositionChanging += new EventHandler <DockEventArgs>(this.DockOperations_DockPositionChanging);
DockOperations.DockPositionChanged += new EventHandler <DockEventArgs>(this.DockOperations_DockPositionChanged);
}
public DesignService(IWorkspaceService workspaceService, CompilerService compilerService, Report report)
{
this.WorkspaceService = workspaceService;
this.compilerService = compilerService;
controlViewFactory = new ControlViewFactory(this);
PixbufRepository = new PixbufRepository()
{
Report = report
};
IsDesign = true;
Zoom = 1;
Render = true;
Report = report;
}
public CommandLineService(
IMigrationServiceFactory migrationServiceFactory,
IDataServiceFactory dataServiceFactory,
IWorkspaceService workspaceService,
IEnvironmentService environmentService,
ITraceService traceService,
IConfigurationService configurationService)
{
this._workspaceService = workspaceService;
this._environmentService = environmentService;
this._traceService = traceService;
this._configurationService = configurationService;
this._migrationServiceFactory = migrationServiceFactory;
this._dataServiceFactory = dataServiceFactory;
}
public OutlookBarViewModel(
IWorkspaceService workspaceService,
IEventAggregator eventAggregator,
ICachingService cachingService,
IStatusBarMessageQueue statusBarMessageQueue,
IOutlookBarItemViewModelFactory modelFactory,
ISearchViewModel searchViewModel)
{
_workspaceService = workspaceService;
_eventAggregator = eventAggregator;
_cachingService = cachingService;
_statusBarMessageQueue = statusBarMessageQueue;
_modelFactory = modelFactory;
_searchViewModel = searchViewModel;
Initialize();
}
#pragma warning restore 0414
public HoverProvider(
IWorkspaceService workspace,
ScriptContext context,
Func <string, CodeCellId> monacoModelIdToCodeCellIdMapper)
{
this.workspace = workspace
?? throw new ArgumentNullException(nameof(workspace));
this.context = context
?? throw new ArgumentNullException(nameof(context));
this.monacoModelIdToCodeCellIdMapper = monacoModelIdToCodeCellIdMapper
?? throw new ArgumentNullException(nameof(monacoModelIdToCodeCellIdMapper));
providerTicket = context.GlobalObject.xiexports.monaco.RegisterWorkbookHoverProvider(
"csharp",
(ScriptFunc)ProvideHover);
}
public async Task ShowQuickActions(string path)
{
IWorkspaceService workspaceService = _app.GetRequiredService <IWorkspaceService>();
var dir = new DirectoryInfo(path);
QuickAction[] quickActions =
workspaceService.GetQuickActions(path).ToArray();
Console.WriteLine($"Quick actions: {dir.Name}");
Console.WriteLine($"------------------------------------");
var actionIndex = _console.ChooseFromList(
quickActions.Select(x => x.ToString()));
QuickAction?action = quickActions[actionIndex];
switch (action.Type)
{
case QuickActionTypes.OpenVisualStudioSolution:
ProcessHelpers.Open(action.Value);
break;
case QuickActionTypes.OpenDirectoryInExplorer:
await workspaceService.OpenInExplorer(action.Value);
break;
case QuickActionTypes.OpenDirectoryInCode:
await workspaceService.OpenInCode(action.Value);
break;
case QuickActionTypes.OpenDirectoryInTerminal:
await workspaceService.OpenInTerminal(action.Value);
break;
case QuickActionTypes.RunSuperBoost:
await workspaceService.RunSuperBoostAsync(action.Title, path);
break;
}
}
/// <inheritdoc />
public MigrationService(
IWorkspaceService workspaceService,
IDataService dataService,
IBulkImportService bulkImportService,
IMetadataService metadataService,
ITokenReplacementService tokenReplacementService,
IDirectoryService directoryService,
IFileService fileService,
ITraceService traceService,
IConfigurationService configurationService)
{
this._workspaceService = workspaceService;
this._dataService = dataService;
this._bulkImportService = bulkImportService;
this._tokenReplacementService = tokenReplacementService;
this._directoryService = directoryService;
this._fileService = fileService;
this._traceService = traceService;
this._configurationService = configurationService;
this._metadataService = metadataService;
}
protected BaseTool(IServiceManager services)
{
Resources = services.GetService <IResourceService> ();
Settings = services.GetService <ISettingsService> ();
tools = services.GetService <IToolService> ();
workspace = services.GetService <IWorkspaceService> ();
CurrentCursor = DefaultCursor;
// Update cursor when active document changes
workspace.ActiveDocumentChanged += (_, _) => {
if (tools.CurrentTool == this)
{
SetCursor(DefaultCursor);
}
};
// Give tools a chance to save their settings on application quit
Settings.SaveSettingsBeforeQuit += (_, _)
=> OnSaveSettings(Settings);
}
public IWorkbookSaveOperation CreateSaveOperation(
IWorkspaceService workspace)
{
var dependencies = new WorkbookDependencyCollector().Visit(this);
var onlyPage = dependencies.SingleOrDefault();
var workspaceDependencies = workspace
?.GetExternalDependencies()
?.Select(dependency => dependency.Location);
if (workspaceDependencies != null)
{
onlyPage.Value.AddRange(workspaceDependencies);
}
return(new SaveOperation {
Destination = logicalPath,
AllDependencies = dependencies,
OnlyPage = onlyPage.Key,
OnlyPageHasDependencies = onlyPage.Key != null && onlyPage.Value.Count > 0,
Options = SaveOptions
});
}
public AuditBatchProcessor(
ISearchAuditBatchRepository searchAuditBatchRepository,
IHourRepository hourRepository,
ISearchAnalysisService searchAnalysisService,
IAuditBatchAnalyzer auditBatchAnalyzer,
IWorkspaceAuditServiceFactory workspaceAuditServiceFactory,
IWorkspaceAuditReporter workspaceAuditReporter,
IServerRepository serverRepository,
IAuditParsingService auditParsingService,
IWorkspaceService workspaceService,
ILogger logger)
{
this.searchAuditBatchRepository = searchAuditBatchRepository;
this.hourRepository = hourRepository;
this.searchAnalysisService = searchAnalysisService;
this.auditBatchAnalyzer = auditBatchAnalyzer;
this.workspaceAuditServiceFactory = workspaceAuditServiceFactory;
this.workspaceAuditReporter = workspaceAuditReporter;
this.serverRepository = serverRepository;
this.auditParsingService = auditParsingService;
this.workspaceService = workspaceService;
this.logger = logger.WithClassName().WithCategory(Names.LogCategory.Audit);
}
public SaveCommand(IWorkspaceService workspaceService)
{
this._workspaceService = workspaceService;
Command = new DelegateCommand(() => this._workspaceService.SaveCurrentEditor());
}
public OpenTexture2DCommand(IEventAggregator eventAggregator, IWorkspaceService workSpaceService)
{
this._workSpaceService = workSpaceService;
this.Command = new DelegateCommand<Object>(CreateNewTexture2DExecute, CanCreateNewTexture2D);
}
internal WorkspaceService(IWorkspaceService service, string org) : base(org)
{
Service = service;
}
public OpenLevelCommand(IWorkspaceService workSpaceService)
{
this._workSpaceService = workSpaceService;
this.Command = new DelegateCommand<Object>(x => _workSpaceService.OpenEditor(ViewNames.LevelEditor, (Asset)x));
}
public WorkspaceServiceInternal(IWorkspaceService workspace)
{
this.workspaceService = workspace;
}
public PropertySearchGroupTreeViewModel(IEventAggregator eventAggregator, IWorkspaceService workspaceService) :
base(eventAggregator)
{
_workspaceService = workspaceService;
Initialize();
}
public OpenTerrainTileDefinitionCommand(IWorkspaceService workSpaceService)
{
this._workSpaceService = workSpaceService;
this.Command = new DelegateCommand<Object>(x => _workSpaceService.OpenEditor(ViewNames.TerrainTileDefinitionEditor, (Asset)x));
}
