/[winpt]/trunk/Src/wptPreferencesDlg.cpp
ViewVC logotype

Diff of /trunk/Src/wptPreferencesDlg.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 105 by twoaday, Wed Nov 30 10:22:00 2005 UTC revision 328 by twoaday, Fri Sep 25 16:07:38 2009 UTC
# Line 1  Line 1 
1  /* wptPreferencesDlg.cpp - Dialog for the preferences  /* wptPreferencesDlg.cpp - Dialog for the preferences
2   *      Copyright (C) 2001, 2002, 2003, 2005 Timo Schulz   *      Copyright (C) 2001-2003, 2005-2006, 2008-2009 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
# Line 12  Line 12 
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   * GNU General Public License for more details.   * GNU General Public License for more details.
  *  
  * You should have received a copy of the GNU General Public License  
  * along with WinPT; if not, write to the Free Software Foundation,  
  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA  
15   */   */
16    
17  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
18  #include <config.h>  #include <config.h>
19  #endif  #endif
# Line 41  Line 38 
38    
39  /* Dialog IDs of all hotkeys. */  /* Dialog IDs of all hotkeys. */
40  static int hotkeys[] = {  static int hotkeys[] = {
41      IDC_PREFS_CLIP_ENCRYPT,      /* clipboard based */
42        // FIXME: why the wrong order leads to a correct storing
43        // in the registry!? (2,1) should be (1,2)
44      IDC_PREFS_CLIP_DECRYPT_VERIFY,      IDC_PREFS_CLIP_DECRYPT_VERIFY,
45        IDC_PREFS_CLIP_ENCRYPT,    
46      IDC_PREFS_CLIP_SIGN,      IDC_PREFS_CLIP_SIGN,
47      IDC_PREFS_CLIP_SIGNENC,      IDC_PREFS_CLIP_SIGNENC,
48        /* current window based */
49      IDC_PREFS_CWS_ENCRYPT,      IDC_PREFS_CWS_ENCRYPT,
50      IDC_PREFS_CWS_DECRYPT_VERIFY,      IDC_PREFS_CWS_DECRYPT_VERIFY,
51      IDC_PREFS_CWS_SIGN,      IDC_PREFS_CWS_SIGN,
# Line 55  static int hotkeys[] = { Line 56  static int hotkeys[] = {
56    
57  /* Check that the given hotkey is in A..Z or a..z. */  /* Check that the given hotkey is in A..Z or a..z. */
58  static int  static int
59  check_hotkey (char * key)  check_hotkey (char *key)
60  {  {
61      if (*key >= 'A' && *key <= 'Z')      if (*key >= 'A' && *key <= 'Z')
62          return 1;          return 1;
# Line 72  static void Line 73  static void
73  disable_hotkey_items (HWND dlg, int val)  disable_hotkey_items (HWND dlg, int val)
74  {  {
75      int mode = val? FALSE : TRUE;      int mode = val? FALSE : TRUE;
     int i, id;  
76            
77      for (i=0; (id = hotkeys[i]); i++)      for (int i=0; hotkeys[i] != 0; i++)
78          EnableWindow (GetDlgItem (dlg, id), mode);          EnableWindow (GetDlgItem (dlg, hotkeys[i]), mode);
79  }  }
80    
81    
# Line 91  enable_backup_items (HWND dlg, int val) Line 91  enable_backup_items (HWND dlg, int val)
91      EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKUSER), mode);      EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKUSER), mode);
92      EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), mode);      EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), mode);
93      EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), mode);      EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), mode);
94        EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSECRING), mode);
95  }  }
96    
97    /* Helper function to prepare dialog. */
 /* Initialize the combox in the dialog @dlg with the valid list modes. */  
