示例#1
0
        /// <summary>
        /// 关联文件
        /// </summary>
        /// <param name="filePathString">应用程序路径</param>
        /// <param name="pFileTypeName">文件类型</param>
        public static void SaveReg(string filePathString, string pFileTypeName)
        {
            RegistryKey regKey = Registry.ClassesRoot.OpenSubKey("", true); //打开注册表
            RegistryKey vrPkey = regKey?.OpenSubKey(pFileTypeName, true);

            if (vrPkey != null)
            {
                regKey.DeleteSubKey(pFileTypeName, true);
            }

            regKey?.CreateSubKey(pFileTypeName);
            vrPkey = regKey?.OpenSubKey(pFileTypeName, true);
            vrPkey?.SetValue("", "Exec");
            vrPkey = regKey?.OpenSubKey("Exec", true);
            if (vrPkey != null)
            {
                regKey.DeleteSubKeyTree("Exec");                 //如果等于空就删除注册表DSKJIVR
            }
            regKey?.CreateSubKey("Exec");
            vrPkey = regKey?.OpenSubKey("Exec", true);
            vrPkey?.CreateSubKey("shell");
            vrPkey = vrPkey?.OpenSubKey("shell", true); //写入必须路径
            vrPkey?.CreateSubKey("open");
            vrPkey = vrPkey?.OpenSubKey("open", true);
            vrPkey?.CreateSubKey("command");
            vrPkey = vrPkey?.OpenSubKey("command", true);
            string pathString = "\"" + filePathString + "\" \"%1\"";

            vrPkey?.SetValue("", pathString); //写入数据
        }
