protected override void ConfigurationPresent()
{
config = ObjectFactory.LoadConfiguration(VisualStudioCloseQuestion.ConfigurationName);
// present configuration on the screen:
promptOnClosing.Checked = config.GetUInt(VisualStudioCloseQuestion.Config_Prompt, 0) > 0;
}
private void CheckVersion()
{
PersistentStorageData data = PersistentStorageHelper.Load(PersistantStorageName);
bool executeCheck = false;
if (data != null && data.Count > 0)
{
// get the last update date from the registry:
lastUpdateCheck = data.GetDateTime("LastUpdateDate");
sleepTime = (int)data.GetUInt("SleepTimeBeforeUpdateCheck", SleepTimeBeforeUpdateCheck) * 1000;
// check if update-check was performed at least one week ago:
if (lastUpdateCheck.AddDays(PeriodBeforeUpdateCheck) < DateTime.Today)
{
executeCheck = true;
}
else
{
// prevent updating the date inside the registry:
lastUpdateCheck = DateTime.MinValue;
}
}
else
{
executeCheck = true;
}
if (executeCheck && sleepTime != 0)
{
// start asynchronously new thread that will perform check and update the registry:
Thread threadCheck = new Thread(PerformUpdateCheck);
threadCheck.Start();
}
}
protected override void ConfigurationUpdate(out PersistentStorageData actionConfig)
{
// update configuration:
config.Add(VisualStudioCloseQuestion.Config_Prompt, (uint)(promptOnClosing.Checked ? 1 : 0));
actionConfig = config;
}
/// <summary>
/// Performs initialization of this action and
/// also registers all the UI elements required by the action, e.g.: menus / menu groups / toolbars.
/// </summary>
public void Initialize(IPackageEnvironment env, IMenuCreator mc)
{
solutionListener = new SolutionEventsListener(env.DTE);
solutionListener.SolutionQueryClose += SolutionEvents_SolutionQueryClose;
config = ObjectFactory.LoadConfiguration(ConfigurationName);
}
/// <summary>
/// Loads system assemblies and the list of forbidden names.
/// </summary>
private void LoadAndSortSystemAssemblies()
{
// load some configuration options from registry:
PersistentStorageData data = ObjectFactory.LoadConfiguration(CofigurationName);
string[] forbiddenNames = data.GetMultiString(Persistent_ForbiddenNames);
string[] systemAssemblies = data.GetMultiString(Persistent_SystemAssemblies);
if (forbiddenNames != null && forbiddenNames.Length > 0)
{
ForbiddenNames = forbiddenNames;
}
if (systemAssemblies != null && systemAssemblies.Length > 0)
{
SystemAssemblies = systemAssemblies;
}
else
{
SystemAssemblies = DefaultSystemAssemblies;
}
if (SystemAssemblies != null)
{
Array.Sort(SystemAssemblies);
}
}
/// <summary>
/// Sets the configuration description for given action.
/// </summary>
public void UpdateConfiguration(Type actionType, PersistentStorageData config)
{
IPackageAction action = actions.Get(actionType);
if (action != null)
{
action.Configuration = config;
}
}
/// <summary>
/// Writes the current state of the control to a persistent storage area.
/// </summary>
public void StoreState()
{
if (treeView.SelectedNode != null)
{
PersistentStorageData data = new PersistentStorageData(ToolName);
data.Add(Settings_Path, treeView.SelectedNode.FullPath);
data.Add(Settings_Favorites, ExportFavorites());
PersistentStorageHelper.Save(data);
}
}
protected override void ConfigurationPresent()
{
string[] assemblies;
config = ObjectFactory.LoadConfiguration(ReferenceProjectAction.CofigurationName);
// add assemblies to the screen:
listReferences.Items.Clear();
assemblies = config.GetMultiString(ReferenceProjectAction.Persistent_SystemAssemblies);
if (assemblies != null)
{
Add(assemblies);
}
}
public void SaveState()
{
string[] storedFilter = FilterMessages;
if (storedFilter != null && storedFilter.Length > 0)
{
PersistentStorageData data = new PersistentStorageData(ToolName);
data.Add("Filter", storedFilter);
PersistentStorageHelper.Save(data);
}
}
/// <summary>
/// Performs initialization of this action and
/// also registers all the UI elements required by the action, e.g.: menus / menu groups / toolbars.
/// </summary>
public void Initialize(IPackageEnvironment env, IMenuCreator mc)
{
MenuCommand menu = ObjectFactory.CreateCommand(GuidList.guidCmdSet, ID, Execute, BeforeQueryStatus);
parent = env;
// load configuration:
config = ObjectFactory.LoadConfiguration(ConfigurationName);
// -------------------------------------------------------
mc.AddCommand(menu, "MultiRenameRefactor", "Multi Method &Rename...", 9004, "Global::Ctrl+R, L", null, false);
mc.Customizator.AddRefactoring(menu, false, -1, null);
}
/// <summary>
/// Store inside the persistent storage, when the last update took place.
/// </summary>
private void StoreCheckState()
{
if (lastUpdateCheck == DateTime.MinValue)
{
return;
}
PersistentStorageData data = new PersistentStorageData(PersistantStorageName);
data.Add("LastUpdateDate", lastUpdateCheck.ToShortDateString());
// store:
PersistentStorageHelper.Save(data);
}
public static Task LogOutAsync()
{
EnsureInitialized();
return(Task.Run(() =>
{
if (SessionKey == null)
{
return;
}
var resp = Rest.DoPost("Logout", new { SessionKey = SessionKey });
StoredData = new PersistentStorageData();
RaiseStorageChanged();
}));
}
/// <summary>
/// Restores the stored state of the editor.
/// </summary>
public void RestoreState()
{
PersistentStorageData data = PersistentStorageHelper.Load(ToolName);
if (data != null && data.Count > 0)
{
NavigateTo(data.GetString(Settings_Path));
ImportFavorites(data.GetMultiString(Settings_Favorites));
}
navigator.Clear();
RefreshNavigationButtons();
RefreshFavoritesMenu();
}
/// <summary>
/// Loads the persistent storage data for particular tool.
/// </summary>
public static PersistentStorageData Load(string toolName)
{
try
{
PersistentStorageData data = new PersistentStorageData(toolName);
RegistryKey key = OpenKey(toolName, false);
if (key == null)
{
return(data);
}
string[] names = key.GetValueNames();
foreach (string k in names)
{
object d = key.GetValue(k);
switch (key.GetValueKind(k))
{
case RegistryValueKind.MultiString:
data.Add(k, (string[])d);
break;
case RegistryValueKind.ExpandString:
case RegistryValueKind.String:
data.Add(k, (string)d);
break;
case RegistryValueKind.Binary:
data.Add(k, (byte[])d);
break;
case RegistryValueKind.DWord:
case RegistryValueKind.QWord:
data.Add(k, Convert.ToUInt32(d));
break;
}
}
CloseKey(key);
return(data);
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message);
Trace.WriteLine(ex.StackTrace);
return(null);
}
}
protected override void ConfigurationUpdate(out PersistentStorageData actionConfig)
{
string[] assemblies = GetSerializedAssemblies();
// set new set of system assemblies:
if (assemblies != null)
{
config.Add(ReferenceProjectAction.Persistent_SystemAssemblies, assemblies);
}
else
{
config.Remove(ReferenceProjectAction.Persistent_SystemAssemblies);
}
actionConfig = config;
}
/// <summary>
/// Writes the particular data to the persistent storage area.
/// </summary>
public static bool Save(PersistentStorageData data)
{
try
{
RegistryKey key = OpenKey(data.Name, true);
// store the data:
if (key != null)
{
// remove deleted keys:
foreach (string k in data.Removed)
{
key.DeleteValue(k, false);
}
// set values for the others:
foreach (string k in data.KeysStrings)
{
key.SetValue(k, data.GetString(k), RegistryValueKind.String);
}
foreach (string k in data.KeysMultiString)
{
key.SetValue(k, data.GetMultiString(k), RegistryValueKind.MultiString);
}
foreach (string k in data.KeysBytes)
{
key.SetValue(k, data.GetByte(k), RegistryValueKind.Binary);
}
foreach (string k in data.KeysUInts)
{
key.SetValue(k, data.GetUInt(k), RegistryValueKind.DWord);
}
}
CloseKey(key);
return(true);
}
catch (Exception ex)
{
Trace.WriteLine(ex.Message);
Trace.WriteLine(ex.StackTrace);
return(false);
}
}
private void StoreConfig(MultiRenameForm dlg)
{
if (dlg != null)
{
if (config == null)
{
config = ObjectFactory.LoadConfiguration(ConfigurationName);
}
StringHelper.CounterDetails counter = dlg.Counter;
config.Add("Formula", dlg.Formula);
config.Add("CounterStart", counter.Current);
config.Add("CounterStep", counter.Step);
config.Add("CounterDigits", (uint)counter.Digits);
config.Add("FormatIndex", (uint)dlg.FormatIndex);
}
}
/// <summary>
/// Performs the cleanup actions.
/// </summary>
public void Dispose()
{
// notify about the exit event:
foreach (IPackageAction addIn in data)
{
PersistentStorageData config = addIn.Configuration;
// write configuration if needed:
if (config != null && config.IsDirty)
{
PersistentStorageHelper.Save(config);
}
// and finally release resources:
addIn.Destroy();
}
data.Clear();
}
/// <summary>
/// Initialize customizator and associate with given manager.
/// </summary>
public void Initialize(CustomAddInManager m)
{
IMenuCreator mc = m.MenuCreator;
// read the global settings for an add-in:
config = ObjectFactory.LoadConfiguration(null);
// configure the management objects:
manager = m;
tytanToolbar = mc.AddToolbar(ToolbarName);
tytanAuxTools = mc.AddPopup(tytanToolbar, AuxiliaryToolsName, null, false, -1);
tytanRefactors = mc.AddPopup(tytanToolbar, RefactorMenu, null, true, -1);
refactors = new List <CommandBar>();
if (tytanRefactors != null)
{
refactors.Add(tytanRefactors.CommandBar);
}
refactors.Add(mc.GetMainMenuCommandBar(RefactorMenu));
refactors.Add(mc.GetCodeWindowCommandBar(RefactorMenu));
}
public void RestoreState()
{
PersistentStorageData data = PersistentStorageHelper.Load(ToolName);
if (data != null && data.Count > 0)
{
string[] storedFilter = data.GetMultiString("Filter");
if (storedFilter == null)
{
string f = data.GetString("Filter");
if (f != null)
{
storedFilter = new string[] { f }
}
;
}
FilterMessages = storedFilter;
}
}
/// <summary>
/// Writes the configuration items into persistent storage.
/// To have a valid effect ActionType property must be overwritten and return
/// correct type of an associated action.
/// </summary>
protected virtual void ConfigurationUpdate(out PersistentStorageData actionConfig)
{
actionConfig = null;
}
/// <summary>
/// Sets the configuration object for given action.
/// </summary>
private static void UpdateActionConfig(IPackageConfigUpdater cu, Type actionType, PersistentStorageData config)
{
if (cu != null && config != null && actionType != null)
{
PersistentStorageHelper.Save(config);
cu.UpdateConfiguration(actionType, config);
}
}
