public Encouragements(SVsServiceProvider vsServiceProvider) { var shellSettingsManager = new ShellSettingsManager(vsServiceProvider); writableSettingsStore = shellSettingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); LoadSettings(); }
/// <summary> /// Initializes the settings /// </summary> /// <param name="configurationSettingsStore">The settings store</param> public Settings(WritableSettingsStore configurationSettingsStore) { _store = configurationSettingsStore; _showLinesColored = _store.GetBoolean(SETTINGS_PATH, SettingNames.ShowLinesColored, false); _showCoverageGlyphs = _store.GetBoolean(SETTINGS_PATH, SettingNames.ShowCoverageGlyphs, true); }
private SavedOptions() { var shellSettingsManager = new ShellSettingsManager(ServiceProvider.GlobalProvider); _store = shellSettingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); LoadOptions(); }
public SettingsStore(WritableSettingsStore store, string root) { Guard.ArgumentNotNull(store, nameof(store)); Guard.ArgumentNotNull(root, nameof(root)); Guard.ArgumentNotEmptyString(root, nameof(root)); this.store = store; this.root = root; }
public WhereAmISettings(SVsServiceProvider vsServiceProvider) : this() { var shellSettingsManager = new ShellSettingsManager(vsServiceProvider); writableSettingsStore = shellSettingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); LoadSettings(); }
protected SettingStore() { SettingsManager settingsManager = new ShellSettingsManager(ServiceProvider.GlobalProvider); userSettingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); if (!userSettingsStore.CollectionExists(CollectionPath)) { userSettingsStore.CreateCollection(CollectionPath); } }
public void Initialize() { var shellManager = new ShellSettingsManager(Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider); this.settingsStore = shellManager.GetWritableSettingsStore(SettingsScope.UserSettings); var collection = SettingsManager.GetSettingsCollectionName(typeof(Foo)); if (this.settingsStore.CollectionExists(collection)) this.settingsStore.DeleteCollection(collection); }
internal VersionProvider(IServiceProvider serviceProvider) { var settingsManager = new ShellSettingsManager(serviceProvider); _settingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); if (!_settingsStore.CollectionExists(CollectionName)) _settingsStore.CreateCollection(CollectionName); if (_settingsStore.PropertyExists(CollectionName, OldVersionPropertyName)) _settingsStore.DeleteProperty(CollectionName, OldVersionPropertyName); }
public Settings(SVsServiceProvider serviceProvider) { _vsSettingsProvider = GetWritableSettingsStore(serviceProvider); if (!_vsSettingsProvider.CollectionExists(collectionKey)) { _vsSettingsProvider.CreateCollection(collectionKey); } _mergeOperationDefaultValues = new[] { mergeOperationDefaultLast, mergeOperationDefaultMerge, mergeOperationDefaultMergeCheckin }; BranchNameMatches = BranchNameMatches ?? new BranchNameMatch[0]; }
public static void Initialize(IServiceProvider provider) { _manager = new ShellSettingsManager(provider); _readStore = _manager.GetReadOnlySettingsStore(SettingsScope.UserSettings); _writeStore = _manager.GetWritableSettingsStore(SettingsScope.UserSettings); if (!_writeStore.CollectionExists(_name)) { _writeStore.CreateCollection(_name); string defaults = string.Join(_separator, PreEnabledExtensions.List); _writeStore.SetString(_name, _identifierKey, defaults); } }
internal VimApplicationSettings(VisualStudioVersion visualStudioVersion, WritableSettingsStore settingsStore, IProtectedOperations protectedOperations) { _settingsStore = settingsStore; _protectedOperations = protectedOperations; // Legacy settings were only supported on Visual Studio 2010 and 2012. For any other version there is no // need to modify the legacy settings switch (visualStudioVersion) { case VisualStudioVersion.Vs2010: case VisualStudioVersion.Vs2012: _legacySettingsSupported = true; break; default: // Intentionally do nothing break; } }
internal /* for testing purposes */ IntegrationSettings(IServiceProvider serviceProvider, SettingsManager settingsManager) { if (serviceProvider == null) { throw new ArgumentNullException(nameof(serviceProvider)); } if (settingsManager == null) { throw new ArgumentNullException(nameof(settingsManager)); } this.store = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); Debug.Assert(this.store != null, "Could not get WritableSettingsStore, no settings will be persisted!"); if (this.store != null) { this.Initialize(); } }
public void Initialize() { userSettingsStore = _hostEnviromentConnection.SettingsManager .GetWritableSettingsStore(SettingsScope.UserSettings); if (!userSettingsStore.CollectionExists(CollectionName)) { userSettingsStore.CreateCollection(CollectionName); } // if (!userSettingsStore.PropertyExists(CollectionName, "MutationResultsFilePath")) // { // this["MutationResultsFilePath"] = @"C:\results"; // } }
protected override void Initialize() { base.Initialize(); OleMenuCommandService menuCommandService = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (menuCommandService != null) { // This is the drop down combo box itself CommandID comboBoxCommandID = new DebugCommandLineCommandID(DebugCommandLineCommand.DebugCommandLineCombo); OleMenuCommand comboBoxCommand = new OleMenuCommand(HandleInvokeCombo, HandleChangeCombo, HandleBeforeQueryStatusCombo, comboBoxCommandID); menuCommandService.AddCommand(comboBoxCommand); // This is the special command to get the list of drop down items CommandID comboBoxGetListCommandID = new DebugCommandLineCommandID(DebugCommandLineCommand.DebugCommandLineComboGetList); OleMenuCommand comboBoxGetListCommand = new OleMenuCommand(HandleInvokeComboGetList, comboBoxGetListCommandID); menuCommandService.AddCommand(comboBoxGetListCommand); } var shellSettingsManager = new ShellSettingsManager(this); SettingsStore = shellSettingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); LoadSettings(); }
/// <summary> /// Saves the properties to the registry asyncronously. /// </summary> public virtual async Task SaveAsync() { ShellSettingsManager manager = await _settingsManager.GetValueAsync(); WritableSettingsStore settingsStore = manager.GetWritableSettingsStore(SettingsScope.UserSettings); if (!settingsStore.CollectionExists(CollectionName)) { settingsStore.CreateCollection(CollectionName); } foreach (PropertyInfo property in GetOptionProperties()) { string output = SerializeValue(property.GetValue(this)); settingsStore.SetString(CollectionName, property.Name, output); } T liveModel = await GetLiveInstanceAsync(); if (this != liveModel) { await liveModel.LoadAsync(); } }
/// <summary> /// Saves the settings to the settings store /// </summary> /// <param name="indentSize">The indent size specifiyng the number of spaces for indentation detection</param> /// <param name="colors">The colors as string</param> public static void SaveSettings(int indentSize, string fileExtensionsString, string colors, double opacityMultiplier, HighlightingMode highlightingmode, string errorColor, bool detectError) { ThreadHelper.ThrowIfNotOnUIThread(); WritableSettingsStore settingsStore = GetWritableSettingsStore(); settingsStore.SaveIndentSize(indentSize); settingsStore.SaveFileExtensionsIndentSizes(fileExtensionsString); settingsStore.SaveColors(colors); settingsStore.SaveOpacityMultiplier(opacityMultiplier); settingsStore.SaveHighlightingMode(highlightingmode); settingsStore.SaveDetectErrorsFlag(detectError); settingsStore.SaveErrorColor(errorColor); OptionsManager.indentSize.Set(indentSize); OptionsManager.fileExtensionsString.Set(fileExtensionsString); fileExtensionsDictionary.Set(LanguageParser.CreateDictionaryFromString(fileExtensionsString)); OptionsManager.colors.Set(colors); brushes.Set(ColorParser.ConvertStringToBrushArray(colors, opacityMultiplier)); OptionsManager.opacityMultiplier.Set(opacityMultiplier); OptionsManager.highlightingMode.Set(highlightingmode); OptionsManager.errorColor.Set(errorColor); detectErrors.Set(detectError); errorBrush.Set(ColorParser.ConvertStringToBrush(errorColor, opacityMultiplier)); }
public ConfiguredSettings(IServiceProvider vsServiceProvider) { try { var shellSettingsManager = new ShellSettingsManager(vsServiceProvider); this.store = shellSettingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); if (this.store.PropertyExists(SettingCollectionName, nameof(this.ActualSettings))) { var settingsString = this.store.GetString(SettingCollectionName, nameof(this.ActualSettings)); this.actualSettings = DeserializeOrDefault(settingsString); } else { this.actualSettings = GetDefaultSettings(); } } catch (Exception exc) { RapidXamlPackage.Logger?.RecordException(exc); throw; // Remove for launch. see issue #90 } }
protected override void Dispose(bool disposing) { if (disposing) { using (ServiceProvider serviceProvider = new ServiceProvider((IServiceProvider)(Package.GetGlobalService(typeof(IServiceProvider))))) { SettingsManager settingsManager = new ShellSettingsManager(serviceProvider); WritableSettingsStore settingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); if (settingsStore.CollectionExists(FilterSettings)) { settingsStore.DeleteCollection(FilterSettings); } settingsStore.CreateCollection(FilterSettings); for (int i = 0; (i < CommonFilters.Count); ++i) { settingsStore.SetString(FilterSettings, i.ToString(), CommonFilters[i]); } } } base.Dispose(disposing); }
public AvaloniaDesignerSettings(SVsServiceProvider vsServiceProvider) { _store = vsServiceProvider.GetWritableSettingsStore(SettingsScope.UserSettings); LoadSettings(); }
public ShellSettingsStore(IServiceProvider serviceProvider) { var manager = new ShellSettingsManager(serviceProvider); this.store = manager.GetWritableSettingsStore(SettingsScope.UserSettings); }
public SettingsService(WritableSettingsStore settings) { _settings = settings; }
public OptionsService(IServiceProvider serviceProvider) { var settingsManager = SettingsManagerCreator.GetSettingsManager(serviceProvider); _settingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); }
public SettingsHelper() { settings = GetSettings(); resourceManager = new ComponentResourceManager(typeof(DoxygenToolsOptionsBase)); }
public Settings(IServiceProvider provider) { SettingsManager settingsManager = new ShellSettingsManager(provider); _settingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); if (!_settingsStore.CollectionExists("DebugAttachManagerProcesses")) { return; } IEnumerable <string> services = _settingsStore.GetSubCollectionNames("DebugAttachManagerProcesses"); foreach (var s in services) { var p = new StoredProcessInfo { ProcessName = _settingsStore.GetString("DebugAttachManagerProcesses\\" + s, "ProcessName"), Title = _settingsStore.PropertyExists("DebugAttachManagerProcesses\\" + s, "Title") ? _settingsStore.GetString("DebugAttachManagerProcesses\\" + s, "Title") : null, RemoteServerName = _settingsStore.PropertyExists("DebugAttachManagerProcesses\\" + s, "RemoteServerName") ? _settingsStore.GetString("DebugAttachManagerProcesses\\" + s, "RemoteServerName") : null, RemotePortNumber = _settingsStore.PropertyExists("DebugAttachManagerProcesses\\" + s, "RemotePortNumber") ? _settingsStore.GetInt64("DebugAttachManagerProcesses\\" + s, "RemotePortNumber") : (long?)null, Selected = _settingsStore.GetBoolean("DebugAttachManagerProcesses\\" + s, "Selected"), DebugMode = _settingsStore.PropertyExists("DebugAttachManagerProcesses\\" + s, "DebugMode") ? _settingsStore.GetString("DebugAttachManagerProcesses\\" + s, "DebugMode") : null }; Processes.Add(p.Hash, p); } if (_settingsStore.PropertyExists("DebugAttachManagerProcesses", "RemoteServer")) { RemoteServer = _settingsStore.GetString("DebugAttachManagerProcesses", "RemoteServer"); } if (_settingsStore.PropertyExists("DebugAttachManagerProcesses", "RemotePort")) { RemotePort = _settingsStore.GetString("DebugAttachManagerProcesses", "RemotePort"); } if (_settingsStore.PropertyExists("DebugAttachManagerProcesses", "RemoteUserName")) { RemoteUserName = _settingsStore.GetString("DebugAttachManagerProcesses", "RemoteUserName"); } for (int i = 0; i < Constants.NUMBER_OF_OPTIONAL_COLUMNS; i++) { string columnName = $"Column{i}"; if (_settingsStore.PropertyExists("DebugAttachManagerProcesses", columnName)) { ProcessesColumns[i] = _settingsStore.GetBoolean("DebugAttachManagerProcesses", columnName); } else { if (i == 0) { // This is a hack, so we display PID by default ProcessesColumns[i] = true; } } } }
public VsUserSettings([Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider) { var shellSettingsManager = new ShellSettingsManager(serviceProvider); settingsStore = shellSettingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); }
protected void WriteInt32(string settingsRoot, string property, int value) { WritableSettingsStore userSettingsStore = GetWritableSettingsStore(settingsRoot); userSettingsStore.SetInt32(settingsRoot, property, value); }
internal static Settings Initialize(WritableSettingsStore settings) { return(Instance = new Settings(settings)); }
/// <summary> /// Saves the given string (representing the colors) /// </summary> /// <param name="store">The writable settings store</param> /// <param name="colors">The colors to save</param> public static void SaveColors(this WritableSettingsStore store, string colors) { store.SetString(collectionName, colorsPropertyName, colors); }
private PythonToolsOptionsService(IServiceProvider serviceProvider) { var settingsManager = SettingsManagerCreator.GetSettingsManager(serviceProvider); _settingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); }
/// <summary> /// Initializes properties in the package /// </summary> /// <param name="package">The package</param> private void Initialize(ShelvesetComparerPackage package) { SettingsManager settingsManager = new ShellSettingsManager(package); this.writableSettingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); if (!this.writableSettingsStore.CollectionExists("ShelveSetComparer")) { this.writableSettingsStore.CreateCollection("ShelveSetComparer"); this.ShowAsButton = true; this.TwoUsersView = true; } this.readableSettingStore = settingsManager.GetReadOnlySettingsStore(SettingsScope.UserSettings); }
public AlpaOptionsService(IServiceProvider serviceProvider) { var settingsManager = AlpaPackage.GetSettings(serviceProvider); _settingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); }
public void CheckSettingsStore() { SettingsManager settingsManager = new ShellSettingsManager(ServiceProvider); WritableSettingsStore userSettingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); }
/// <summary> /// Called when the window has loaded /// </summary> private void OnLoad(object sender, RoutedEventArgs e) { // Window icon var icon = WindowExtensions.ImageSourceFromIcon(Properties.Resources.oof); if (icon != null) { Icon = icon; } // Hide/disable minimize button WindowExtensions.HideMinimizeAndMaximizeButtons(this, hideMaximize: false); // Restore window size and position, if any try { var settingsManager = new ShellSettingsManager(Package); WritableSettingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); if (WritableSettingsStore.CollectionExists(SS_Collection) == true) { // These two are required from now on WindowStartupLocation = WindowStartupLocation.Manual; SizeToContent = SizeToContent.Manual; // Window size and position Top = WritableSettingsStore.GetInt32(SS_Collection, SS_WindowTop); Left = WritableSettingsStore.GetInt32(SS_Collection, SS_WindowLeft); Height = WritableSettingsStore.GetInt32(SS_Collection, SS_WindowHeight); Width = WritableSettingsStore.GetInt32(SS_Collection, SS_WindowWidth); WindowState = (WindowState)WritableSettingsStore.GetInt32(SS_Collection, SS_WindowState); // Other settings chActiveItem.IsChecked = WritableSettingsStore.GetBoolean(SS_Collection, SS_ActiveItem); rbLeftPanelTC.IsChecked = WritableSettingsStore.GetBoolean(SS_Collection, SS_LeftPanelTC); rbRightPanelTC.IsChecked = WritableSettingsStore.GetBoolean(SS_Collection, SS_RightPanelTC); if (rbLeftPanelTC.IsChecked == rbRightPanelTC.IsChecked) { // Impossible case that should not be possible but has somehow happened, so here is the fix rbLeftPanelTC.IsChecked = true; rbRightPanelTC.IsChecked = false; } } else { // Create collection now to be able to check for other settings the 1st time around WritableSettingsStore.CreateCollection(SS_Collection); // Must have a default rbLeftPanelTC.IsChecked = true; } } catch (Exception) { // Ignore quietly } // Load configurations and active path #pragma warning disable VSTHRD010 if (Paths.ListSolutionConfigurations(Dte, lbConfigurations, ref _activePath) == false) { // Something went wrong so abort // Error reporting, if any, is to be done in the calling method above Close(); } #pragma warning restore VSTHRD010 // Double-click on an item brings up TotalCommander without further ado lbConfigurations.MouseDoubleClick += LbConfigurations_MouseDoubleClick; }
public SettingsHelper(String collectionRootPathArg, WritableSettingsStore storeArg) { collectionRootPath = collectionRootPathArg; store = storeArg; }
public void SetUp() { mocks = new MockRepository(); store = mocks.StrictMock<WritableSettingsStore>(); }
public BoilerplateSettings() { SettingsManager settingsManager = new ShellSettingsManager(ServiceProvider.GlobalProvider); this.store = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); this.store.CreateCollection(CollectionPath); // Setting upgrade if needed if (this.store.PropertyExists(CollectionPath, VersionKey)) { int storedVersion = this.store.GetInt32(CollectionPath, VersionKey); if (storedVersion < LatestVersion) { this.SetVersionToLatest(); } } else { if (this.store.PropertyExists(CollectionPath, TestProjectsKey)) { // We are upgrading from an old version (v0), as we didn't have version tracked, but had a test projects dictionary var mockFrameworks = new List <string> { "Moq", "AutoMoq", "SimpleStubs", "NSubstitute" }; var templateTypes = new List <TemplateType> { TemplateType.File, TemplateType.MockFieldDeclaration, TemplateType.MockFieldInitialization, TemplateType.MockObjectReference }; foreach (string mockFrameworkName in mockFrameworks) { MockFramework mockFramework = MockFrameworks.Get(mockFrameworkName); foreach (TemplateType templateType in templateTypes) { string templateKey = $"Template_{mockFrameworkName}_{templateType}"; if (this.store.PropertyExists(CollectionPath, templateKey)) { string oldTemplate = this.store.GetString(CollectionPath, templateKey); this.CreateEntryForTestFramework(oldTemplate, templateType, TestFrameworks.Get("VisualStudio"), mockFramework); this.CreateEntryForTestFramework(oldTemplate, templateType, TestFrameworks.Get("NUnit"), mockFramework); this.store.DeleteProperty(CollectionPath, templateKey); } } } } this.SetVersionToLatest(); } if (this.store.PropertyExists(CollectionPath, TestProjectsKey)) { string dictionaryString = this.store.GetString(CollectionPath, TestProjectsKey); if (string.IsNullOrEmpty(dictionaryString)) { this.testProjectsDictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); } else { this.testProjectsDictionary = new Dictionary <string, string>(JsonConvert.DeserializeObject <Dictionary <string, string> >(dictionaryString), StringComparer.OrdinalIgnoreCase); } } else { this.testProjectsDictionary = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); } }
internal VimApplicationSettings(SVsServiceProvider vsServiceProvider, [EditorUtilsImport] IProtectedOperations protectedOperations) { var shellSettingsManager = new ShellSettingsManager(vsServiceProvider); _settingsStore = shellSettingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); _protectedOperations = protectedOperations; }
public PythonToolsOptionsService(IServiceProvider serviceProvider) { var settingsManager = PythonToolsPackage.GetSettings(serviceProvider); _settingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); }
/// <summary> /// This function is the callback used to execute the command when the menu item is clicked. /// See the constructor to see how the menu item is associated with this function using /// OleMenuCommandService service and MenuCommand class. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Event args.</param> private async void Execute(object sender, EventArgs e) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); string message = string.Format(CultureInfo.CurrentCulture, "Inside {0}.MenuItemCallback()", this.GetType().FullName); SettingsManager settingsManager = new ShellSettingsManager((IServiceProvider)ServiceProvider); WritableSettingsStore userSettingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); String serverUrl = userSettingsStore.GetString("ScantistSCA", "ServerURL", "https://api.scantist.io/"); String token = userSettingsStore.GetString("ScantistSCA", "Token", ""); String projectName = userSettingsStore.GetString("ScantistSCA", "ProjectName", ""); ProjectDetailWindow projectDetailWindow = new ProjectDetailWindow(); projectDetailWindow.ServerUrl = serverUrl; projectDetailWindow.Token = token; projectDetailWindow.ProjectName = projectName; projectDetailWindow.ShowModal(); String ServerUrl = projectDetailWindow.ServerUrl; String Token = projectDetailWindow.Token; String ProjectName = projectDetailWindow.ProjectName; String FilePath = projectDetailWindow.txtFileName.Text; if (projectDetailWindow.DialogResult.GetValueOrDefault(false)) { var dialogFactory = await ServiceProvider.GetServiceAsync(typeof(SVsThreadedWaitDialogFactory)).ConfigureAwait(false) as IVsThreadedWaitDialogFactory; IVsThreadedWaitDialog2 dialog = null; if (dialogFactory != null) { dialogFactory.CreateInstance(out dialog); } if (dialog != null && dialog.StartWaitDialog( "Scantist SCA", "Retrieving the project dependency", "We are getting there soon...", null, "ScantistSCA is running...", 0, false, true) == VSConstants.S_OK) { if (!userSettingsStore.CollectionExists("ScantistSCA")) { userSettingsStore.CreateCollection("ScantistSCA"); } userSettingsStore.SetString("ScantistSCA", "ServerURL", ServerUrl); userSettingsStore.SetString("ScantistSCA", "Token", Token); userSettingsStore.SetString("ScantistSCA", "ProjectName", ProjectName); CommandParameters commandParameters = new CommandParameters(); commandParameters.parseCommandLine(new string[11] { "-t", Token, "-serverUrl", ServerUrl, "-scanType", "source_code", "-f", Path.GetDirectoryName(FilePath), "-project_name", ProjectName, "--debug" }); int scanID = new Application().run(commandParameters); if (scanID == 0) { VsShellUtilities.ShowMessageBox( this.package, "Cannot trigger SCA scan. Please check log file for detail.", "Error", OLEMSGICON.OLEMSGICON_INFO, OLEMSGBUTTON.OLEMSGBUTTON_OK, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST); } else { VsShellUtilities.ShowMessageBox( this.package, "Scan " + scanID + " is successfully created.", "Completed", OLEMSGICON.OLEMSGICON_INFO, OLEMSGBUTTON.OLEMSGBUTTON_OK, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST); userSettingsStore.SetString("ScantistSCA", "ScanID", scanID.ToString()); await this.package.JoinableTaskFactory.RunAsync(async delegate { ToolWindowPane window = await this.package.ShowToolWindowAsync(typeof(ComponentResult), 0, true, this.package.DisposalToken); if ((null == window) || (null == window.Frame)) { throw new NotSupportedException("Cannot create tool window"); } }); } } int usercancel; dialog.EndWaitDialog(out usercancel); } }
internal VimApplicationSettings(VisualStudioVersion visualStudioVersion, WritableSettingsStore settingsStore, IVimProtectedOperations protectedOperations) { _settingsStore = settingsStore; _protectedOperations = protectedOperations; }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> /// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param> /// <param name="progress">A provider for progress updates.</param> /// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns> protected override async Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { // When initialized asynchronously, the current thread may be a background thread at this point. // Do any initialization that requires the UI thread after switching to the UI thread. await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken); try { SettingsManager settingsManager = new ShellSettingsManager(ServiceProvider); configurationSettingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); configurationSettingsStore.CreateCollection("LuaDkmDebugger"); attachOnLaunch = configurationSettingsStore.GetBoolean("LuaDkmDebugger", "AttachOnLaunch", true); breakOnError = configurationSettingsStore.GetBoolean("LuaDkmDebugger", "BreakOnError", true); releaseDebugLogs = configurationSettingsStore.GetBoolean("LuaDkmDebugger", "ReleaseDebugLogs", false); showHiddenFrames = configurationSettingsStore.GetBoolean("LuaDkmDebugger", "ShowHiddenFrames", false); useSchema = configurationSettingsStore.GetBoolean("LuaDkmDebugger", "UseSchema", false); LuaDkmDebuggerComponent.LocalComponent.attachOnLaunch = attachOnLaunch; LuaDkmDebuggerComponent.LocalComponent.breakOnError = breakOnError; LuaDkmDebuggerComponent.LocalComponent.releaseDebugLogs = releaseDebugLogs; LuaDkmDebuggerComponent.LocalComponent.showHiddenFrames = showHiddenFrames; LuaDkmDebuggerComponent.LocalComponent.useSchema = useSchema; } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Failed to setup setting with " + e.Message); } OleMenuCommandService commandService = ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (commandService != null) { { CommandID menuCommandID = new CommandID(CommandSet, LuaInitializeCommandId); OleMenuCommand menuItem = new OleMenuCommand((object sender, EventArgs args) => { if (sender is OleMenuCommand command) { command.Visible = false; } }, menuCommandID); menuItem.BeforeQueryStatus += (object sender, EventArgs args) => { if (sender is OleMenuCommand command) { command.Visible = false; } }; menuItem.Visible = false; commandService.AddCommand(menuItem); } { CommandID menuCommandID = new CommandID(CommandSet, LuaAttachOnLaunchCommandId); OleMenuCommand menuItem = new OleMenuCommand((object sender, EventArgs args) => { HandleToggleMenuItem(sender, args, "AttachOnLaunch", ref LuaDkmDebuggerComponent.LocalComponent.attachOnLaunch, ref attachOnLaunch); }, menuCommandID); menuItem.BeforeQueryStatus += (object sender, EventArgs args) => { if (sender is OleMenuCommand command) { command.Checked = attachOnLaunch; } }; menuItem.Enabled = true; menuItem.Checked = attachOnLaunch; commandService.AddCommand(menuItem); } { CommandID menuCommandID = new CommandID(CommandSet, LuaBreakOnErrorCommandId); OleMenuCommand menuItem = new OleMenuCommand((object sender, EventArgs args) => { HandleToggleMenuItem(sender, args, "BreakOnError", ref LuaDkmDebuggerComponent.LocalComponent.breakOnError, ref breakOnError); }, menuCommandID); menuItem.BeforeQueryStatus += (object sender, EventArgs args) => { if (sender is OleMenuCommand command) { command.Checked = breakOnError; } }; menuItem.Enabled = true; menuItem.Checked = breakOnError; commandService.AddCommand(menuItem); } { CommandID menuCommandID = new CommandID(CommandSet, LoggingCommandId); OleMenuCommand menuItem = new OleMenuCommand((object sender, EventArgs args) => { HandleToggleMenuItem(sender, args, "ReleaseDebugLogs", ref LuaDkmDebuggerComponent.LocalComponent.releaseDebugLogs, ref releaseDebugLogs); }, menuCommandID); menuItem.BeforeQueryStatus += (object sender, EventArgs args) => { if (sender is OleMenuCommand command) { command.Checked = releaseDebugLogs; } }; menuItem.Enabled = true; menuItem.Checked = releaseDebugLogs; commandService.AddCommand(menuItem); } { CommandID menuCommandID = new CommandID(CommandSet, LuaShowHiddenFramesCommandId); OleMenuCommand menuItem = new OleMenuCommand((object sender, EventArgs args) => { HandleToggleMenuItem(sender, args, "ShowHiddenFrames", ref LuaDkmDebuggerComponent.LocalComponent.showHiddenFrames, ref showHiddenFrames); }, menuCommandID); menuItem.BeforeQueryStatus += (object sender, EventArgs args) => { if (sender is OleMenuCommand command) { command.Checked = showHiddenFrames; } }; menuItem.Enabled = true; menuItem.Checked = showHiddenFrames; commandService.AddCommand(menuItem); } { CommandID menuCommandID = new CommandID(CommandSet, LuaUseSchemaCommandId); OleMenuCommand menuItem = new OleMenuCommand((object sender, EventArgs args) => { HandleToggleMenuItem(sender, args, "UseSchema", ref LuaDkmDebuggerComponent.LocalComponent.useSchema, ref useSchema); }, menuCommandID); menuItem.BeforeQueryStatus += (object sender, EventArgs args) => { if (sender is OleMenuCommand command) { command.Checked = useSchema; } }; menuItem.Enabled = true; menuItem.Checked = useSchema; commandService.AddCommand(menuItem); } { CommandID menuCommandID = new CommandID(CommandSet, LuaShowScriptListCommandId); MenuCommand menuItem = new MenuCommand((object sender, EventArgs args) => { JoinableTaskFactory.RunAsync(async() => { ToolWindowPane window = await ShowToolWindowAsync( typeof(ScriptListWindow), 0, create: true, cancellationToken: DisposalToken); }); }, menuCommandID); commandService.AddCommand(menuItem); } } try { DTE2 dte = (DTE2)ServiceProvider.GetService(typeof(SDTE)); scriptListWindowState.dte = dte; Debugger5 debugger = dte?.Debugger as Debugger5; var debuggerEventHandler = new LuaDebuggerEventHandler(this, debugger); ServiceContainer.AddService(debuggerEventHandler.GetType(), debuggerEventHandler, promote: true); } catch (Exception e) { Debug.WriteLine("Failed to setup debuggerEventHandler with " + e.Message); } }
public VsWritableSettingsStore(WritableSettingsStore writableSettingsStore) { this.writableSettingsStore = writableSettingsStore; }
public static void Initialize(WritableSettingsStore configurationSettingsStore) { Instance.store = configurationSettingsStore; }
/// <summary> /// Creates new SettingsStoreDexterInfoProvider /// </summary> /// <param name="serviceProvider"> service provider from the owner package</param> public SettingsStoreDexterInfoProvider(IServiceProvider serviceProvider) { SettingsManager settingsManager = new ShellSettingsManager(serviceProvider); settingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); }
public ConfigurableSettingsManager(WritableSettingsStore store) { this.WritableSettingsStore = store; }
public SettingsManager(Package settingProvider) { ShellSettingsManager settingsManager = new ShellSettingsManager(settingProvider as IServiceProvider); _settings = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); LoadSettings(); }
public MediatRSettingsStoreManager(WritableSettingsStore store) { this.store = store ?? throw new ArgumentNullException(nameof(store)); }
public SettingStoreProvider(string collection) { this.collection = collection; SettingsManager settingsManager = new ShellSettingsManager(ServiceProvider.GlobalProvider); userSettingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); }
protected bool DeleteProperty(string settingsRoot, string property) { WritableSettingsStore userSettingsStore = GetWritableSettingsStore(settingsRoot); return(userSettingsStore.DeleteProperty(settingsRoot, property)); }
public SettingsHelper() { settings = GetSettings(); resourceManager = new ResourceManager("DoxygenComments.Settings.DoxygenToolsOptionsBase", typeof(DoxygenToolsOptionsBase).Assembly); }
protected void WriteString(string settingsRoot, string property, string value) { WritableSettingsStore userSettingsStore = GetWritableSettingsStore(settingsRoot); userSettingsStore.SetString(settingsRoot, property, value); }
protected virtual void SaveProperty(WritableSettingsStore store) { }
protected void ClearAllSettings(string settingsRoot) { WritableSettingsStore userSettingsStore = _settingsManager.Value.GetWritableSettingsStore(SettingsScope.UserSettings); userSettingsStore.DeleteCollection(settingsRoot); }
public PaketSettings(ShellSettingsManager settingsManager) { settingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); if (!settingsStore.CollectionExists(StoreCollection)) settingsStore.CreateCollection(StoreCollection); }
public Settings(WritableSettingsStore settingsStore) { this.settingsStore = settingsStore; LoadSettings(); CreateApplicationFolderIfNotExist(); }