示例#2
0
        private void InstallAdministratorRegistry()
        {
            RegistryKey administratorKey = defaultKey?.CreateSubKey("runas", RegistryKeyPermissionCheck.ReadWriteSubTree);

            try
            {
                administratorKey?.SetValue("", runAsAdministratorNameTextBox.Text);
            }
            catch
            {
                // ignored
            }
            try
            {
                if (runAsAdministratorIconTextBox.Text != String.Empty)
                {
                    administratorKey?.SetValue("icon", Path.Combine(IcoDirectory, @"Administrator\Administrator.ico"));
                }
                else
                {
                    administratorKey?.DeleteValue("icon");
                }
            }
            catch
            {
                // ignored
            }
            administratorKey?.Close();
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="extension"></param>
        /// <param name="progId"></param>
        /// <param name="description"></param>
        /// <param name="icon"></param>
        /// <param name="application"></param>
        // Associate file extension with progID, description, icon and application
        public static void Associate(string extension,
                                     string progId, string description, string icon, string application)
        {
            RegistryKey registryKey = Registry.ClassesRoot.CreateSubKey(extension);

            registryKey?.SetValue("", progId);


            if (string.IsNullOrEmpty(progId))
            {
                return;
            }
            using (RegistryKey key = Registry.ClassesRoot.CreateSubKey(progId))
            {
                if (description != null)
                {
                    key?.SetValue("", description);
                }
                if (icon != null)
                {
                    var subKey = key?.CreateSubKey("DefaultIcon");
                    subKey?.SetValue("", ToShortPathName(icon));
                }
                if (application != null)
                {
                    var subKey = key?.CreateSubKey(@"Shell\Open\Command");
                    subKey?.SetValue("", ToShortPathName(application) + " \"%1\"");
                }
            }
            SHChangeNotify(0x08000000, 0x0000, IntPtr.Zero, IntPtr.Zero);
        }
示例#4
0
        public void AssociateFiles()
        {
            new System.Security.Permissions.RegistryPermission(System.Security.Permissions.PermissionState.Unrestricted).Assert();
            try
            {
                using (RegistryKey myKey = Registry.ClassesRoot.CreateSubKey(".tga"))
                {
                    myKey?.SetValue("", "ArdaViewer.tga");
                }
                using (RegistryKey myKey = Registry.ClassesRoot.CreateSubKey("ArdaViewer.tga"))
                {
                    myKey?.SetValue("", "TGA");
                    RegistryKey shell = myKey?.CreateSubKey("shell");
                    shell = shell?.CreateSubKey("open");
                    shell?.CreateSubKey("command").SetValue("", "\"" + Application.ExecutablePath + "\" \"" + "%1\"");
                }

                MessageBox.Show("Restart might be required for changes to take full effect.");
            }
            catch
            {
                MessageBox.Show("This action requires Registry Write Permission. Try running the application with administrator privileges and try again.");
            }
            finally
            {
                System.Security.Permissions.RegistryPermission.RevertAssert();
            }
        }
示例#5
0
        private void InstallLink()
        {
            DebugWriteLine("Problem: InstallLink");
            MessageBox.Show("Please nagivate to your Leaguesharp folder and select your loader.exe");
            OpenFileDialog loaderdialog = new OpenFileDialog
            {
                Multiselect     = false,
                AddExtension    = true,
                CheckFileExists = true,
                CheckPathExists = true,
                DefaultExt      = ".exe",
                Title           = "Please select your Loader.exe"
            };

            loaderdialog.ShowDialog();
            string loaderPath = loaderdialog.FileName;

            DebugWriteLine("Selected loader path " + loaderPath);

            DebugWriteLine("Deleting old reg key");
            string[] subKeys = Registry.ClassesRoot.GetSubKeyNames();
            if (subKeys.Contains("ls"))
            {
                Registry.ClassesRoot.DeleteSubKeyTree("ls");
            }
            DebugWriteLine("Adding level 0 ls reg key");
            //level 0 ls
            RegistryKey baseKey = Registry.ClassesRoot.CreateSubKey("ls");

            baseKey?.SetValue(null, "URL:Custom Protocol", RegistryValueKind.String);
            baseKey?.SetValue("URL Protocol", "");
            DebugWriteLine("Adding level 1 stdIcon reg key");
            //level 1 stdIcon
            RegistryKey stdIcon = baseKey?.CreateSubKey("DefaultIcon");

            stdIcon?.SetValue(null, loaderPath + ",0", RegistryValueKind.String);
            DebugWriteLine("Adding level 1 shell reg key");
            //level 1 shell
            RegistryKey shell = baseKey?.CreateSubKey("shell");

            DebugWriteLine("Adding level 2 open reg key");
            //level 2 open
            RegistryKey open = shell?.CreateSubKey("open");

            open?.SetValue(null, "\"" + loaderPath + "\" \",%1\"", RegistryValueKind.String);
            DebugWriteLine("Adding level 3 command reg key");
            //level 3 command
            RegistryKey command = open?.CreateSubKey("command");

            command?.SetValue(null, "\"" + loaderPath + "\" \"%1\"", RegistryValueKind.String);

            DebugWriteLine("InstallLink fix done");
            DebugWriteLine("Exitcode 0");
        }
示例#6
0
        /// <summary>
        ///		Asocia una extensión con un ejecutable y una acción
        /// </summary>
        public void LinkExtension(string extension, string executableFileName, string programId,
                                  string command = "open", string description = "")
        {
            string      linkedProgramID;
            RegistryKey registryKey      = null;
            RegistryKey registryKeyShell = null;

            // El comando predeterminado es open
            if (string.IsNullOrEmpty(command))
            {
                command = "open";
            }
            // Obtiene la descripción
            if (string.IsNullOrEmpty(description))
            {
                description = $"{extension} Descripción de {programId}";
            }
            // Normaliza la extensión
            extension = NormalizeExtension(extension);
            // Obtiene el ID del programa a partir de la extensión
            linkedProgramID = GetProgIdFromExtension(extension);
            // Si no hay nada asociado, se crean las claves, si hay algo asociado se modifican
            if (string.IsNullOrEmpty(linkedProgramID) || linkedProgramID.Length == 0)
            {
                // Crear la clave con la extensión
                registryKey = Registry.ClassesRoot.CreateSubKey(extension);
                registryKey?.SetValue("", programId);
                // Crea la clave con el programa
                registryKey = Registry.ClassesRoot.CreateSubKey(programId);
                registryKey?.SetValue("", description);
                // Crea la clave con el comando
                registryKeyShell = registryKey?.CreateSubKey($"shell\\{command}\\command");
            }
            else
            {
                // Abrimos la clave clave indicando que vamos a escribir para que nos permita crear nuevas subclaves.
                registryKey      = Registry.ClassesRoot.OpenSubKey(linkedProgramID, true);
                registryKeyShell = registryKey?.OpenSubKey($"shell\\{command}\\command", true);
                // Si es un comando que se añade, no existirá
                if (registryKeyShell == null)
                {
                    registryKeyShell = registryKey?.CreateSubKey(programId);
                }
            }
            // Si tenemos la clave de registro del Shell
            if (registryKeyShell != null)
            {
                registryKeyShell.SetValue("", $"\"{executableFileName}\" \"%1\"");
                registryKeyShell.Close();
            }
        }
示例#7
0
        /// <summary>
        /// Sets the registry key to associat .james files
        /// </summary>
        public static void AssociateFileExtension()
        {
            if (Config.Instance.FirstInstance)
            {
                string      executablePath = Config.WorkflowFolderLocation + "\\James.exe";
                string      iconPath       = Config.WorkflowFolderLocation + "\\Resources\\logo2.ico";
                RegistryKey FileReg        = Registry.CurrentUser.CreateSubKey("Software\\Classes\\.james");
                Registry.CurrentUser.CreateSubKey("Software\\Classes\\Applicatons\\MyNotepad.exe");
                Registry.CurrentUser.CreateSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FileExts\\.james");

                FileReg?.CreateSubKey("DefaultIcon")?.SetValue("", iconPath);
                FileReg?.CreateSubKey("shell\\open\\command")?.SetValue("", $"\"{executablePath}\" %1");
            }
        }
        public void SaveLastPage(string userName, int page)
        {
            RegistryKey masterKey = null;

            try
            {
                masterKey = Registry.CurrentUser.CreateSubKey(MASTER_REG_KEY);

                RegistryKey userKey = masterKey?.CreateSubKey($"{SAVED_USERS_SUB_KEY}\\{userName}");
                if (userKey == null)
                {
                    return;
                }

                userKey.SetValue("LastPage", page);
            }
            catch (Exception ex)
            {
                Trace.WriteError("Saving user info to registry failed", Trace.GetMethodName(), CLASSNAME, ex);
            }
            finally
            {
                masterKey?.Close();
            }
        }
示例#9
0
        internal static void ConfigurateRegistry()
        {
            string      fileName      = Process.GetCurrentProcess().MainModule.ModuleName;
            string      cacheFilePath = $@"{Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData)}\Package Cache\{GUID}\{fileName}";
            RegistryKey registryKey   = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall", true);
            var         key           = registryKey?.CreateSubKey(GUID);

            if (key != null)
            {
                key.SetValue("ApplicationPath", viewModel.InstallFolderPath);
                key.SetValue("BundleCachePath", $@"{cacheFilePath} ");
                key.SetValue("BundleProviderKey", GUID);
                key.SetValue("BundleVersion", "1.0.0.0");
                key.SetValue("DisplayIcon", $@"{cacheFilePath} ,0");
                key.SetValue("DisplayName", ApplicationName);
                key.SetValue("DisplayVersion", Settings.Version);
                key.SetValue("EstimatedSize", EstimatedSize);
                key.SetValue("Installed", 1);
                key.SetValue("NoElevateOnModify", 1);
                key.SetValue("Publisher", Manufacturer);
                key.SetValue("QuietUninstallString", 1);
                key.SetValue("UninstallString", $"{cacheFilePath} /uninstall");
                key.SetValue("URLInfoAbout", SupportUrl);
            }
        }
示例#10
0
        public RegistryConfiguration()
        {
            var app = Assembly.GetExecutingAssembly().GetName().Name;

            _software = Registry.CurrentUser.OpenSubKey("Software", true);

            _key = _software?.CreateSubKey(app);
        }
        public static void Create(string key, CpuPriorityLevel priorityLevel)
        {
            RegistryKey subKey      = WorkingKey.CreateSubKey(key);
            RegistryKey perfOptions = subKey?.CreateSubKey("PerfOptions");

            perfOptions?.SetValue("CpuPriorityClass", priorityLevel, RegistryValueKind.DWord);
            perfOptions?.Close();
        }
        public static void WriteExecutionLocation()
        {
            RegistryKey key = Registry.LocalMachine.OpenSubKey("Software", true);

            key?.CreateSubKey("NetworkGameCopier");
            key = key?.OpenSubKey("NetworkGameCopier", true);

            key?.SetValue("InstalledPath", Path.GetFullPath("."));
        }
示例#13
0
        public RegistryKey CreateRegKey(string regKeyName = "")
        {
            if (string.IsNullOrEmpty(regKeyName))
            {
                regKeyName = _regKey;
            }
            else
            {
                regKeyName = $"{this._regKey}\\{regKeyName}";
            }

            // creazione chiave
            _baseKey?.CreateSubKey(regKeyName ?? "", RegistryKeyPermissionCheck.ReadWriteSubTree)?.Close();

            // apertura con permessi per modifica permesssi
            RegistryKey key = _baseKey?.OpenSubKey(
                regKeyName,
                RegistryKeyPermissionCheck.ReadWriteSubTree,
                RegistryRights.ChangePermissions | RegistryRights.ReadKey | RegistryRights.WriteKey |
                RegistryRights.FullControl
                );

            // permessi da applicare
            RegistryRights acl = RegistryRights.WriteKey | RegistryRights.ReadKey | RegistryRights.Delete;

            // attuale policy
            if (EnvironmentUtils.IsWin())
            {
                try
                {
                    RegistrySecurity regSec = key?.GetAccessControl();

                    // aggiunta policy all'attuale
                    regSec?.AddAccessRule(
                        new RegistryAccessRule(
                            $"{Environment.UserDomainName}\\{Environment.UserName}",
                            acl,
                            InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit,
                            PropagationFlags.InheritOnly,
                            AccessControlType.Allow
                            )
                        );

                    // definizione proprietario
                    regSec?.SetOwner(new NTAccount($"{Environment.UserDomainName}\\{Environment.UserName}"));

                    // applicazione della policy
                    key?.SetAccessControl(regSec);
                }
                catch
                {
                    // ignore
                }
            }

            return(key);
        }
示例#14
0
 /// <summary>
 /// Defines a new custom url protocol for james
 /// </summary>
 public static void RegisterCustomProtocol()
 {
     if (Config.Instance.FirstInstance)
     {
         string      executablePath = Config.WorkflowFolderLocation + "\\James.exe";
         RegistryKey reg            = Registry.CurrentUser.CreateSubKey("Software\\Classes\\james");
         reg?.SetValue("URL PROTOCOL", "");
         reg?.CreateSubKey("shell\\open\\command")?.SetValue("", $"\"{executablePath}\" \"%1\"");
     }
 }
        public void LinkExtension(string extension, string executableFileName, string programId, string command, string description)
        {
            string      linkedProgramID;
            RegistryKey registryKey      = null;
            RegistryKey registryKeyShell = null;

            if (string.IsNullOrEmpty(command))
            {
                command = EngineData.Comando;
            }
            if (string.IsNullOrEmpty(description))
            {
                description = $"{extension} Descripción de {programId}";
            }
            if (!extension.StartsWith("."))
            {
                extension = "." + extension;
            }

            linkedProgramID = GetProgIdFromExtension(extension);
            if (string.IsNullOrEmpty(linkedProgramID) || linkedProgramID.Length == 0)
            {
                registryKey = Registry.ClassesRoot.CreateSubKey(extension);
                registryKey?.SetValue(string.Empty, programId);
                registryKey = Registry.ClassesRoot.CreateSubKey(programId);
                registryKey?.SetValue(string.Empty, description);
                registryKeyShell = registryKey?.CreateSubKey($"shell\\{command}\\command");
            }
            else
            {
                registryKey      = Registry.ClassesRoot.OpenSubKey(linkedProgramID, true);
                registryKeyShell = registryKey?.OpenSubKey($"shell\\{command}\\command", true);
                if (registryKeyShell == null)
                {
                    registryKeyShell = registryKey?.CreateSubKey(programId);
                }
            }
            if (registryKeyShell != null)
            {
                registryKeyShell.SetValue(string.Empty, $"\"{executableFileName}\" \"%1\"");
                registryKeyShell.Close();
            }
        }
示例#16
0
        public void setValue <T>(RegistryHive hive, string subKey, string valueName, T value, RegistryValueKind kind)
            where T : struct
        {
            RegistryKey basekey = RegistryKey.OpenBaseKey(hive, this.registryView);
            RegistryKey subkey  = basekey?.OpenSubKey(subKey, true);

            if (subkey == null)
            {
                subkey = basekey?.CreateSubKey(subKey, true);
            }
            subkey?.SetValue(valueName, value, kind);
        }
示例#17
0
        private static void RegisterReloadedProtocol()
        {
            // Get the user classes subkey.
            var classesSubKey = Registry.CurrentUser.OpenSubKey("Software", true)?.OpenSubKey("Classes", true);

            // Add a Reloaded Key.
            RegistryKey reloadedProtocolKey = classesSubKey?.CreateSubKey($"{Constants.ReloadedProtocol}");

            reloadedProtocolKey?.SetValue("", $"URL:{Constants.ReloadedProtocol}");
            reloadedProtocolKey?.SetValue("URL Protocol", "");
            reloadedProtocolKey?.CreateSubKey(@"shell\open\command")?.SetValue("", $"\"{Path.ChangeExtension(Assembly.GetExecutingAssembly().Location, ".exe")}\" {Constants.ParameterDownload} %1");
        }
示例#18
0
        /// <summary>
        /// Registers Reloaded Mod Loader as an URL handler for the reloaded:// protocol, allowing
        /// those links to be redirected to Reloaded for purposes such as GameBanana's 1 click mod installs.
        /// </summary>
        private static void SetupURLHandler()
        {
            // Get the user classes subkey.
            var classesSubKey = Registry.CurrentUser.OpenSubKey("Software", true)?.OpenSubKey("Classes", true);

            // Add a Reloaded Key.
            RegistryKey reloadedProtocolKey = classesSubKey?.CreateSubKey($"{Strings.Launcher.ReloadedProtocolName}");

            reloadedProtocolKey?.SetValue("", $"URL:{Strings.Launcher.ReloadedProtocolName}");
            reloadedProtocolKey?.SetValue("URL Protocol", "");
            reloadedProtocolKey?.CreateSubKey(@"shell\open\command")?.SetValue("", $"\"{Assembly.GetExecutingAssembly().Location}\" --download %1");
        }
        /// <summary>
        /// Adds registry entries to prevent ListDLL nag screens
        /// </summary>
        private static void FixRegistryNagOnListDlls()
        {
            try
            {
                RegistryKey key = Registry.CurrentUser.OpenSubKey("Software", true);

                key?.CreateSubKey("Sysinternals");
                key = key?.OpenSubKey("Sysinternals", true);

                key?.CreateSubKey("ListDLLs");
                key = key?.OpenSubKey("ListDLLs", true);

                key?.SetValue("EulaAccepted", 1);

                key?.Close();
            }
            catch (Exception ex)
            {
                Logger.Warn("Error trying to create registry keys, this is not critical.");
                Logger.Warn(ex.Message);
            }
        }
        public void Register(string exePath, string iconPath)
        {
            using (RegistryKey shellKey = Registry.ClassesRoot.OpenSubKey("Directory\\shell", true))
            {
                RegistryKey keyFolder = shellKey?.CreateSubKey(KeyFolderName);
                if (keyFolder == null)
                {
                    return;
                }

                keyFolder.SetValue("Icon", iconPath);
                keyFolder.CreateSubKey("command").SetValue("", exePath + " " + FilterDirPathArgName + "=\"%1\"");
            }
        }
示例#21
0
        /// <summary>
        /// Check if mailpassword exists in registry
        /// </summary>
        /// <returns></returns>
        public bool CheckPasswordExists()
        {
            RegistryKey pswd = Registry.CurrentUser.OpenSubKey("Software", true);

            pswd?.CreateSubKey("Bestellsoftware");
            pswd = pswd?.OpenSubKey("Bestellsoftware");
            if (pswd?.GetValue("Passwort") == null)
            {
                pswd?.Close();
                return(false);
            }
            pswd.Close();
            return(true);
        }
示例#22
0
        //Редактирование реестра
        static void Main(string[] args)
        {
            //Совершаем навигацию в нужное место и открываем его для записи.
            RegistryKey currentUserKey = Registry.CurrentUser;
            RegistryKey softwareKey    = currentUserKey.OpenSubKey("Software", true);
            RegistryKey testFolderKey  = softwareKey?.CreateSubKey("TestFolder");

            //Совершаем запись в реестр
            testFolderKey?.SetValue("TheStringName", "I contain string value");
            testFolderKey?.SetValue("TheInt32Name", 1234567890); //REG_DWORD - двойное машинное слово (4 байта)

            //Тип можно указать явно
            testFolderKey?.SetValue("AnotherName", 1234567890, RegistryValueKind.String);

            softwareKey?.Close();
        }
示例#23
0
        private void InstallSystemRegistry()
        {
            RegistryKey systemKey        = defaultKey?.CreateSubKey("runassystem", RegistryKeyPermissionCheck.ReadWriteSubTree);
            RegistryKey systemKeyCommand = systemKey?.CreateSubKey("command");

            try
            {
                systemKey?.SetValue("", runAsSystemNameTextBox.Text);
            }
            catch
            {
                // ignored
            }
            try
            {
                if (runAsSystemIconTextBox.Text != String.Empty)
                {
                    systemKey?.SetValue("icon", Path.Combine(IcoDirectory, @"System\System.ico"));
                }
                else
                {
                    systemKey?.DeleteValue("icon");
                }
            }
            catch
            {
                // ignored
            }
            try
            {
                systemKeyCommand?.SetValue("", $"C:\\Windows\\{(IntPtr.Size >= 8 ? "PsExec64.exe" : "PsExec.exe")} -d -i -s \"%1\" %*");
            }
            catch
            {
                // ignored
            }
            systemKey?.Close();
        }
示例#24
0
    private void loadConfig()
    {
        rootKey = Microsoft.Win32.Registry.CurrentUser;
        softwareKey = rootKey.CreateSubKey (@"SOFTWARE\Mono.mLedMatrix");

        led_matrix_address = (string)softwareKey.GetValue("ip_address","192.168.0.222");
        led_matrix.setAddress(led_matrix_address);

        winamp.winamp_address = (string)softwareKey.GetValue("winamp_address","localhost");
        winamp.winamp_port = (int)softwareKey.GetValue("winamp_port",4800);
        winamp.winamp_pass = (string)softwareKey.GetValue("winamp_pass","pass");
        entry_winamp_address.Text = winamp.winamp_address;
        entry_winamp_port.Text = winamp.winamp_port.ToString();
        entry_winamp_pass.Text = winamp.winamp_pass;
        entry_mpd.Text = (string)softwareKey.GetValue("mpd_address","localhost");

        entry_address.Text = led_matrix_address;
        led_matrix.scroll_speed = (int)softwareKey.GetValue("scroll_speed",10);
        hscale_shift_speed.Value = led_matrix.scroll_speed;
        //entry_static_text.Text = (string)softwareKey.GetValue("static_text")
    }
示例#25
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="hklm"></param>
 /// <param name="key"></param>
 /// <param name="name"></param>
 /// <param name="value"></param>
 public static void SetREGSZRegKey(RegistryKey hklm, string key, string name, string value)
 {
   try
   {
     using (RegistryKey subkey = hklm.CreateSubKey(key))
     {
       if (subkey != null)
       {
         subkey.SetValue(name, value);
       }
     }
   }
   catch (SecurityException)
   {
     Log.Error(@"User does not have sufficient rights to modify registry key HKLM\{0}", key);
   }
   catch (UnauthorizedAccessException)
   {
     Log.Error(@"User does not have sufficient rights to modify registry key HKLM\{0}", key);
   }
 }
示例#26
0
        public static void RegisterFunction(Type type)
        {
            string PATH     = System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase.Replace("\\", "/");
            string ASSM     = Assembly.GetExecutingAssembly().FullName;
            int    startPos = ASSM.ToLower().IndexOf("version=") + "version=".Length;
            int    len      = ASSM.ToLower().IndexOf(",", startPos) - startPos;
            string VER      = ASSM.Substring(startPos, len);
            string GUID     = "{" + type.GUID.ToString().ToUpper() + "}";
            string NAME     = type.Namespace + "." + type.Name;
            string BASE     = @"Classes\" + NAME;
            string CLSID    = @"Classes\CLSID\" + GUID;

            // open the key
            RegistryKey CU = Registry.CurrentUser.OpenSubKey("Software", true);

            // is this version registred?
            RegistryKey key = CU.OpenSubKey(CLSID + @"\InprocServer32\" + VER);

            if (key == null)
            {
                // The version of this class currently being registered DOES NOT
                // exist in the registry - so we will now register it

                // BASE KEY
                // HKEY_CURRENT_USER\CLASSES\{NAME}
                key = CU.CreateSubKey(BASE);
                key.SetValue("", NAME);

                // HKEY_CURRENT_USER\CLASSES\{NAME}\CLSID}
                key = CU.CreateSubKey(BASE + @"\CLSID");
                key.SetValue("", GUID);

                // CLSID
                // HKEY_CURRENT_USER\CLASSES\CLSID\{GUID}
                key = CU.CreateSubKey(CLSID);
                key.SetValue("", NAME);

                // HKEY_CURRENT_USER\CLASSES\CLSID\{GUID}\Implemented Categories
                key = CU.CreateSubKey(CLSID + @"\Implemented Categories").CreateSubKey("{62C8FE65-4EBB-45e7-B440-6E39B2CDBF29}");

                // HKEY_CURRENT_USER\CLASSES\CLSID\{GUID}\InProcServer32
                key = CU.CreateSubKey(CLSID + @"\InprocServer32");
                key.SetValue("", @"c:\Windows\SysWow64\mscoree.dll");
                key.SetValue("ThreadingModel", "Both");
                key.SetValue("Class", NAME);
                key.SetValue("CodeBase", PATH);
                key.SetValue("Assembly", ASSM);
                key.SetValue("RuntimeVersion", "v4.0.30319");

                // HKEY_CURRENT_USER\CLASSES\CLSID\{GUID}\InProcServer32\{VERSION}
                key = CU.CreateSubKey(CLSID + @"\InprocServer32\" + VER);
                key.SetValue("Class", NAME);
                key.SetValue("CodeBase", PATH);
                key.SetValue("Assembly", ASSM);
                key.SetValue("RuntimeVersion", "v4.0.30319");

                // HKEY_CURRENT_USER\CLASSES\CLSID\{GUID}\ProgId
                key = CU.CreateSubKey(CLSID + @"\ProgId");
                key.SetValue("", NAME);

                // HKEY_CURRENT_USER\CLASSES\CLSID\{GUID}\Progammable
                key = CU.CreateSubKey(CLSID + @"\Programmable");

                // now register the addin in the addins sub keys for each version of Office
                foreach (string keyName in Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Office\").GetSubKeyNames())
                {
                    if (IsVersionNum(keyName))
                    {
                        // if the adding i found in the Add-in Manager - remove it
                        key = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Office\" + keyName + @"\Excel\Add-in Manager", true);
                        if (key != null)
                        {
                            key.SetValue(NAME, "");
                        }
                    }
                }
                if (!fVstoRegister)
                {
                    // all done - this just helps to assure REGASM is complete
                    // this is not needed, but is useful for troubleshooting
                    MessageBox.Show("Registered " + NAME + ".");
                }
            }
        }
示例#27
0
    private void load_config()
    {
        int i;

        rootKey = Microsoft.Win32.Registry.CurrentUser;
        softwareKey = rootKey.CreateSubKey (@"SOFTWARE\Mono.mLedMatrix\lines");
        i=0;
        foreach(string key in softwareKey.GetSubKeyNames())
        {
            string name,code,rss;
            bool active,loop;
            int num, time;
            RegistryKey tempkey;
            tempkey = rootKey.CreateSubKey (@"SOFTWARE\Mono.mLedMatrix\lines\"+key);

            num = (int)tempkey.GetValue("num",0);
            time = (int)tempkey.GetValue("time",0);
            loop = (string)tempkey.GetValue("loop","True") == "True";
            name = (string)tempkey.GetValue("name","");
            code = (string)tempkey.GetValue("code","");
            rss = (string)tempkey.GetValue("rss","");
            active = (string)tempkey.GetValue("active","True") == "True";
            user_lines.Add(new userLine(name,active,code,rss,num,loop,time));
            Console.WriteLine(key);
            i++;
        }
        if(i==0)
        {
            user_lines.Add(new userLine("Spiegel.de",false,"%c%r%8%h:%m:%s%n%g%-%R"
                ,"http://www.spiegel.de/index.rss",i++,true,10));
            user_lines.Add(new userLine("kicker.de",false,"%c%r%8%h:%m:%s%n%g%-%R"
                ,"http://rss.kicker.de/live/bundesliga",i++,true,10));
            user_lines.Add(new userLine("Uhrzeit",true,"%2%+%+%c%r%h:%m:%s"
                ,"",i++,true,10));
            user_lines.Add(new userLine("Wetter",false,"%c%r%8%h:%m:%s%n%g%-%R"
                ,"http://wetter.bjoern-b.de/daten.xml",i++,true,10));
            user_lines.Add(new userLine("Musik+Uhr",false,"%c%r%h:%m:%s%n%-%g%a %o- %g%t"
                ,"http://wetter.bjoern-b.de/daten.xml",i++,true,10));
            user_lines.Add(new userLine("Musik",false,"%r%a %o- %g%t"
                ,"http://wetter.bjoern-b.de/daten.xml",i++,true,10));
            user_lines.Add(new userLine("Weihnachten",false,"%+%+%g%2%T%1%c%+%-%-%-%-%rFrohe%2      %g%+%+%+%T%n%r%1%c%-%-%-%-Weihnachten"
                ,"",i++,false,10));

        }
        user_lines.Sort();
    }
示例#28
0
        public static void RegisterControl(Type t, int iconResourceIndex = 101)
        {
            try
            {
                if (t == null)
                {
                    throw new ArgumentNullException(nameof(t));
                }

                if (!typeof(Control).IsAssignableFrom(t))
                {
                    throw new ArgumentException("Type argument must be a Windows Forms control.");
                }


                string key = $"CLSID\\{t.GUID:B}";

                using (RegistryKey registryKey = Registry.ClassesRoot.OpenSubKey(key, true))
                {
                    // InprocServer32

                    using (RegistryKey inprocServerKey = registryKey?.OpenSubKey("InprocServer32", true))
                    {
                        //Override the default value - to make sure that the applications will be able to locate the DLL
                        inprocServerKey?.SetValue(null, $@"{Environment.SystemDirectory}\mscoree.dll");
                        // Create the CodeBase entry - needed if not string named and GACced.
                        inprocServerKey?.SetValue("CodeBase", t.Assembly.CodeBase);
                    }

                    // Control
                    // Create the 'Control' key - this allows our control to show up in
                    // the ActiveX control container
                    RegistryKey controlKey = registryKey?.CreateSubKey("Control");
                    controlKey?.Close();

                    // MiscStatus
                    using (RegistryKey miscKey = registryKey?.CreateSubKey("MiscStatus"))
                    {
                        const int miscStatusValue = OLEMISC_RECOMPOSEONRESIZE
                                                    + OLEMISC_CANTLINKINSIDE
                                                    + OLEMISC_INSIDEOUT
                                                    + OLEMISC_ACTIVATEWHENVISIBLE
                                                    + OLEMISC_SETCLIENTSITEFIRST;

                        miscKey?.SetValue("", miscStatusValue.ToString(), RegistryValueKind.String);
                    }

                    // ToolBoxBitmap32
                    using (RegistryKey bitmapKey = registryKey?.CreateSubKey("ToolboxBitmap32"))
                    {
                        bitmapKey?.SetValue("", $"{t.Assembly.Location}, {iconResourceIndex}",
                                            RegistryValueKind.String);
                    }

                    // TypeLib
                    using (RegistryKey typeLibKey = registryKey?.CreateSubKey("TypeLib"))
                    {
                        Guid libId = Marshal.GetTypeLibGuidForAssembly(t.Assembly);
                        typeLibKey?.SetValue("", libId.ToString("B"), RegistryValueKind.String);
                    }

                    // Version
                    using (RegistryKey versionKey = registryKey?.CreateSubKey("Version"))
                    {
                        int major, minor;
                        Marshal.GetTypeLibVersionForAssembly(t.Assembly, out major, out minor);
                        versionKey?.SetValue("", $"{major}.{minor}");
                    }
                }

                EventLogWrapper.Log($"Control registered for {Bitness} applications: {t.FullName}, {key}",
                                    EventLogEntryType.Information, 200);
            }
            catch (Exception ex)
            {
                EventLogWrapper.Log($"Control was not registered: {t.FullName}\n{ex}", EventLogEntryType.Error, 500);
            }
        }
示例#29
0
 public static void RegisterClass(string keyName)
 {
     using (RegistryKey key = Registry.ClassesRoot.OpenSubKey(keyName.Replace(@"HKEY_CLASSES_ROOT\", ""), true))
         key?.CreateSubKey("Control")?.Close();
 }
示例#30
0
        public static bool Add(string extension, string progId, string description, string executable, bool urlHandler = false)
        {
            try
            {
                if (!string.IsNullOrEmpty(extension))
                {
                    if (extension[0] != '.')
                    {
                        extension = "." + extension;
                    }

                    // register the extension, if necessary
                    using (RegistryKey key = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(extension, true))
                    {
                        if (key == null)
                        {
                            using (RegistryKey extKey = Microsoft.Win32.Registry.ClassesRoot.CreateSubKey(extension))
                            {
                                extKey?.SetValue(string.Empty, progId);
                            }
                        }
                        else
                        {
                            key.SetValue(string.Empty, progId);
                        }
                    }
                }

                // register the progId, if necessary
                using (RegistryKey key = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(progId))
                {
                    if (key == null || key.OpenSubKey("shell\\open\\command")?.GetValue(string.Empty).ToString() != $"\"{executable}\" \"%1\"")
                    {
                        using (RegistryKey progIdKey = Microsoft.Win32.Registry.ClassesRoot.CreateSubKey(progId))
                        {
                            if (progIdKey != null)
                            {
                                progIdKey.SetValue(string.Empty, description);
                                if (urlHandler)
                                {
                                    progIdKey.SetValue("URL Protocol", string.Empty);
                                }

                                using (RegistryKey command = progIdKey.CreateSubKey("shell\\open\\command"))
                                {
                                    command?.SetValue(string.Empty, $"\"{executable}\" \"%1\"");
                                }

                                using (RegistryKey command = progIdKey.CreateSubKey("DefaultIcon"))
                                {
                                    command?.SetValue(string.Empty, $"\"{executable}\",1");
                                }
                            }
                        }
                    }
                    // Add new icon for existing osu! users anyway
                    else if (key.OpenSubKey("DefaultIcon")?.GetValue(string.Empty) == null)
                    {
                        using (RegistryKey progIdKey = Microsoft.Win32.Registry.ClassesRoot.CreateSubKey(progId))
                        {
                            using (RegistryKey command = progIdKey?.CreateSubKey("DefaultIcon"))
                            {
                                command?.SetValue(string.Empty, $"\"{executable}\",1");
                            }
                        }
                    }
                }
            }
            catch
            {
                return(false);
            }

            return(true);
        }
示例#31
0
    private bool treemode_foreach_func(Gtk.TreeModel model, Gtk.TreePath path,
		Gtk.TreeIter iter)
    {
        rootKey = Microsoft.Win32.Registry.CurrentUser;
        softwareKey = rootKey.CreateSubKey (@"SOFTWARE\Mono.mLedMatrix\lines");

        userLine line = (userLine)model.GetValue(iter,0);
        softwareKey = rootKey.CreateSubKey (@"SOFTWARE\Mono.mLedMatrix\lines\"+line.m_name);
        softwareKey.SetValue("name",line.m_name);
        softwareKey.SetValue("code",line.m_code);
        softwareKey.SetValue("active",line.m_active);
        softwareKey.SetValue("rss",line.m_rss_url);
        softwareKey.SetValue("loop",line.m_loop);
        softwareKey.SetValue("time",line.m_time);
        softwareKey.SetValue("num",line.m_number);
        return false; // run loop further
    }
示例#32
0
        public void Install()
        {
            Console.WriteLine("Starting installation");
            Console.WriteLine($"Installing: {Info.CurrentInstallingModVersion.Name}");
            Console.WriteLine($"To: {Info.CurrentGamePath}");
            OnStart?.Invoke();
            try {
                if (Info.CurrentInstalledModVersion != null)
                {
                    _Restore();
                    Console.WriteLine();
                }

                _Backup();
                Console.WriteLine();

                _DownloadAndUnpack();
                Console.WriteLine();

                // Sneaky step: Copy the installer.
                string installerPath = null;
                try {
                    string installerTmpPath = Assembly.GetEntryAssembly().Location;
                    installerPath = Path.Combine(Info.CurrentGamePath, Path.GetFileName(installerTmpPath));
                    File.Copy(installerTmpPath, installerPath, true);
                } catch {
                }
                // Sneaky step: Set up URI handler.
                if (!string.IsNullOrEmpty(Info.ModURIProtocol) &&
                    !string.IsNullOrEmpty(Info.ModsDir))
                {
                    try {
                        RegistryKey regClasses = Registry
                                                 .CurrentUser
                                                 ?.OpenSubKey("Software", true)
                                                 ?.OpenSubKey("Classes", true);
                        RegistryKey regProtocol = regClasses?.CreateSubKey(Info.ModURIProtocol);
                        if (regProtocol != null)
                        {
                            regProtocol.SetValue("", $"URL:{Info.ModURIProtocol}");
                            regProtocol.SetValue("URL Protocol", "");
                            regProtocol.CreateSubKey(@"shell\open\command").SetValue("", $"\"{installerPath}\" %1");
                        }
                    } catch {
                    }
                }

                _Install();
                Console.WriteLine();
            } catch (Exception e) {
                Console.WriteLine($"Failed installing {Info.CurrentInstallingModVersion.Name}");
                Console.WriteLine(e);
                Console.WriteLine("Error! Please check installer-log.txt");
                OnError?.Invoke(e);
                if (Debugger.IsAttached)
                {
                    throw;
                }
                return;
            }
            Console.WriteLine("Finished installing!");
            Console.WriteLine();
            OnFinish?.Invoke();
        }
示例#33
0
        public static void SaveSettings()
        {
            try
            {
                PlatformID ptId = DetectOS.GetRealPlatformID();

                switch (ptId)
                {
                case PlatformID.MacOSX:
                case PlatformID.iOS:
                {
                    var root = new NSDictionary
                    {
                        {
                            "TemporaryFolder", Current.TemporaryFolder
                        },
                        {
                            "DatabasePath", Current.DatabasePath
                        },
                        {
                            "RepositoryPath", Current.RepositoryPath
                        },
                        {
                            "UnArchiverPath", Current.UnArchiverPath
                        },
                        {
                            "CompressionAlgorithm", Current.CompressionAlgorithm.ToString()
                        },
                        {
                            "UseAntivirus", Current.UseAntivirus
                        },
                        {
                            "UseClamd", Current.UseClamd
                        },
                        {
                            "ClamdHost", Current.ClamdHost
                        },
                        {
                            "ClamdPort", Current.ClamdPort
                        },
                        {
                            "ClamdIsLocal", Current.ClamdIsLocal
                        },
                        {
                            "UseVirusTotal", Current.UseVirusTotal
                        },
                        {
                            "VirusTotalKey", Current.VirusTotalKey
                        }
                    };

                    string preferencesPath =
                        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Library",
                                     "Preferences");

                    string preferencesFilePath =
                        Path.Combine(preferencesPath, "com.claunia.museum.apprepodbmgr.plist");

                    var fs = new FileStream(preferencesFilePath, FileMode.Create);
                    BinaryPropertyListWriter.Write(fs, root);
                    fs.Close();
                }

                break;

                case PlatformID.Win32NT:
                case PlatformID.Win32S:
                case PlatformID.Win32Windows:
                case PlatformID.WinCE:
                case PlatformID.WindowsPhone:
                {
                    RegistryKey parentKey = Registry.CurrentUser.OpenSubKey("SOFTWARE", true)?.
                                            CreateSubKey("Canary Islands Computer Museum");

                    RegistryKey key = parentKey?.CreateSubKey("AppRepoDBMgr");

                    if (key != null)
                    {
                        key.SetValue("TemporaryFolder", Current.TemporaryFolder);
                        key.SetValue("DatabasePath", Current.DatabasePath);
                        key.SetValue("RepositoryPath", Current.RepositoryPath);

                        if (Current.UnArchiverPath != null)
                        {
                            key.SetValue("UnArchiverPath", Current.UnArchiverPath);
                        }

                        key.SetValue("CompressionAlgorithm", Current.CompressionAlgorithm);
                        key.SetValue("UseAntivirus", Current.UseAntivirus);
                        key.SetValue("UseClamd", Current.UseClamd);
                        key.SetValue("ClamdHost", Current.ClamdHost == null ? "" : Current.ClamdHost);
                        key.SetValue("ClamdPort", Current.ClamdPort);
                        key.SetValue("ClamdIsLocal", Current.ClamdIsLocal);
                        key.SetValue("UseVirusTotal", Current.UseVirusTotal);
                        key.SetValue("VirusTotalKey", Current.VirusTotalKey == null ? "" : Current.VirusTotalKey);
                    }
                }

                break;

                default:
                {
                    string configPath =
                        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".config");

                    string settingsPath = Path.Combine(configPath, "AppRepoDBMgr.xml");

                    if (!Directory.Exists(configPath))
                    {
                        Directory.CreateDirectory(configPath);
                    }

                    var fs = new FileStream(settingsPath, FileMode.Create);
                    var xs = new XmlSerializer(Current.GetType());
                    xs.Serialize(fs, Current);
                    fs.Close();
                }

                break;
                }
            }
            #pragma warning disable RECS0022     // A catch clause that catches System.Exception and has an empty body
            catch
                #pragma warning restore RECS0022 // A catch clause that catches System.Exception and has an empty body
            {
                if (Debugger.IsAttached)
                {
                    throw;
                }
            }
        }
示例#34
0
    private void loadConfig()
    {
        int i;

        rootKey = Microsoft.Win32.Registry.CurrentUser;
        softwareKey = rootKey.CreateSubKey (@"SOFTWARE\Mono.mLedMatrix\lines");
        i=0;
        foreach(string key in softwareKey.GetSubKeyNames())
        {
            string name,code,rss;
            bool active,loop;
            int num, time;
            RegistryKey tempkey;
            tempkey = rootKey.CreateSubKey (@"SOFTWARE\Mono.mLedMatrix\lines\"+key);

            num = (int)tempkey.GetValue("num",0);
            time = (int)tempkey.GetValue("time",0);
            loop = (string)tempkey.GetValue("loop","True") == "True";
            name = (string)tempkey.GetValue("name","");
            code = (string)tempkey.GetValue("code","");
            rss = (string)tempkey.GetValue("rss","");
            active = (string)tempkey.GetValue("active","True") == "True";
            user_lines.Add(new userLine(name,active,code,rss,num,loop,time));
            Console.WriteLine(key);
            i++;
        }
        if(i==0)
        {
            user_lines.Add(new userLine("Spiegel.de",false,"%c%r%8%h:%m:%s%n%g%-%R"
                ,"http://www.spiegel.de/index.rss",user_lines.Count+1,true,10));
            user_lines.Add(new userLine("kicker.de",false,"%c%r%8%h:%m:%s%n%g%-%R"
                ,"http://rss.kicker.de/live/bundesliga",user_lines.Count+1,true,10));
            user_lines.Add(new userLine("Uhrzeit",true,"%2%+%+%c%r%h:%m:%s"
                ,"",user_lines.Count+1,true,10));
            user_lines.Add(new userLine("Wetter",false,"%c%r%8%h:%m:%s%n%g%-%R"
                ,"http://wetter.bjoern-b.de/daten.xml",user_lines.Count+1,true,10));
            user_lines.Add(new userLine("Weihnachten",false,"%+%+%g%2%T%1%c%+%-%-%-%-%rFrohe%2      %g%+%+%+%T%n%r%1%c%-%-%-%-Weihnachten"
                ,"",user_lines.Count+1,false,10));

        }
        user_lines.Sort();
        softwareKey = rootKey.CreateSubKey (@"SOFTWARE\Mono.mLedMatrix");

        led_matrix_address = (string)softwareKey.GetValue("ip_address","192.168.0.222");
        led_matrix.setAddress(led_matrix_address);

        winamp.winamp_address = (string)softwareKey.GetValue("winamp_address","localhost");
        winamp.winamp_port = (int)softwareKey.GetValue("winamp_port",4800);
        winamp.winamp_pass = (string)softwareKey.GetValue("winamp_pass","pass");
        entry_winamp_address.Text = winamp.winamp_address;
        entry_winamp_port.Text = winamp.winamp_port.ToString();
        entry_winamp_pass.Text = winamp.winamp_pass;

        entry_address.Text = led_matrix_address;
        led_matrix.scroll_speed = (int)softwareKey.GetValue("scroll_speed",10);
        hscale_shift_speed.Value = led_matrix.scroll_speed;
        //entry_static_text.Text = (string)softwareKey.GetValue("static_text")
    }
示例#35
0
        public static void SaveSettings()
        {
            try
            {
                PlatformID ptId = DetectOS.GetRealPlatformID();

                switch (ptId)
                {
                // In case of macOS or iOS settings will be saved in ~/Library/Preferences/com.claunia.discimagechef.plist
                case PlatformID.MacOSX:
                case PlatformID.iOS:
                {
                    NSDictionary root = new NSDictionary
                    {
                        { "SaveReportsGlobally", Current.SaveReportsGlobally },
                        { "ShareReports", Current.ShareReports },
                        { "GdprCompliance", Current.GdprCompliance }
                    };
                    if (Current.Stats != null)
                    {
                        NSDictionary stats = new NSDictionary
                        {
                            { "ShareStats", Current.Stats.ShareStats },
                            { "BenchmarkStats", Current.Stats.BenchmarkStats },
                            { "CommandStats", Current.Stats.CommandStats },
                            { "DeviceStats", Current.Stats.DeviceStats },
                            { "FilesystemStats", Current.Stats.FilesystemStats },
                            { "FilterStats", Current.Stats.FilterStats },
                            { "MediaImageStats", Current.Stats.MediaImageStats },
                            { "MediaScanStats", Current.Stats.MediaScanStats },
                            { "PartitionStats", Current.Stats.PartitionStats },
                            { "MediaStats", Current.Stats.MediaStats },
                            { "VerifyStats", Current.Stats.VerifyStats }
                        };
                        root.Add("Stats", stats);
                    }

                    string preferencesPath =
                        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Library",
                                     "Preferences");
                    string preferencesFilePath = Path.Combine(preferencesPath, "com.claunia.discimagechef.plist");

                    FileStream fs = new FileStream(preferencesFilePath, FileMode.Create);
                    BinaryPropertyListWriter.Write(fs, root);
                    fs.Close();
                }
                break;

#if !NETSTANDARD2_0
                // In case of Windows settings will be saved in the registry: HKLM/SOFTWARE/Claunia.com/DiscImageChef
                case PlatformID.Win32NT:
                case PlatformID.Win32S:
                case PlatformID.Win32Windows:
                case PlatformID.WinCE:
                case PlatformID.WindowsPhone:
                {
                    RegistryKey parentKey =
                        Registry.CurrentUser.OpenSubKey("SOFTWARE", true)?.CreateSubKey("Claunia.com");
                    RegistryKey key = parentKey?.CreateSubKey("DiscImageChef");

                    if (key != null)
                    {
                        key.SetValue("SaveReportsGlobally", Current.SaveReportsGlobally);
                        key.SetValue("ShareReports", Current.ShareReports);
                        key.SetValue("GdprCompliance", Current.GdprCompliance);

                        if (Current.Stats != null)
                        {
                            key.SetValue("Statistics", true);
                            key.SetValue("ShareStats", Current.Stats.ShareStats);
                            key.SetValue("BenchmarkStats", Current.Stats.BenchmarkStats);
                            key.SetValue("CommandStats", Current.Stats.CommandStats);
                            key.SetValue("DeviceStats", Current.Stats.DeviceStats);
                            key.SetValue("FilesystemStats", Current.Stats.FilesystemStats);
                            key.SetValue("FilterStats", Current.Stats.FilterStats);
                            key.SetValue("MediaImageStats", Current.Stats.MediaImageStats);
                            key.SetValue("MediaScanStats", Current.Stats.MediaScanStats);
                            key.SetValue("PartitionStats", Current.Stats.PartitionStats);
                            key.SetValue("MediaStats", Current.Stats.MediaStats);
                            key.SetValue("VerifyStats", Current.Stats.VerifyStats);
                        }
                        else
                        {
                            key.SetValue("Statistics", true);
                            key.DeleteValue("ShareStats", false);
                            key.DeleteValue("BenchmarkStats", false);
                            key.DeleteValue("CommandStats", false);
                            key.DeleteValue("DeviceStats", false);
                            key.DeleteValue("FilesystemStats", false);
                            key.DeleteValue("MediaImageStats", false);
                            key.DeleteValue("MediaScanStats", false);
                            key.DeleteValue("PartitionStats", false);
                            key.DeleteValue("MediaStats", false);
                            key.DeleteValue("VerifyStats", false);
                        }
                    }
                }
                break;
#endif
                // Otherwise, settings will be saved in ~/.config/DiscImageChef.xml
                default:
                {
                    string homePath      = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
                    string xdgConfigPath =
                        Path.Combine(homePath,
                                     Environment.GetEnvironmentVariable(XDG_CONFIG_HOME) ??
                                     XDG_CONFIG_HOME_RESOLVED);
                    string settingsPath = Path.Combine(xdgConfigPath, "DiscImageChef.xml");

                    if (!Directory.Exists(xdgConfigPath))
                    {
                        Directory.CreateDirectory(xdgConfigPath);
                    }

                    FileStream    fs = new FileStream(settingsPath, FileMode.Create);
                    XmlSerializer xs = new XmlSerializer(Current.GetType());
                    xs.Serialize(fs, Current);
                    fs.Close();
                }
                break;
                }
            }
            #pragma warning disable RECS0022 // A catch clause that catches System.Exception and has an empty body
            catch
            {
                // ignored
            }
            #pragma warning restore RECS0022 // A catch clause that catches System.Exception and has an empty body
        }