src/TortoiseProc/Settings/SettingsAdvanced.h

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2023 - TortoiseGit
   4 // Copyright (C) 2009-2010, 2015 - TortoiseSVN
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 #pragma once
  21 #include "SettingsPropPage.h"
  22
  23
  24 class CSettingsAdvanced : public ISettingsPropPage
  25 {
  26         DECLARE_DYNAMIC(CSettingsAdvanced)
  27
  28 public:
  29         CSettingsAdvanced();
  30         virtual ~CSettingsAdvanced();
  31
  32         UINT GetIconID() override { return IDI_GENERAL; }
  33
  34 // Dialog Data
  35         enum { IDD = IDD_SETTINGS_CONFIG };
  36
  37         class AdvancedSetting
  38         {
  39         public:
  40                 AdvancedSetting(const wchar_t* sName) noexcept
  41                         : sName(sName)
  42                 {
  43                 }
  44                 virtual ~AdvancedSetting() = default;
  45
  46                 CString GetName() const { return sName; }
  47                 virtual CString GetValue() const = 0;
  48                 virtual bool IsValid(LPCWSTR s) const = 0;
  49                 virtual void StoreValue(const CString& sValue) const = 0;
  50
  51         protected:
  52                 CString GetRegistryPath() const
  53                 {
  54                         return L"Software\\TortoiseGit\\" + GetName();
  55                 }
  56
  57         private:
  58                 CString sName;
  59         };
  60         class StringSetting : public AdvancedSetting
  61         {
  62         public:
  63                 StringSetting(const wchar_t* sName, LPCWSTR defaultValue) noexcept
  64                         : AdvancedSetting(sName)
  65                         , m_defaultValue(defaultValue)
  66                 {
  67                 }
  68
  69                 CString GetValue() const override
  70                 {
  71                         return CRegString(GetRegistryPath(), m_defaultValue);
  72                 }
  73                 bool IsValid(LPCWSTR /*s*/) const override
  74                 {
  75                         return true;
  76                 }
  77                 void StoreValue(const CString& sValue) const override
  78                 {
  79                         CRegString s(GetRegistryPath(), m_defaultValue);
  80                         if (sValue.Compare(static_cast<CString>(s)))
  81                                 s = sValue;
  82                 }
  83
  84         private:
  85                 LPCWSTR m_defaultValue;
  86         };
  87         class BooleanSetting : public AdvancedSetting
  88         {
  89         public:
  90                 BooleanSetting(const wchar_t* sName, bool defaultValue) noexcept
  91                         : AdvancedSetting(sName)
  92                         , m_defaultValue(defaultValue)
  93                 {
  94                 }
  95
  96                 CString GetValue() const override
  97                 {
  98                         return static_cast<DWORD>(CRegDWORD(GetRegistryPath(), m_defaultValue)) ? L"true" : L"false";
  99                 }
 100                 bool IsValid(LPCWSTR pszText) const override
 101                 {
 102                         assert(pszText);
 103                         return (!*pszText ||
 104                                         (wcscmp(pszText, L"true") == 0) ||
 105                                         (wcscmp(pszText, L"false") == 0));
 106                 }
 107                 void StoreValue(const CString& sValue) const override
 108                 {
 109                         CRegDWORD s(GetRegistryPath(), m_defaultValue);
 110                         if (sValue.IsEmpty())
 111                         {
 112                                 s.removeValue();
 113                                 return;
 114                         }
 115
 116                         const DWORD newValue = sValue.Compare(L"true") == 0;
 117                         if (DWORD(s) != newValue)
 118                                 s = newValue;
 119                 }
 120
 121         private:
 122                 bool m_defaultValue = false;
 123         };
 124         class DWORDSetting : public AdvancedSetting
 125         {
 126         public:
 127                 DWORDSetting(const wchar_t* sName, DWORD defaultValue) noexcept
 128                         : AdvancedSetting(sName)
 129                         , m_defaultValue(defaultValue)
 130                 {
 131                 }
 132
 133                 CString GetValue() const override
 134                 {
 135                         CString temp;
 136                         temp.Format(L"%ld", static_cast<DWORD>(CRegDWORD(GetRegistryPath(), m_defaultValue)));
 137                         return temp;
 138                 }
 139                 bool IsValid(LPCWSTR pszText) const override
 140                 {
 141                         assert(pszText);
 142                         const wchar_t* pChar = pszText;
 143                         while (*pChar)
 144                         {
 145                                 if (!_istdigit(*pChar))
 146                                         return false;
 147                                 ++pChar;
 148                         }
 149                         return true;
 150                 }
 151                 void StoreValue(const CString& sValue) const override
 152                 {
 153                         CRegDWORD s(GetRegistryPath(), m_defaultValue);
 154                         if (sValue.IsEmpty())
 155                         {
 156                                 s.removeValue();
 157                                 return;
 158                         }
 159                         if (DWORD(_wtol(sValue)) != DWORD(s))
 160                                 s = _wtol(sValue);
 161                 }
 162
 163         private:
 164                 DWORD m_defaultValue;
 165         };
 166
 167 protected:
 168         void DoDataExchange(CDataExchange* pDX) override;    // DDX/DDV support
 169         BOOL OnApply() override;
 170         BOOL PreTranslateMessage(MSG* pMsg) override;
 171         BOOL OnInitDialog() override;
 172         afx_msg void OnLvnBeginlabeledit(NMHDR *pNMHDR, LRESULT *pResult);
 173         afx_msg void OnLvnEndlabeledit(NMHDR *pNMHDR, LRESULT *pResult);
 174         afx_msg void OnNMDblclkConfig(NMHDR *pNMHDR, LRESULT *pResult);
 175
 176         DECLARE_MESSAGE_MAP()
 177
 178 private:
 179         template<typename T, typename S>
 180         void AddSetting(const wchar_t* sName, S defaultValue)
 181         {
 182                 settings.emplace_back(std::make_unique<T>(sName, defaultValue));
 183         }
 184
 185         CListCtrl               m_ListCtrl;
 186         std::vector<std::unique_ptr<AdvancedSetting>> settings;
 187 };