/// <summary> /// Initializes the settings /// </summary> /// <param name="configurationSettingsStore">The settings store</param> public Settings(WritableSettingsStore configurationSettingsStore) { _store = configurationSettingsStore; _showLinesColored = _store.GetBoolean(SETTINGS_PATH, "ShowLinesColored", false); _showCoverageGlyphs = _store.GetBoolean(SETTINGS_PATH, "ShowCoverageGlyphs", true); }
public static void Load() { ResourcesFolderName = settings.GetString(collectionName, nameof(ResourcesFolderName)); ResourcesManagerName = settings.GetString(collectionName, nameof(ResourcesManagerName)); UseStaticResourceXAML = settings.GetBoolean(collectionName, nameof(UseStaticResourceXAML)); SetLocaleOnStartup = settings.GetBoolean(collectionName, nameof(SetLocaleOnStartup)); }
/// <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); }
/// <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); _showUncoveredClasses = _store.GetBoolean(SETTINGS_PATH, SettingNames.ShowUncoveredClasses, true); }
/// <summary> /// Reads and parses Crm Connections from settings store /// </summary> /// <returns>Returns Crm Connetions</returns> private CrmConnections GetCrmConnections() { if (_settingsStore.PropertyExists(CollectionPath, ConnectionsPropertyName) == false) { return(null); } var connectionsXml = _settingsStore.GetString(CollectionPath, ConnectionsPropertyName); try { var connections = XmlSerializerHelper.Deserialize <List <ConnectionDetail> >(connectionsXml); var crmConnections = new CrmConnections { Connections = connections }; var publisAfterUpload = true; if (_settingsStore.PropertyExists(CollectionPath, AutoPublishPropertyName)) { publisAfterUpload = _settingsStore.GetBoolean(CollectionPath, AutoPublishPropertyName); } crmConnections.PublishAfterUpload = publisAfterUpload; var ignoreExtensions = false; if (_settingsStore.PropertyExists(CollectionPath, IgnoreExtensionsProprtyName)) { ignoreExtensions = _settingsStore.GetBoolean(CollectionPath, IgnoreExtensionsProprtyName); } crmConnections.IgnoreExtensions = ignoreExtensions; var extendedLog = false; if (_settingsStore.PropertyExists(CollectionPath, ExtendedLogProprtyName)) { extendedLog = _settingsStore.GetBoolean(CollectionPath, ExtendedLogProprtyName); } crmConnections.ExtendedLog = extendedLog; foreach (var connection in crmConnections.Connections) { if (!string.IsNullOrEmpty(connection.UserPassword)) { connection.UserPassword = DecryptString(connection.UserPassword); } } return(crmConnections); } catch (Exception) { Logger.WriteLine("Failed to parse connection settings"); return(null); } }
public static void LoadCurrent() { try { if (!settingsStore.CollectionExists(COLLECTION_PATH)) { return; } if (settingsStore.PropertyExists(COLLECTION_PATH, nameof(FontSettings.Font))) { CurrentSettings.Font = settingsStore.GetString(COLLECTION_PATH, nameof(FontSettings.Font)); } if (settingsStore.PropertyExists(COLLECTION_PATH, nameof(FontSettings.Size))) { var str = settingsStore.GetString(COLLECTION_PATH, nameof(FontSettings.Size)); double size; double.TryParse(str, out size); CurrentSettings.Size = size; } if (settingsStore.PropertyExists(COLLECTION_PATH, nameof(FontSettings.Italic))) { CurrentSettings.Italic = settingsStore.GetBoolean(COLLECTION_PATH, nameof(FontSettings.Italic)); } if (settingsStore.PropertyExists(COLLECTION_PATH, nameof(FontSettings.Opacity))) { var str = settingsStore.GetString(COLLECTION_PATH, nameof(FontSettings.Opacity)); double opacity; double.TryParse(str, out opacity); CurrentSettings.Opacity = opacity; } if (settingsStore.PropertyExists(COLLECTION_PATH, nameof(FontSettings.HighlightKeywordsOnly))) { CurrentSettings.HighlightKeywordsOnly = settingsStore.GetBoolean(COLLECTION_PATH, nameof(FontSettings.HighlightKeywordsOnly)); } if (settingsStore.PropertyExists(COLLECTION_PATH, nameof(FontSettings.UnderlineImportantComments))) { CurrentSettings.UnderlineImportantComments = settingsStore.GetBoolean(COLLECTION_PATH, nameof(FontSettings.UnderlineImportantComments)); } } catch (Exception ex) { Debug.Fail(ex.Message); } }
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"); } 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; } } } }
/// <summary> /// Read from a settings store /// </summary> /// <typeparam name="T"></typeparam> /// <param name="subpath">The subcollection path (appended to the path passed to the constructor)</param> /// <param name="property">The property name to read</param> /// <param name="defaultValue">The default value to use in case the property doesn't exist. /// The type of the default value will be used to figure out the proper way to read the property, so if pass null, /// the property will be read as a string (which may or may not be what you want)</param> /// <returns></returns> public object Read(string subpath, string property, object defaultValue) { Guard.ArgumentNotNull(property, nameof(property)); Guard.ArgumentNotEmptyString(property, nameof(property)); var collection = subpath != null?Path.Combine(root, subpath) : root; store.CreateCollection(collection); if (defaultValue is bool) { return(store.GetBoolean(collection, property, (bool)defaultValue)); } else if (defaultValue is int) { return(store.GetInt32(collection, property, (int)defaultValue)); } else if (defaultValue is uint) { return(store.GetUInt32(collection, property, (uint)defaultValue)); } else if (defaultValue is long) { return(store.GetInt64(collection, property, (long)defaultValue)); } else if (defaultValue is ulong) { return(store.GetUInt64(collection, property, (ulong)defaultValue)); } return(store.GetString(collection, property, defaultValue?.ToString() ?? "")); }
void LoadSettings() { SettingsManager settingsManager = new ShellSettingsManager(LogcatOutputToolWindowCommand.Instance.ServiceProvider); WritableSettingsStore configurationSettingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); string adb_path = configurationSettingsStore.GetString(StoreCategoryName, StorePropertyAdbPathName, ""); uint log_limit = configurationSettingsStore.GetUInt32(StoreCategoryName, StorePropertyLogsLimitName, 20000); bool is_auto = configurationSettingsStore.GetBoolean(StoreCategoryName, StorePropertyAutoScrollName, false); LogLimitCount = log_limit; adb.AdbExePath = adb_path; IsAutoScroll = is_auto; ColumnWidth[0] = configurationSettingsStore.GetUInt32(StoreCategoryName, StorePropertyLevelWidthName, 60); ColumnWidth[1] = configurationSettingsStore.GetUInt32(StoreCategoryName, StorePropertyTimeWidthName, 120); ColumnWidth[2] = configurationSettingsStore.GetUInt32(StoreCategoryName, StorePropertyPidWidthName, 60); ColumnWidth[3] = configurationSettingsStore.GetUInt32(StoreCategoryName, StorePropertyTagWidthName, 120); ColumnWidth[4] = configurationSettingsStore.GetUInt32(StoreCategoryName, StorePropertyTextWidthName, 600); if (IsAutoScroll) { Dispatcher.InvokeAsync(() => { AutoScrollLabel.Content = "Auto Scroll On"; }); } else { Dispatcher.InvokeAsync(() => { AutoScrollLabel.Content = "Auto Scroll Off"; }); } }
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"); } }
private static void LoadSettingsFromStore(ISettings settings) { var properties = GetProperties(settings); foreach (var prop in properties) { if (store.PropertyExists(settings.Key, prop.Name)) { switch (prop.GetValue(settings)) { case bool b: prop.SetValue(settings, store.GetBoolean(settings.Key, prop.Name)); break; case int i: prop.SetValue(settings, store.GetInt32(settings.Key, prop.Name)); break; case double d when double.TryParse(store.GetString(settings.Key, prop.Name), out double value): prop.SetValue(settings, value); break; case string s: prop.SetValue(settings, store.GetString(settings.Key, prop.Name)); break; } } } }
public object Read(string subPath, string property, object defaultValue) { Validate.IsNotNull(property, nameof(property)); Validate.IsNotEmpty(property, nameof(property)); var collection = subPath != null?Path.Combine(_root, subPath) : _root; _store.CreateCollection(collection); if (defaultValue is bool b) { return(_store.GetBoolean(collection, property, b)); } if (defaultValue is int i) { return(_store.GetInt32(collection, property, i)); } if (defaultValue is uint u) { return(_store.GetUInt32(collection, property, u)); } if (defaultValue is long l) { return(_store.GetInt64(collection, property, l)); } if (defaultValue is ulong ul) { return(_store.GetUInt64(collection, property, ul)); } return(_store.GetString(collection, property, defaultValue?.ToString() ?? "")); }
public static void LoadCurrent() { if (!settingsStore.CollectionExists(CollectionPath)) { return; } Current.IsEnabled = settingsStore.GetBoolean(CollectionPath, "IsEnabled", true); }
private object Get(string key, Type targetType = null, object defaultValue = null, SerializationMode serializationMode = SerializationMode.Xml) { try { if (targetType == null) { targetType = ConvertSettingsType(Check.TryCatch <SettingsType, Exception>(() => settingsStore.GetPropertyType(collectionPath, key))); } object result = null; if (targetType.IsEnum) { targetType = typeof(int); } if (targetType == typeof(bool)) { result = settingsStore.GetBoolean(collectionPath, key, Convert.ToBoolean(defaultValue)); } else if (targetType == typeof(string)) { result = settingsStore.GetString(collectionPath, key, defaultValue as string); } else if (targetType == typeof(int)) { result = settingsStore.GetInt32(collectionPath, key, Convert.ToInt32(defaultValue)); } else { if (settingsStore.PropertyExists(collectionPath, key)) { if (serializationMode == SerializationMode.Xml) { string xmlContent = settingsStore.GetString(collectionPath, key); var serializer = new XmlSerializer(targetType); MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(xmlContent)); var res = serializer.Deserialize(ms); return(res); } else { var ms = settingsStore.GetMemoryStream(collectionPath, key); if (ms != null) { var serializer = new BinaryFormatter(); result = serializer.Deserialize(ms); } } } } return(result ?? defaultValue); } catch (Exception) { return(defaultValue); } }
/// <summary> /// Loads DexterInfo from Settings Store /// </summary> /// <returns>loaded DexterInfo</returns> public DexterInfo Load() { if (!settingsStore.CollectionExists(DexterStoreName)) { return(new DexterInfo()); } else { return(new DexterInfo() { dexterHome = settingsStore.GetString(DexterStoreName, "dexterHome"), dexterServerIp = settingsStore.GetString(DexterStoreName, "dexterServerIp"), dexterServerPort = settingsStore.GetInt32(DexterStoreName, "dexterServerPort"), userName = settingsStore.GetString(DexterStoreName, "userName"), userPassword = settingsStore.GetString(DexterStoreName, "userPassword"), standalone = settingsStore.GetBoolean(DexterStoreName, "standalone"), IsDexterHomeEnabled = settingsStore.GetBoolean(DexterStoreName, "isDexterHomeEnabled"), }); } }
public static bool ReadBoolFromUserSettings(string propertyName) { try { bool ret = _userSettingsStore.GetBoolean(REGISTRY_FOLDER_NAME, propertyName); return(ret); } catch (Exception ex) { return(false); } }
private static void EnableLoadingAllExtensions(WritableSettingsStore settingsStore) { const string EnableAdminExtensionsProperty = "EnableAdminExtensions"; if (!settingsStore.CollectionExists(ExtensionManagerCollectionPath)) { settingsStore.CreateCollection(ExtensionManagerCollectionPath); } if (!settingsStore.GetBoolean(ExtensionManagerCollectionPath, EnableAdminExtensionsProperty, defaultValue: false)) { settingsStore.SetBoolean(ExtensionManagerCollectionPath, EnableAdminExtensionsProperty, value: true); } }
private static bool GetBooleanProperty(WritableSettingsStore store, string propertyName, bool defaultValue) { try { if (!store.PropertyExists(CollectionName, propertyName)) { store.SetBoolean(CollectionName, propertyName, defaultValue); } return(store.GetBoolean(CollectionName, propertyName)); } catch { store.SetBoolean(CollectionName, propertyName, defaultValue); return(defaultValue); } }
public static void LoadSettings(ISettings settings) { try { if (store.CollectionExists(settings.Key) != true) { return; } var type = settings.GetType(); foreach (var prop in type.GetProperties().Where(p => Attribute.IsDefined(p, typeof(SettingAttribute)))) { if (prop.PropertyType == typeof(bool)) { if (store.PropertyExists(settings.Key, prop.Name)) { prop.SetValue(settings, store.GetBoolean(settings.Key, prop.Name)); } } else if (prop.PropertyType == typeof(int)) { if (store.PropertyExists(settings.Key, prop.Name)) { prop.SetValue(settings, store.GetInt32(settings.Key, prop.Name)); } } else if (prop.PropertyType == typeof(double)) { if (store.PropertyExists(settings.Key, prop.Name)) { double.TryParse(store.GetString(settings.Key, prop.Name), out double value); prop.SetValue(settings, value); } } else if (prop.PropertyType == typeof(string)) { if (store.PropertyExists(settings.Key, prop.Name)) { prop.SetValue(settings, store.GetString(settings.Key, prop.Name)); } } } } catch (Exception ex) { Debug.Fail(ex.Message); } }
private IClippyVSSettings GetClippySettings() { ThreadHelper.ThrowIfNotOnUIThread(); bool res = false; if (_store.PropertyExists(Constants.SettingsCollectionPath, "ShowAtStartup")) { res = _store.GetBoolean(Constants.SettingsCollectionPath, "ShowAtStartup"); } return(new ClippyVSSettings(_store) { ShowAtStartup = res }); }
/// <summary> /// Read the stored settings /// </summary> private void LoadSettings() { try { // Tries to retrieve the configurations if previously saved if (writableSettingsStore.PropertyExists(Constants.SettingsCollectionPath, ShowAtStartupStoreName)) { ShowAtStartup = writableSettingsStore.GetBoolean(Constants.SettingsCollectionPath, ShowAtStartupStoreName); Debug.WriteLine("Setting loaded which is {0}", ShowAtStartup); } } catch (ArgumentException ex) { Debug.Fail(ex.Message); } }
public bool GetBoolean(string propertyName) { try { if (_settingsStore.PropertyExists(CollectionPath, propertyName)) { return(_settingsStore.GetBoolean(CollectionPath, propertyName)); } } catch (Exception ex) { Debug.WriteLine(ex.Message); } return(false); }
public static object GetValue(this WritableSettingsStore store, string collectionPath, PropertyDescriptor property) { if (store.PropertyExists(collectionPath, property.Name)) { switch (property.PropertyType) { case Type t when t == typeof(string): return(store.GetString(collectionPath, property.Name)); case Type t when t == typeof(int): return(store.GetInt32(collectionPath, property.Name)); case Type t when t == typeof(long): return(store.GetInt64(collectionPath, property.Name)); case Type t when t == typeof(bool): return(store.GetBoolean(collectionPath, property.Name)); } } return(null); }
/// <summary> /// Loads the detect errors flag /// </summary> /// <param name="store">The writable settings store</param> /// <returns>The detect error flag or if not found, the default detect error flag</returns> public static bool LoadDetectErrorsFlag(this WritableSettingsStore store) { bool detectErrorFlag = DefaultRainbowIndentOptions.defaultDetectErrorsFlag; if (store == null) { return(detectErrorFlag); } if (!store.PropertyExists(CollectionName, DetectErrorsPropertyName)) { store.SaveDetectErrorsFlag(detectErrorFlag); } else { detectErrorFlag = store.GetBoolean(CollectionName, DetectErrorsPropertyName); } return(detectErrorFlag); }
internal bool GetBoolean(string propertyName, bool defaultValue) { EnsureCollectionExists(); try { if (!_settingsStore.PropertyExists(CollectionPath, propertyName)) { return(defaultValue); } return(_settingsStore.GetBoolean(CollectionPath, propertyName)); } catch (Exception e) { Report(String.Format(ErrorGetFormat, propertyName), e); return(defaultValue); } }
public static async System.Threading.Tasks.Task InitializeAsync(AsyncPackage package) { { // Adding callback method to "Parallel Builds Monitor" menu item into "VS -> Menu -> View -> Other Windows" menu IMenuCommandService commandService = (IMenuCommandService)await package.GetServiceAsync(typeof(IMenuCommandService)); Microsoft.Assumes.Present(commandService); CommandID menuCommandID = new CommandID(typeof(MainMenuCommandSet).GUID, (int)MainMenuCommandSet.ShowToolWindow); MenuCommand menuItem = new MenuCommand((s, e) => Execute(package), menuCommandID); commandService.AddCommand(menuItem); } { // Start listening VS Events... // Should we always collect data even when "Parallel Builds Monitor" pane is closed? // What if user open PBM pane in the the middle of build? Should we show Gantt chart or draw notice like "Restart build to see results"? // If we decide not to collect data when PBM pane is closed, then user must manually activate PBM before build in order to have Gantt. // This is because "Output" pane is left as active after each build, so "Output" pane will be active pane after VS restart. PBMCommand.Initialize(package); } { // Show and Activate "Parallel Builds Monitor" pane // Do we really want to activate "Parallel Builds Monitor" pane after each solution load? // Or maybe we want to do that only once after installation? // Will it work when PBM plugin is installed whn solution is already opened? const string collectionName = "PBMSettings"; const string propertyName = "FirstRun"; SettingsManager settingsManager = new ShellSettingsManager(PBMCommand.ServiceProvider); WritableSettingsStore writableUserSettingsStore = settingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); if (!writableUserSettingsStore.CollectionExists(collectionName)) { writableUserSettingsStore.CreateCollection(collectionName); } bool firstRun = writableUserSettingsStore.GetBoolean(collectionName, propertyName, true); if (firstRun) { writableUserSettingsStore.SetBoolean(collectionName, propertyName, false); Execute(package); } } }
public static bool GetBoolean(string option) { Initialize(); bool default_value = false; defaults.TryGetValue(option, out object value); if (value == null) { default_value = false; } else if (value is bool) { default_value = (bool)value; } if (persistent_settings != null) { return(persistent_settings.GetBoolean("AntlrVSIX", option, default_value)); } else { return(default_value); } }
public static T ReadSetting <T>(string propertyName) { CreatePropertyIfDoesNotExist <T>(propertyName); object value; switch (Type.GetTypeCode(typeof(T))) { case TypeCode.String: value = _userSettingsStore.GetString(CollectionName, propertyName); return((T)Convert.ChangeType(value, typeof(T))); case TypeCode.Boolean: value = _userSettingsStore.GetBoolean(CollectionName, propertyName); return((T)Convert.ChangeType(value, typeof(T))); case TypeCode.Int32: value = _userSettingsStore.GetInt32(CollectionName, propertyName); return((T)Convert.ChangeType(value, typeof(T))); case TypeCode.Int64: value = _userSettingsStore.GetInt64(CollectionName, propertyName); return((T)Convert.ChangeType(value, typeof(T))); case TypeCode.UInt32: value = _userSettingsStore.GetUInt32(CollectionName, propertyName); return((T)Convert.ChangeType(value, typeof(T))); case TypeCode.UInt64: value = _userSettingsStore.GetUInt64(CollectionName, propertyName); return((T)Convert.ChangeType(value, typeof(T))); default: value = _userSettingsStore.GetString(CollectionName, propertyName); return((T)Convert.ChangeType(value, typeof(T))); } }
/// <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; }
/// <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 bool GetBooleanByProject(Project project, string key, bool defaultValue = false) { var collectionPath = GetOrCreateCollectionByProject(project); return(store.GetBoolean(collectionPath, key, defaultValue)); }