98  static void  static void
99  init_keylist_modes (HWND dlg)  on_init_dialog (HWND dlg)
100  {  {
101      HWND cb = GetDlgItem (dlg, IDC_PREFS_LISTMODE);      struct gettext_tab_s prefs[] = {
102      combox_add_string (cb, (char *)"NORMAL");          {IDC_PREFS_VIEWER, _("Use clipboard &viewer to display the plaintext")},
103      combox_add_string (cb, (char *)"MINIMAL");          {IDC_PREFS_WWINFO, _("Word wrap cleartext &signatures at column:")},
104      SendMessage (cb, CB_SETCURSEL, (WPARAM)reg_prefs.keylist_mode, 0);          {IDC_PREFS_DISABLE_HOTKEYS, _("&Disable hotkeys (Not recommended!)")},
105  }          {IDC_PREFS_TRUST, _("Skip key validation and assume that keys are always fully trusted")},
106            {IDC_PREFS_AUTOBACKUP, _("&Automatic keyring backup when WinPT closes")},
107            {IDC_PREFS_BAKHOME, _("Backup to &keyring folder")},
108            {IDC_PREFS_BAKUSER, _("Backup to:")},
109            {IDC_PREFS_KEYLISTINF, _("Select &key list mode")},
110            {IDC_PREFS_KSINF, _("Keyserver &config")},
111            {IDC_PREFS_CACHEINF, _("Cache &passphrases for 'n' minutes:")},
112            {IDC_PREFS_CACHEHINT, _("(CTRL+ALT+F to clear the cache)")},
113            {IDC_PREFS_ALLOPTINF, _("General options")},
114            {IDC_PREFS_CLIPINF, _("Clipboard hotkeys CTRL+ALT")},
115            {IDC_PREFS_CURRINF, _("Current window hotkeys CTRL+SHIFT")},
116            {IDC_PREFS_KSELFILE, _("Browse...")},
117            {IDC_PREFS_BAKSELECT, _("Browse...")},
118            {IDC_PREFS_EXTINF, _("Default extension for encrypted files:")},
119            {IDC_PREFS_BAKSECRING, _("&Backup includes secret keyring")},
120            
121            {IDC_PREFS_CLIP_HT_ENC, _("Encrypt")},
122            {IDC_PREFS_CLIP_HT_DEC, _("Decrypt/Verify")},
123            {IDC_PREFS_CLIP_HT_SIG, _("Sign")},
124            {IDC_PREFS_CLIP_HT_SAE, _("Sign && Encrypt")},  
125            {IDC_PREFS_CW_HT_ENC, _("Encrypt")},
126            {IDC_PREFS_CW_HT_DEC, _("Decrypt/Verify")},
127            {IDC_PREFS_CW_HT_SIG, _("Sign")},
128            {IDC_PREFS_CW_HT_SAE, _("Sign && Encrypt")},
129            {IDCANCEL, _("&Cancel")},
130            {0, NULL}};
131        int i;
132        HWND cb;
133    
134        gettext_localize_dialog (dlg, prefs, _("WinPT Preferences"));
135    
136  /* Initialize the combobox in the dialog @dlg with the valid wipe modes. */      SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, reg_prefs.cache_time/60, TRUE);
137  static void      SetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, reg_prefs.word_wrap, TRUE);
138  init_wipe_modes (HWND dlg)      if (reg_prefs.backup.path)
139  {          SetDlgItemText (dlg, IDC_PREFS_BAKPATH, reg_prefs.backup.path);
140      HWND cb = GetDlgItem (dlg, IDC_PREFS_WIPEMODE);          
141      combox_add_string (cb, (char *)"Simple");      for (i=0; hotkeys[i]; i++) {
142      combox_add_string (cb, (char *)"DoD");          if (!wpt_hotkeys[i].enabled)
143      combox_add_string (cb, (char *)"Gutmann");              continue;
144      SendMessage (cb, CB_SETCURSEL, (WPARAM)reg_prefs.wipe_mode, 0);          char key[2];
145            key[0] = wpt_hotkeys[i].key;
146            key[1] = 0;
147            SetDlgItemText (dlg, hotkeys[i], key);
148        }
149        cb = GetDlgItem (dlg, IDC_PREFS_DEFEXT);
150        combox_add_string (cb, "GnuPG (.gpg)");
151        combox_add_string (cb, "PGP   (.pgp)");
152        SendMessage (cb, CB_SETCURSEL, 0, 0);
153    
154        CheckDlgButton (dlg, IDC_PREFS_DISABLE_HOTKEYS,
155                        reg_prefs.no_hotkeys ? BST_CHECKED : BST_UNCHECKED);
156        CheckDlgButton (dlg, IDC_PREFS_VIEWER,
157                        reg_prefs.use_viewer ? BST_CHECKED: BST_UNCHECKED);
158        CheckDlgButton (dlg, IDC_PREFS_TRUST,
159                        reg_prefs.always_trust? BST_CHECKED : BST_UNCHECKED);
160        CheckDlgButton (dlg, IDC_PREFS_AUTOBACKUP,
161                        reg_prefs.auto_backup? BST_CHECKED : BST_UNCHECKED);
162        CheckDlgButton (dlg, IDC_PREFS_BAKHOME,
163                        reg_prefs.backup.mode==1? BST_CHECKED : BST_UNCHECKED);
164        CheckDlgButton (dlg, IDC_PREFS_BAKUSER,
165                        reg_prefs.backup.mode==2? BST_CHECKED : BST_UNCHECKED);
166        CheckDlgButton (dlg, IDC_PREFS_BAKSECRING,
167                        reg_prefs.backup.include_secr? BST_CHECKED :BST_UNCHECKED);
168        SendDlgItemMessage (dlg, IDC_PREFS_DEFEXT, CB_SETCURSEL,
169                            reg_prefs.default_ext, 0);
170        if (reg_prefs.no_hotkeys)
171            disable_hotkey_items (dlg, 1);
172        if (!reg_prefs.auto_backup)
173            enable_backup_items (dlg, 0);
174        EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH),
175                          reg_prefs.backup.mode==1?FALSE : TRUE);
176        EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT),
177                          reg_prefs.backup.mode==1? FALSE : TRUE);
178        center_window (dlg, NULL);    
179        SetForegroundWindow (dlg);
180  }  }
181    
182    
# Line 122  BOOL CALLBACK Line 185  BOOL CALLBACK
185  prefs_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)  prefs_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
186  {  {
187      int rc;      int rc;
188      int i, id;      char t[3];
189      char t[2];      char path[256], *p;
     char path[256], * p;  
     HWND cb;  
190            
191      switch (msg) {      switch (msg) {
192      case WM_INITDIALOG:      case WM_INITDIALOG:
193          SetWindowText (dlg, _("WinPT Preferences"));          on_init_dialog (dlg);
         SetDlgItemText (dlg, IDC_PREFS_SECMODE, _("Do not use any &temporary files"));  
         SetDlgItemText (dlg, IDC_PREFS_VIEWER, _("Use clipboard &viewer to display the plaintext"));  
         SetDlgItemText (dlg, IDC_PREFS_WWINFO, _("Word wrap cleartext &signatures at column"));  
         SetDlgItemText (dlg, IDC_PREFS_DISABLE_HOTKEYS, _("&Disable hotkeys (Not recommended!)"));  
         SetDlgItemText (dlg, IDC_PREFS_TRUST, _("Skip key validation and assume that keys are always fully trusted"));  
         SetDlgItemText (dlg, IDC_PREFS_AUTOBACKUP, _("&Automatic keyring backup when WinPT closes"));  
         SetDlgItemText (dlg, IDC_PREFS_BAKHOME, _("Backup to GPG &home folder"));  
         SetDlgItemText (dlg, IDC_PREFS_BAKUSER, _("Backup to:"));  
         SetDlgItemText (dlg, IDC_PREFS_KEYLISTINF, _("Select &key list mode"));  
         SetDlgItemText (dlg, IDC_PREFS_WIPEINF, _("Select &wipe mode"));  
         SetDlgItemText (dlg, IDC_PREFS_KSINF, _("Keyserver &config"));  
         SetDlgItemText (dlg, IDC_PREFS_CACHEINF, _("Cache &passphrases for 'n' seconds"));  
         SetDlgItemText (dlg, IDC_PREFS_CACHEHINT, _("(CTRL+ALT+F to clear the cache)"));  
         SetDlgItemText (dlg, IDC_PREFS_ALLOPTINF, _("General options"));  
         SetDlgItemText (dlg, IDC_PREFS_CLIPINF, _("Clipboard hotkeys"));  
         SetDlgItemText (dlg, IDC_PREFS_CURRINF, _("Current window hotkeys"));  
         SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));  
   
         SetDlgItemInt( dlg, IDC_PREFS_CACHETIME, reg_prefs.cache_time, TRUE );  
         SetDlgItemInt( dlg, IDC_PREFS_WORDWRAP, reg_prefs.word_wrap, TRUE );  
         if (reg_prefs.backup.path)  
             SetDlgItemText (dlg, IDC_PREFS_BAKPATH, reg_prefs.backup.path);  
         if (reg_prefs.kserv_conf)  
             SetDlgItemText (dlg, IDC_PREFS_KSERVER, reg_prefs.kserv_conf);  
   
         for (i=0; (id=hotkeys[i]); i++)  
             SetDlgItemText (dlg, id, reg_hotkeys[i].key);  
         CheckDlgButton( dlg, IDC_PREFS_DISABLE_HOTKEYS,  
                         reg_prefs.no_hotkeys ? BST_CHECKED : BST_UNCHECKED );  
         CheckDlgButton( dlg, IDC_PREFS_SECMODE,  
                         reg_prefs.use_tmpfiles ? BST_UNCHECKED : BST_CHECKED );  
         CheckDlgButton( dlg, IDC_PREFS_VIEWER,  
                         reg_prefs.use_viewer ? BST_CHECKED: BST_UNCHECKED );  
         CheckDlgButton( dlg, IDC_PREFS_TRUST,  
                         reg_prefs.always_trust? BST_CHECKED : BST_UNCHECKED );  
         CheckDlgButton( dlg, IDC_PREFS_AUTOBACKUP,  
                         reg_prefs.auto_backup? BST_CHECKED : BST_UNCHECKED );  
         CheckDlgButton( dlg, IDC_PREFS_BAKHOME,  
                         reg_prefs.backup.mode==1? BST_CHECKED : BST_UNCHECKED );  
         CheckDlgButton( dlg, IDC_PREFS_BAKUSER,  
                         reg_prefs.backup.mode==2? BST_CHECKED : BST_UNCHECKED );  
         if( reg_prefs.no_hotkeys )  
             disable_hotkey_items( dlg, 1 );  
         if (!reg_prefs.auto_backup)  
             enable_backup_items (dlg, 0);  
         EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH),  
                       reg_prefs.backup.mode==1?FALSE : TRUE);  
         EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT),  
                       reg_prefs.backup.mode==1? FALSE : TRUE);  
         init_keylist_modes (dlg);  
         init_wipe_modes (dlg);  
         center_window (dlg, NULL);  
         SetForegroundWindow (dlg);  
