trunk/Src/wptPreferencesDlg.cpp

/* wptPreferencesDlg.cpp - Dialog for the preferences
 *      Copyright (C) 2001, 2002, 2003, 2005, 2006 Timo Schulz
 *
 * This file is part of WinPT.
 *
 * WinPT is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * 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
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <shlobj.h>

#include "wptNLS.h"
#include "wptGPG.h"
#include "wptCommonCtl.h"
#include "wptDlgs.h"
#include "wptTypes.h"
#include "wptErrors.h"
#include "wptRegistry.h"
#include "wptHotkey.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptAgent.h"
#include "wptKeyserver.h"
#include "resource.h"


/* Dialog IDs of all hotkeys. */
static int hotkeys[] = {
    IDC_PREFS_CLIP_ENCRYPT,
    IDC_PREFS_CLIP_DECRYPT_VERIFY,
    IDC_PREFS_CLIP_SIGNENC,
    IDC_PREFS_CLIP_SIGN,    
    IDC_PREFS_CWS_ENCRYPT,
    IDC_PREFS_CWS_DECRYPT_VERIFY,
    IDC_PREFS_CWS_SIGN,
    IDC_PREFS_CWS_SIGNENC,
    0
};


/* Check that the given hotkey is in A..Z or a..z. */
static int
check_hotkey (char *key)
{
    if (*key >= 'A' && *key <= 'Z')
        return 1;
    else if (*key >= 'a' && *key <= 'z') {
        *key = *key - 32;
        return 1;
    }
    return 0;
}


/* Disable all hotkey controls in the dialog @dlg if val is 1. */
static void
disable_hotkey_items (HWND dlg, int val)
{
    int mode = val? FALSE : TRUE;
    int i, id;
    
    for (i=0; (id = hotkeys[i]); i++)
        EnableWindow (GetDlgItem (dlg, id), mode);
}


/* En- or disable the backup items in the dialog @dlg.
   If val != 0 activate them, disable them otherwise. */
static void
enable_backup_items (HWND dlg, int val)
{
    int mode = val? TRUE : FALSE;

    EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKHOME), mode);
    EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKUSER), mode);
    EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), mode);
    EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), mode);
}


/* Initialize the combobox in the dialog @dlg with the valid wipe modes. */
static void
init_wipe_modes (HWND dlg)
{
    HWND cb = GetDlgItem (dlg, IDC_PREFS_WIPEMODE);
    combox_add_string (cb, (char *)"Simple");
    combox_add_string (cb, (char *)"DoD");
    combox_add_string (cb, (char *)"Gutmann");
    SendMessage (cb, CB_SETCURSEL, (WPARAM)reg_prefs.wipe_mode, 0);
}