194          return TRUE;          return TRUE;
195                    
196      case WM_SYSCOMMAND:      case WM_DESTROY:
197          if (LOWORD (wparam) == SC_CLOSE)          balloon_msg_disable ();
198              EndDialog (dlg, TRUE);          break;
199          return FALSE;          
           
200      case WM_COMMAND:      case WM_COMMAND:
201          switch( HIWORD(wparam) ) {          switch (HIWORD (wparam)) {
202          case BN_CLICKED:          case BN_CLICKED:
203              switch( (int)LOWORD( wparam ) ) {              switch ((int)LOWORD (wparam)) {
204              case IDC_PREFS_DISABLE_HOTKEYS:                          case IDC_PREFS_DISABLE_HOTKEYS:            
205                  reg_prefs.no_hotkeys ^= 1;                  reg_prefs.no_hotkeys ^= 1;
206                  disable_hotkey_items( dlg, reg_prefs.no_hotkeys );                  disable_hotkey_items (dlg, reg_prefs.no_hotkeys);
207                  break;                  break;
208    
209              case IDC_PREFS_TRUST:              case IDC_PREFS_TRUST:
210                  reg_prefs.always_trust ^= 1;                  reg_prefs.always_trust ^= 1;
211                  if( reg_prefs.always_trust ) {                  if (reg_prefs.always_trust) {
212                      msg_box (dlg,                      msg_box (dlg,
213                  _("In most cases it is not a good idea to enable this setting.\n"                  _("In most cases it is not a good idea to enable this setting.\n"
214                    "If you know what you are doing let this flag enabled, otherwise\n"                    "If you know what you are doing, you can enable this flag, otherwise\n"
215                    "it is safe to leave this flag untouched."),                    "it is safe to leave this flag untouched."),
216                    _("Preferences"), MB_ICONWARNING|MB_OK );                    _("Preferences"), MB_WARN);
217                  }                  }
218                  break;                  break;
219    
# Line 218  prefs_dlg_proc (HWND dlg, UINT msg, WPAR Line 225  prefs_dlg_proc (HWND dlg, UINT msg, WPAR
225                          !IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))                          !IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
226                          CheckDlgButton (dlg, IDC_PREFS_BAKHOME, BST_CHECKED);                          CheckDlgButton (dlg, IDC_PREFS_BAKHOME, BST_CHECKED);
227                  }                  }
228                    if (IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME))
229                        EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
230                  break;                  break;
231    
232              case IDC_PREFS_BAKHOME:                          case IDC_PREFS_BAKHOME:            
# Line 232  prefs_dlg_proc (HWND dlg, UINT msg, WPAR Line 241  prefs_dlg_proc (HWND dlg, UINT msg, WPAR
241              }              }
242              break;              break;
243          }          }
244          switch( LOWORD( wparam ) ) {          switch (LOWORD (wparam)) {
245          case IDC_PREFS_BAKSELECT:          case IDC_PREFS_BAKSELECT:
246              const char *bpath;              const char *bpath;
247              bpath = get_folder_dlg (dlg, _("Select GPG backup path"), NULL);              bpath = get_folder_dlg (dlg, _("Select GPG backup path"), NULL);
# Line 240  prefs_dlg_proc (HWND dlg, UINT msg, WPAR Line 249  prefs_dlg_proc (HWND dlg, UINT msg, WPAR
249                  SetDlgItemText (dlg, IDC_PREFS_BAKPATH, bpath);                  SetDlgItemText (dlg, IDC_PREFS_BAKPATH, bpath);
250              break;              break;
251    
         case IDC_PREFS_KSELFILE: {  
             const char * name;  
             name = get_fileopen_dlg (dlg, _("Please select a keyserver.conf file"),  
                                      NULL, NULL);  
             if (name != NULL)  
                 SetDlgItemText (dlg, IDC_PREFS_KSERVER, name);  
             break; }  
   
252          case IDOK:          case IDOK:
253              rc = GetDlgItemInt( dlg, IDC_PREFS_CACHETIME, NULL, FALSE );              rc = GetDlgItemInt (dlg, IDC_PREFS_CACHETIME, NULL, FALSE);
254              if( !rc )              if (rc <= 0) {
255                  reg_prefs.cache_time = 0;                  reg_prefs.cache_time = 0;
256              else if( rc > 3600 ) {                  agent_flush_cache ();
257                  msg_box( dlg, _("Please enter a value that is between 1-3600.\nIt is not "              }
258                                  "a good idea to cache the passphrase more than one hour."),              else if (rc > 720) {
259                                  _("Preferences"), MB_ERR );                  show_balloon_msg (GetDlgItem (dlg, IDC_PREFS_CACHETIME),
260                  SetDlgItemInt( dlg, IDC_PREFS_CACHETIME, 0, FALSE );                                    _("Please enter a value that is between 1-720.\nIt is not "
261                  return TRUE;                                      "a good idea to cache the passphrase more than 12 hours."),
262                                      IDI_ERROR);
263                    SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, 0, FALSE);
264                    return FALSE;
265              }              }
266              if (reg_prefs.cache_time != rc)              if (reg_prefs.cache_time != rc)
267                  agent_flush_cache ();                  agent_flush_cache ();
268              reg_prefs.cache_time = rc;              reg_prefs.cache_time = rc*60;
269              rc = GetDlgItemInt( dlg, IDC_PREFS_WORDWRAP, NULL, FALSE );              rc = GetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, NULL, FALSE);
270              if( !rc )              if (rc <= 0)
271                  reg_prefs.word_wrap = 0;                  reg_prefs.word_wrap = 0;
272              else if( rc > 80 ) {              else if (rc > 80) {
273                  msg_box( dlg, _("Please enter a value between 1-80."), _("Preferences"), MB_ERR );                  show_balloon_msg (GetDlgItem (dlg, IDC_PREFS_WORDWRAP),
274                  return TRUE;                                    _("Please enter a value between 1-80."),
275                                      IDI_ERROR);
276                    return FALSE;
277              }              }
278                reg_prefs.default_ext = SendDlgItemMessage (dlg, IDC_PREFS_DEFEXT, CB_GETCURSEL, 0, 0);
279              reg_prefs.word_wrap = rc;              reg_prefs.word_wrap = rc;
280              reg_prefs.use_tmpfiles = IsDlgButtonChecked( dlg, IDC_PREFS_SECMODE )? 0 : 1;              reg_prefs.use_viewer = IsDlgButtonChecked (dlg, IDC_PREFS_VIEWER)? 1 : 0;
281              reg_prefs.use_viewer = IsDlgButtonChecked( dlg, IDC_PREFS_VIEWER )? 1 : 0;              reg_prefs.backup.mode = IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME ) ? 1 :
282              reg_prefs.backup.mode = IsDlgButtonChecked( dlg, IDC_PREFS_BAKHOME ) ? 1 :                                      IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER)? 2 : 0;
283                                      IsDlgButtonChecked( dlg, IDC_PREFS_BAKUSER )? 2 : 0;              reg_prefs.backup.include_secr = IsDlgButtonChecked (dlg, IDC_PREFS_BAKSECRING)? 1 : 0;
284              if( reg_prefs.backup.mode == 2 ) {              if (reg_prefs.backup.mode == 2) {
285                  if( !GetDlgItemText( dlg, IDC_PREFS_BAKPATH, path, sizeof (path)-1 )                  if (!GetDlgItemText (dlg, IDC_PREFS_BAKPATH, path, DIM (path)-1)
286                      || dir_exist_check( path ) ) {                      || dir_exist_check (path)) {
287                      msg_box( dlg, _("The specified backup folder is invalid."),                      show_balloon_msg (GetDlgItem (dlg, IDC_PREFS_BAKPATH),
288                               _("Preferences"), MB_ERR );                                        _("The specified backup folder is invalid."),
289                      return TRUE;                                        IDI_ERROR);
290                        return FALSE;
291                  }                  }
292                  free_if_alloc (reg_prefs.backup.path);                  free_if_alloc (reg_prefs.backup.path);
293                  p = reg_prefs.backup.path = m_strdup (path);                  p = reg_prefs.backup.path = m_strdup (path);
                 if (!p)  
                     BUG (0);  
             }  
             free_if_alloc (reg_prefs.kserv_conf);  
             if (!GetDlgItemText (dlg, IDC_PREFS_KSERVER, path, sizeof (path)-1)  
                 || file_exist_check (path)) {  
                 rc = msg_box (dlg, _("The specified keyserver config file is invalid.\n\n"  
                                      "Create new default config file?"),  
                          _("Preferences"), MB_ERR|MB_YESNO);  
                 if (rc == IDNO)  
                     return TRUE;  
                 else  
                 {  
                     char cwd[256], * fn;  
                     FILE * fp = fopen ("keyserver.conf", "wb");  
                     if (fp) {  
                         fprintf (fp, "%s\r\n", DEF_HKP_KEYSERVER);  
                         fclose (fp);  
                     }  
                     GetCurrentDirectory (DIM (cwd)-1, cwd);  
                     fn = make_filename (cwd, "keyserver", "conf");  
                     memset (path, 0, sizeof( path));  
                     strncpy (path, fn, DIM (path)-1);  
                     free_if_alloc (fn);  
                 }  
294              }              }
             p = reg_prefs.kserv_conf = m_strdup (path);  
             if (!p)  
                 BUG (0);  
   
             cb = GetDlgItem( dlg, IDC_PREFS_LISTMODE );  
             reg_prefs.keylist_mode = SendMessage( cb, CB_GETCURSEL, 0, 0 );  
   
             cb = GetDlgItem( dlg, IDC_PREFS_WIPEMODE );  
             reg_prefs.wipe_mode = SendMessage( cb, CB_GETCURSEL, 0, 0 );  
295                            
296              if (IsDlgButtonChecked (dlg, IDC_PREFS_DISABLE_HOTKEYS)) {              if (IsDlgButtonChecked (dlg, IDC_PREFS_DISABLE_HOTKEYS)) {
297                  hotkeys_unregister (glob_hwnd);                  hotkeys_unregister (glob_hwnd);
# Line 325  prefs_dlg_proc (HWND dlg, UINT msg, WPAR Line 299  prefs_dlg_proc (HWND dlg, UINT msg, WPAR
299              }              }
300              else {              else {
301                  reg_prefs.no_hotkeys = 0;                  reg_prefs.no_hotkeys = 0;
302                  for( i = 0; (id = hotkeys[i]); i++ ) {                  for (int i = 0; hotkeys[i] != 0; i++) {
303                      rc = GetDlgItemText( dlg, id, t, 2 );                      rc = GetDlgItemText (dlg, hotkeys[i], t, DIM (t)-1);
304                      if( rc && check_hotkey( &t[0] ) )                      if (rc > 0 && check_hotkey (&t[0]))
305                          hotkey_enable( &reg_hotkeys[i], t );                          hotkey_enable (&wpt_hotkeys[i], t);
306                      else                      else
307                          hotkey_disable( &reg_hotkeys[i] );                          hotkey_disable (&wpt_hotkeys[i]);
308                  }                  }
309                  set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "DisableHotkeys", "0");                  set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "DisableHotkeys", "0");
310                  reg_prefs.no_hotkeys = 0;                  reg_prefs.no_hotkeys = 0;
311              }              }
312    
313              if ((rc = set_reg_winpt_prefs (&reg_prefs)))              rc = set_reg_winpt_prefs (&reg_prefs);
314                if (rc)
315                  msg_box (dlg, winpt_strerror (rc), _("Preferences"), MB_ERR);                  msg_box (dlg, winpt_strerror (rc), _("Preferences"), MB_ERR);
316                            
317              if (reg_prefs.no_hotkeys == 0) {              if (reg_prefs.no_hotkeys == 0) {
318                  hotkeys_unregister (glob_hwnd);                  hotkeys_unregister (glob_hwnd);
319                  hotkeys_modify ();                  rc = hotkeys_register (glob_hwnd);
320                  if ((rc = hotkeys_register (glob_hwnd)))                  if (rc)
321                      msg_box (NULL, winpt_strerror (rc), _("Hotkeys"), MB_ERR);                      msg_box (NULL, winpt_strerror (rc), _("Hotkeys"), MB_ERR);
322              }              }
323              EndDialog (dlg, TRUE);              EndDialog (dlg, TRUE);
324              return TRUE;              return TRUE;
325                            
326          case IDCANCEL:          case IDCANCEL:
327              EndDialog( dlg, FALSE );              /* Reset backup mode if no mode was chosen. */
328                if (reg_prefs.auto_backup == 1 &&
329                    !IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME) &&
330                    !IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
331                    reg_prefs.auto_backup = 0;
332                EndDialog (dlg, FALSE);
333              return FALSE;              return FALSE;
334          }          }
335          break;          break;
Legend:
Removed from v.105  
changed lines
  Added in v.328
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26