/* Helper function to prepare dialog. */
static void
on_init_dialog (HWND dlg)
{
    struct gettext_tab_s prefs[] = {
        {IDC_PREFS_SECMODE, _("Do not use any &temporary files")},
        {IDC_PREFS_VIEWER, _("Use clipboard &viewer to display the plaintext")},
        {IDC_PREFS_WWINFO, _("Word wrap cleartext &signatures at column")},
        {IDC_PREFS_DISABLE_HOTKEYS, _("&Disable hotkeys (Not recommended!)")},
        {IDC_PREFS_TRUST, _("Skip key validation and assume that keys are always fully trusted")},
        {IDC_PREFS_AUTOBACKUP, _("&Automatic keyring backup when WinPT closes")},
        {IDC_PREFS_BAKHOME, _("Backup to &keyring folder")},
        {IDC_PREFS_BAKUSER, _("Backup to:")},
        {IDC_PREFS_KEYLISTINF, _("Select &key list mode")},
        {IDC_PREFS_WIPEINF, _("Select &wipe mode")},
        {IDC_PREFS_KSINF, _("Keyserver &config")},
        {IDC_PREFS_CACHEINF, _("Cache &passphrases for 'n' minutes")},
        {IDC_PREFS_CACHEHINT, _("(CTRL+ALT+F to clear the cache)")},
        {IDC_PREFS_ALLOPTINF, _("General options")},
        {IDC_PREFS_CLIPINF, _("Clipboard hotkeys")},
        {IDC_PREFS_CURRINF, _("Current window hotkeys")},
        {IDC_PREFS_KSELFILE, _("Browse...")},
        {IDC_PREFS_BAKSELECT, _("Browse...")},
        {IDCANCEL, _("&Cancel")},
    {0, NULL}};
    int i;

    gettext_localize_dialog (dlg, prefs, _("WinPT Preferences"));

    SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, reg_prefs.cache_time/60, 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);
        
    for (i=0; hotkeys[i]; i++) {
        if (!wpt_hotkeys[i].enabled)
            continue;
        char key[2];
        key[0] = wpt_hotkeys[i].key;
        key[1] = 0;
        SetDlgItemText (dlg, 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_wipe_modes (dlg);
    center_window (dlg, NULL);    
    SetForegroundWindow (dlg);
}


/* Dialog box procedure for the WinPT preferences. */
BOOL CALLBACK
prefs_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    int rc;
    int i;
    char t[3];
    char path[256], *p;
    HWND cb;
    
    switch (msg) {
    case WM_INITDIALOG:
        on_init_dialog (dlg);
        return TRUE;
        
    case WM_SYSCOMMAND:
        if (LOWORD (wparam) == SC_CLOSE)
            EndDialog (dlg, FALSE);
        return FALSE;
        
    case WM_COMMAND:
        switch (HIWORD (wparam)) {
        case BN_CLICKED:
            switch ((int)LOWORD (wparam)) {
            case IDC_PREFS_DISABLE_HOTKEYS:            
                reg_prefs.no_hotkeys ^= 1;
                disable_hotkey_items (dlg, reg_prefs.no_hotkeys);
                break;

            case IDC_PREFS_TRUST:
                reg_prefs.always_trust ^= 1;
                if (reg_prefs.always_trust) {
                    msg_box (dlg,
                _("In most cases it is not a good idea to enable this setting.\n"
                  "If you know what you are doing let this flag enabled, otherwise\n"
                  "it is safe to leave this flag untouched."), 
                  _("Preferences"), MB_ICONWARNING|MB_OK);
                }
                break;

            case IDC_PREFS_AUTOBACKUP:
                reg_prefs.auto_backup ^= 1;                 
                enable_backup_items (dlg, reg_prefs.auto_backup);
                if (reg_prefs.auto_backup == 1) {
                    if (!IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME) &&
                        !IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
                        CheckDlgButton (dlg, IDC_PREFS_BAKHOME, BST_CHECKED);
                }
                if (IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME))
                    EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
                break;

            case IDC_PREFS_BAKHOME:             
                EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), FALSE);
                EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
                break;

            case IDC_PREFS_BAKUSER:
                EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), TRUE);
                EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), TRUE);
                break;
            }
            break;
        }
        switch (LOWORD (wparam)) {
        case IDC_PREFS_BAKSELECT:
            const char *bpath;
            bpath = get_folder_dlg (dlg, _("Select GPG backup path"), NULL);
            if (bpath)
                SetDlgItemText (dlg, IDC_PREFS_BAKPATH, bpath);
            break;

        case IDOK:
            rc = GetDlgItemInt (dlg, IDC_PREFS_CACHETIME, NULL, FALSE);
            if (rc <= 0)
                reg_prefs.cache_time = 0;
            else if (rc > 720) {
                msg_box( dlg, _("Please enter a value that is between 1-720.\nIt is not "
                                "a good idea to cache the passphrase more than 12 hours."),
                                _("Preferences"), MB_ERR);
                SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, 0, FALSE);
                return TRUE;
            }
            if (reg_prefs.cache_time != rc)
                agent_flush_cache ();
            reg_prefs.cache_time = rc*60;
            rc = GetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, NULL, FALSE);
            if (rc <= 0)
                reg_prefs.word_wrap = 0;
            else if (rc > 80) {
                msg_box (dlg, _("Please enter a value between 1-80."), 
                         _("Preferences"), MB_ERR);
                return TRUE;
            }
            reg_prefs.word_wrap = rc;
            reg_prefs.use_tmpfiles = IsDlgButtonChecked (dlg, IDC_PREFS_SECMODE)? 0 : 1;
            reg_prefs.use_viewer = IsDlgButtonChecked (dlg, IDC_PREFS_VIEWER)? 1 : 0;
            reg_prefs.backup.mode = IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME ) ? 1 :
                                    IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER)? 2 : 0;
            if (reg_prefs.backup.mode == 2) {
                if (!GetDlgItemText (dlg, IDC_PREFS_BAKPATH, path, sizeof (path)-1)
                    || dir_exist_check (path)) {
                    msg_box (dlg, _("The specified backup folder is invalid."), 
                             _("Preferences"), MB_ERR);
                    return TRUE;
                }
                free_if_alloc (reg_prefs.backup.path);
                p = reg_prefs.backup.path = m_strdup (path);
                if (!p)
                    BUG (0);
            }

            cb = GetDlgItem (dlg, IDC_PREFS_WIPEMODE);
            reg_prefs.wipe_mode = SendMessage (cb, CB_GETCURSEL, 0, 0);
            
            if (IsDlgButtonChecked (dlg, IDC_PREFS_DISABLE_HOTKEYS)) {
                hotkeys_unregister (glob_hwnd);
                reg_prefs.no_hotkeys = 1;
            }
            else {
                reg_prefs.no_hotkeys = 0;
                for (i = 0; hotkeys[i]; i++) {
                    rc = GetDlgItemText (dlg, hotkeys[i], t, sizeof (t)-1);
                    if (rc > 0 && check_hotkey (&t[0]))
                        hotkey_enable (&wpt_hotkeys[i], t);
                    else
                        hotkey_disable (&wpt_hotkeys[i]);
                }
                set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "DisableHotkeys", "0");
                reg_prefs.no_hotkeys = 0;
            }

            rc = set_reg_winpt_prefs (&reg_prefs);
            if (rc)
                msg_box (dlg, winpt_strerror (rc), _("Preferences"), MB_ERR);
            
            if (reg_prefs.no_hotkeys == 0) {
                hotkeys_unregister (glob_hwnd);
                rc = hotkeys_register (glob_hwnd);
                if (rc)
                    msg_box (NULL, winpt_strerror (rc), _("Hotkeys"), MB_ERR);
            }
            EndDialog (dlg, TRUE);
            return TRUE;
            
        case IDCANCEL:
            /* Reset backup mode if no mode was chosen. */
            if (reg_prefs.auto_backup == 1 &&
                !IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME) &&
                !IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
                reg_prefs.auto_backup = 0;
            EndDialog (dlg, FALSE);
            return FALSE;
        }
        break;
    }
    
    return FALSE;
}
1	/* wptPreferencesDlg.cpp - Dialog for the preferences
2	* Copyright (C) 2001, 2002, 2003, 2005, 2006 Timo Schulz
3	*
4	* This file is part of WinPT.
5	*
6	* WinPT is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* WinPT 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 WinPT; if not, write to the Free Software Foundation,
18	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19	*/
20	#ifdef HAVE_CONFIG_H
21	#include <config.h>
22	#endif
23
24	#include <windows.h>
25	#include <shlobj.h>
26
27	#include "wptNLS.h"
28	#include "wptGPG.h"
29	#include "wptCommonCtl.h"
30	#include "wptDlgs.h"
31	#include "wptTypes.h"
32	#include "wptErrors.h"
33	#include "wptRegistry.h"
34	#include "wptHotkey.h"
35	#include "wptW32API.h"
36	#include "wptVersion.h"
37	#include "wptAgent.h"
38	#include "wptKeyserver.h"
39	#include "resource.h"
40
41
42	/* Dialog IDs of all hotkeys. */
43	static int hotkeys[] = {
44	IDC_PREFS_CLIP_ENCRYPT,
45	IDC_PREFS_CLIP_DECRYPT_VERIFY,
46	IDC_PREFS_CLIP_SIGNENC,
47	IDC_PREFS_CLIP_SIGN,
48	IDC_PREFS_CWS_ENCRYPT,
49	IDC_PREFS_CWS_DECRYPT_VERIFY,
50	IDC_PREFS_CWS_SIGN,
51	IDC_PREFS_CWS_SIGNENC,
52	0
53	};
54
55
56	/* Check that the given hotkey is in A..Z or a..z. */
57	static int
58	check_hotkey (char *key)
59	{
60	if (key >= 'A' && key <= 'Z')
61	return 1;
62	else if (key >= 'a' && key <= 'z') {
63	key = key - 32;
64	return 1;
65	}
66	return 0;
67	}
68
69
70	/* Disable all hotkey controls in the dialog @dlg if val is 1. */
71	static void
72	disable_hotkey_items (HWND dlg, int val)
73	{
74	int mode = val? FALSE : TRUE;
75	int i, id;
76
77	for (i=0; (id = hotkeys[i]); i++)
78	EnableWindow (GetDlgItem (dlg, id), mode);
79	}
80
81
82
83	/* En- or disable the backup items in the dialog @dlg.
84	If val != 0 activate them, disable them otherwise. */
85	static void
86	enable_backup_items (HWND dlg, int val)
87	{
88	int mode = val? TRUE : FALSE;
89
90	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKHOME), mode);
91	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKUSER), mode);
92	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), mode);
93	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), mode);
94	}
95
96
97	/* Initialize the combobox in the dialog @dlg with the valid wipe modes. */
98	static void
99	init_wipe_modes (HWND dlg)
100	{
101	HWND cb = GetDlgItem (dlg, IDC_PREFS_WIPEMODE);
102	combox_add_string (cb, (char *)"Simple");
103	combox_add_string (cb, (char *)"DoD");
104	combox_add_string (cb, (char *)"Gutmann");
105	SendMessage (cb, CB_SETCURSEL, (WPARAM)reg_prefs.wipe_mode, 0);
106	}
107
108
109	/* Helper function to prepare dialog. */
110	static void
111	on_init_dialog (HWND dlg)
112	{
113	struct gettext_tab_s prefs[] = {
114	{IDC_PREFS_SECMODE, _("Do not use any &temporary files")},
115	{IDC_PREFS_VIEWER, _("Use clipboard &viewer to display the plaintext")},
116	{IDC_PREFS_WWINFO, _("Word wrap cleartext &signatures at column")},
117	{IDC_PREFS_DISABLE_HOTKEYS, _("&Disable hotkeys (Not recommended!)")},
118	{IDC_PREFS_TRUST, _("Skip key validation and assume that keys are always fully trusted")},
119	{IDC_PREFS_AUTOBACKUP, _("&Automatic keyring backup when WinPT closes")},
120	{IDC_PREFS_BAKHOME, _("Backup to &keyring folder")},
121	{IDC_PREFS_BAKUSER, _("Backup to:")},
122	{IDC_PREFS_KEYLISTINF, _("Select &key list mode")},
123	{IDC_PREFS_WIPEINF, _("Select &wipe mode")},
124	{IDC_PREFS_KSINF, _("Keyserver &config")},
125	{IDC_PREFS_CACHEINF, _("Cache &passphrases for 'n' minutes")},
126	{IDC_PREFS_CACHEHINT, _("(CTRL+ALT+F to clear the cache)")},
127	{IDC_PREFS_ALLOPTINF, _("General options")},
128	{IDC_PREFS_CLIPINF, _("Clipboard hotkeys")},
129	{IDC_PREFS_CURRINF, _("Current window hotkeys")},
130	{IDC_PREFS_KSELFILE, _("Browse...")},
131	{IDC_PREFS_BAKSELECT, _("Browse...")},
132	{IDCANCEL, _("&Cancel")},
133	{0, NULL}};
134	int i;
135
136	gettext_localize_dialog (dlg, prefs, _("WinPT Preferences"));
137
138	SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, reg_prefs.cache_time/60, TRUE);
139	SetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, reg_prefs.word_wrap, TRUE);
140	if (reg_prefs.backup.path)
141	SetDlgItemText (dlg, IDC_PREFS_BAKPATH, reg_prefs.backup.path);
142
143	for (i=0; hotkeys[i]; i++) {
144	if (!wpt_hotkeys[i].enabled)
145	continue;
146	char key[2];
147	key[0] = wpt_hotkeys[i].key;
148	key[1] = 0;
149	SetDlgItemText (dlg, hotkeys[i], key);
150	}
151	CheckDlgButton (dlg, IDC_PREFS_DISABLE_HOTKEYS,
152	reg_prefs.no_hotkeys ? BST_CHECKED : BST_UNCHECKED);
153	CheckDlgButton (dlg, IDC_PREFS_SECMODE,
154	reg_prefs.use_tmpfiles ? BST_UNCHECKED : BST_CHECKED);
155	CheckDlgButton (dlg, IDC_PREFS_VIEWER,
156	reg_prefs.use_viewer ? BST_CHECKED: BST_UNCHECKED);
157	CheckDlgButton (dlg, IDC_PREFS_TRUST,
158	reg_prefs.always_trust? BST_CHECKED : BST_UNCHECKED);
159	CheckDlgButton (dlg, IDC_PREFS_AUTOBACKUP,
160	reg_prefs.auto_backup? BST_CHECKED : BST_UNCHECKED);
161	CheckDlgButton (dlg, IDC_PREFS_BAKHOME,
162	reg_prefs.backup.mode==1? BST_CHECKED : BST_UNCHECKED);
163	CheckDlgButton (dlg, IDC_PREFS_BAKUSER,
164	reg_prefs.backup.mode==2? BST_CHECKED : BST_UNCHECKED);
165	if (reg_prefs.no_hotkeys)
166	disable_hotkey_items (dlg, 1);
167	if (!reg_prefs.auto_backup)
168	enable_backup_items (dlg, 0);
169	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH),
170	reg_prefs.backup.mode==1?FALSE : TRUE);
171	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT),
172	reg_prefs.backup.mode==1? FALSE : TRUE);
173	init_wipe_modes (dlg);
174	center_window (dlg, NULL);
175	SetForegroundWindow (dlg);
176	}
177
178
179	/* Dialog box procedure for the WinPT preferences. */
180	BOOL CALLBACK
181	prefs_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
182	{
183	int rc;
184	int i;
185	char t[3];
186	char path[256], *p;
187	HWND cb;
188
189	switch (msg) {
190	case WM_INITDIALOG:
191	on_init_dialog (dlg);
192	return TRUE;
193
194	case WM_SYSCOMMAND:
195	if (LOWORD (wparam) == SC_CLOSE)
196	EndDialog (dlg, FALSE);
197	return FALSE;
198
199	case WM_COMMAND:
200	switch (HIWORD (wparam)) {
201	case BN_CLICKED:
202	switch ((int)LOWORD (wparam)) {
203	case IDC_PREFS_DISABLE_HOTKEYS:
204	reg_prefs.no_hotkeys ^= 1;
205	disable_hotkey_items (dlg, reg_prefs.no_hotkeys);
206	break;
207
208	case IDC_PREFS_TRUST:
209	reg_prefs.always_trust ^= 1;
210	if (reg_prefs.always_trust) {
211	msg_box (dlg,
212	_("In most cases it is not a good idea to enable this setting.\n"
213	"If you know what you are doing let this flag enabled, otherwise\n"
214	"it is safe to leave this flag untouched."),
215	_("Preferences"), MB_ICONWARNING\|MB_OK);
216	}
217	break;
218
219	case IDC_PREFS_AUTOBACKUP:
220	reg_prefs.auto_backup ^= 1;
221	enable_backup_items (dlg, reg_prefs.auto_backup);
222	if (reg_prefs.auto_backup == 1) {
223	if (!IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME) &&
224	!IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
225	CheckDlgButton (dlg, IDC_PREFS_BAKHOME, BST_CHECKED);
226	}
227	if (IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME))
228	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
229	break;
230
231	case IDC_PREFS_BAKHOME:
232	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), FALSE);
233	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
234	break;
235
236	case IDC_PREFS_BAKUSER:
237	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), TRUE);
238	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), TRUE);
239	break;
240	}
241	break;
242	}
243	switch (LOWORD (wparam)) {
244	case IDC_PREFS_BAKSELECT:
245	const char *bpath;
246	bpath = get_folder_dlg (dlg, _("Select GPG backup path"), NULL);
247	if (bpath)
248	SetDlgItemText (dlg, IDC_PREFS_BAKPATH, bpath);
249	break;
250
251	case IDOK:
252	rc = GetDlgItemInt (dlg, IDC_PREFS_CACHETIME, NULL, FALSE);
253	if (rc <= 0)
254	reg_prefs.cache_time = 0;
255	else if (rc > 720) {
256	msg_box( dlg, _("Please enter a value that is between 1-720.\nIt is not "
257	"a good idea to cache the passphrase more than 12 hours."),
258	_("Preferences"), MB_ERR);
259	SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, 0, FALSE);
260	return TRUE;
261	}
262	if (reg_prefs.cache_time != rc)
263	agent_flush_cache ();
264	reg_prefs.cache_time = rc*60;
265	rc = GetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, NULL, FALSE);
266	if (rc <= 0)
267	reg_prefs.word_wrap = 0;
268	else if (rc > 80) {
269	msg_box (dlg, _("Please enter a value between 1-80."),
270	_("Preferences"), MB_ERR);
271	return TRUE;
272	}
273	reg_prefs.word_wrap = rc;
274	reg_prefs.use_tmpfiles = IsDlgButtonChecked (dlg, IDC_PREFS_SECMODE)? 0 : 1;
275	reg_prefs.use_viewer = IsDlgButtonChecked (dlg, IDC_PREFS_VIEWER)? 1 : 0;
276	reg_prefs.backup.mode = IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME ) ? 1 :
277	IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER)? 2 : 0;
278	if (reg_prefs.backup.mode == 2) {
279	if (!GetDlgItemText (dlg, IDC_PREFS_BAKPATH, path, sizeof (path)-1)
280	\|\| dir_exist_check (path)) {
281	msg_box (dlg, _("The specified backup folder is invalid."),
282	_("Preferences"), MB_ERR);
283	return TRUE;
284	}
285	free_if_alloc (reg_prefs.backup.path);
286	p = reg_prefs.backup.path = m_strdup (path);
287	if (!p)
288	BUG (0);
289	}
290
291	cb = GetDlgItem (dlg, IDC_PREFS_WIPEMODE);
292	reg_prefs.wipe_mode = SendMessage (cb, CB_GETCURSEL, 0, 0);
293
294	if (IsDlgButtonChecked (dlg, IDC_PREFS_DISABLE_HOTKEYS)) {
295	hotkeys_unregister (glob_hwnd);
296	reg_prefs.no_hotkeys = 1;
297	}
298	else {
299	reg_prefs.no_hotkeys = 0;
300	for (i = 0; hotkeys[i]; i++) {
301	rc = GetDlgItemText (dlg, hotkeys[i], t, sizeof (t)-1);
302	if (rc > 0 && check_hotkey (&t[0]))
303	hotkey_enable (&wpt_hotkeys[i], t);
304	else
305	hotkey_disable (&wpt_hotkeys[i]);
306	}
307	set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "DisableHotkeys", "0");
308	reg_prefs.no_hotkeys = 0;
309	}
310
311	rc = set_reg_winpt_prefs (&reg_prefs);
312	if (rc)
313	msg_box (dlg, winpt_strerror (rc), _("Preferences"), MB_ERR);
314
315	if (reg_prefs.no_hotkeys == 0) {
316	hotkeys_unregister (glob_hwnd);
317	rc = hotkeys_register (glob_hwnd);
318	if (rc)
319	msg_box (NULL, winpt_strerror (rc), _("Hotkeys"), MB_ERR);
320	}
321	EndDialog (dlg, TRUE);
322	return TRUE;
323
324	case IDCANCEL:
325	/* Reset backup mode if no mode was chosen. */
326	if (reg_prefs.auto_backup == 1 &&
327	!IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME) &&
328	!IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
329	reg_prefs.auto_backup = 0;
330	EndDialog (dlg, FALSE);
331	return FALSE;
332	}
333	break;
334	}
335
336	return FALSE;
337	}