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...")},
        {IDC_PREFS_EXTINF, _("Default extension for encrypted files")},
        {IDCANCEL, _("&Cancel")},
    {0, NULL}};
    int i;
    HWND cb;

    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);
    }
    cb = GetDlgItem (dlg, IDC_PREFS_DEFEXT);
    combox_add_string (cb, _("GnuPG (.gpg)"));
    combox_add_string (cb, _("PGP   (.pgp)"));
    SendMessage (cb, CB_SETCURSEL, 0, 0);

    CheckDlgButton (dlg, IDC_PREFS_DISABLE_HOTKEYS,
                    reg_prefs.no_hotkeys ? BST_CHECKED : BST_UNCHECKED);
    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);
    SendDlgItemMessage (dlg, IDC_PREFS_DEFEXT, CB_SETCURSEL, 
                        reg_prefs.default_ext, 0);
    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;
                agent_flush_cache ();
            }
            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.default_ext = SendDlgItemMessage (dlg, IDC_PREFS_DEFEXT, CB_GETCURSEL, 0, 0);
            reg_prefs.word_wrap = rc;
            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	{IDC_PREFS_EXTINF, _("Default extension for encrypted files")},
133	{IDCANCEL, _("&Cancel")},
134	{0, NULL}};
135	int i;
136	HWND cb;
137
138	gettext_localize_dialog (dlg, prefs, _("WinPT Preferences"));
139
140	SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, reg_prefs.cache_time/60, TRUE);
141	SetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, reg_prefs.word_wrap, TRUE);
142	if (reg_prefs.backup.path)
143	SetDlgItemText (dlg, IDC_PREFS_BAKPATH, reg_prefs.backup.path);
144
145	for (i=0; hotkeys[i]; i++) {
146	if (!wpt_hotkeys[i].enabled)
147	continue;
148	char key[2];
149	key[0] = wpt_hotkeys[i].key;
150	key[1] = 0;
151	SetDlgItemText (dlg, hotkeys[i], key);
152	}
153	cb = GetDlgItem (dlg, IDC_PREFS_DEFEXT);
154	combox_add_string (cb, _("GnuPG (.gpg)"));
155	combox_add_string (cb, _("PGP (.pgp)"));
156	SendMessage (cb, CB_SETCURSEL, 0, 0);
157
158	CheckDlgButton (dlg, IDC_PREFS_DISABLE_HOTKEYS,
159	reg_prefs.no_hotkeys ? BST_CHECKED : BST_UNCHECKED);
160	CheckDlgButton (dlg, IDC_PREFS_VIEWER,
161	reg_prefs.use_viewer ? BST_CHECKED: BST_UNCHECKED);
162	CheckDlgButton (dlg, IDC_PREFS_TRUST,
163	reg_prefs.always_trust? BST_CHECKED : BST_UNCHECKED);
164	CheckDlgButton (dlg, IDC_PREFS_AUTOBACKUP,
165	reg_prefs.auto_backup? BST_CHECKED : BST_UNCHECKED);
166	CheckDlgButton (dlg, IDC_PREFS_BAKHOME,
167	reg_prefs.backup.mode==1? BST_CHECKED : BST_UNCHECKED);
168	CheckDlgButton (dlg, IDC_PREFS_BAKUSER,
169	reg_prefs.backup.mode==2? BST_CHECKED : BST_UNCHECKED);
170	SendDlgItemMessage (dlg, IDC_PREFS_DEFEXT, CB_SETCURSEL,
171	reg_prefs.default_ext, 0);
172	if (reg_prefs.no_hotkeys)
173	disable_hotkey_items (dlg, 1);
174	if (!reg_prefs.auto_backup)
175	enable_backup_items (dlg, 0);
176	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH),
177	reg_prefs.backup.mode==1?FALSE : TRUE);
178	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT),
179	reg_prefs.backup.mode==1? FALSE : TRUE);
180	init_wipe_modes (dlg);
181	center_window (dlg, NULL);
182	SetForegroundWindow (dlg);
183	}
184
185
186	/* Dialog box procedure for the WinPT preferences. */
187	BOOL CALLBACK
188	prefs_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
189	{
190	int rc;
191	int i;
192	char t[3];
193	char path[256], *p;
194	HWND cb;
195
196	switch (msg) {
197	case WM_INITDIALOG:
198	on_init_dialog (dlg);
199	return TRUE;
200
201	case WM_SYSCOMMAND:
202	if (LOWORD (wparam) == SC_CLOSE)
203	EndDialog (dlg, FALSE);
204	return FALSE;
205
206	case WM_COMMAND:
207	switch (HIWORD (wparam)) {
208	case BN_CLICKED:
209	switch ((int)LOWORD (wparam)) {
210	case IDC_PREFS_DISABLE_HOTKEYS:
211	reg_prefs.no_hotkeys ^= 1;
212	disable_hotkey_items (dlg, reg_prefs.no_hotkeys);
213	break;
214
215	case IDC_PREFS_TRUST:
216	reg_prefs.always_trust ^= 1;
217	if (reg_prefs.always_trust) {
218	msg_box (dlg,
219	_("In most cases it is not a good idea to enable this setting.\n"
220	"If you know what you are doing let this flag enabled, otherwise\n"
221	"it is safe to leave this flag untouched."),
222	_("Preferences"), MB_ICONWARNING\|MB_OK);
223	}
224	break;
225
226	case IDC_PREFS_AUTOBACKUP:
227	reg_prefs.auto_backup ^= 1;
228	enable_backup_items (dlg, reg_prefs.auto_backup);
229	if (reg_prefs.auto_backup == 1) {
230	if (!IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME) &&
231	!IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
232	CheckDlgButton (dlg, IDC_PREFS_BAKHOME, BST_CHECKED);
233	}
234	if (IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME))
235	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
236	break;
237
238	case IDC_PREFS_BAKHOME:
239	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), FALSE);
240	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
241	break;
242
243	case IDC_PREFS_BAKUSER:
244	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), TRUE);
245	EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), TRUE);
246	break;
247	}
248	break;
249	}
250	switch (LOWORD (wparam)) {
251	case IDC_PREFS_BAKSELECT:
252	const char *bpath;
253	bpath = get_folder_dlg (dlg, _("Select GPG backup path"), NULL);
254	if (bpath)
255	SetDlgItemText (dlg, IDC_PREFS_BAKPATH, bpath);
256	break;
257
258	case IDOK:
259	rc = GetDlgItemInt (dlg, IDC_PREFS_CACHETIME, NULL, FALSE);
260	if (rc <= 0) {
261	reg_prefs.cache_time = 0;
262	agent_flush_cache ();
263	}
264	else if (rc > 720) {
265	msg_box( dlg, _("Please enter a value that is between 1-720.\nIt is not "
266	"a good idea to cache the passphrase more than 12 hours."),
267	_("Preferences"), MB_ERR);
268	SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, 0, FALSE);
269	return TRUE;
270	}
271	if (reg_prefs.cache_time != rc)
272	agent_flush_cache ();
273	reg_prefs.cache_time = rc*60;
274	rc = GetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, NULL, FALSE);
275	if (rc <= 0)
276	reg_prefs.word_wrap = 0;
277	else if (rc > 80) {
278	msg_box (dlg, _("Please enter a value between 1-80."),
279	_("Preferences"), MB_ERR);
280	return TRUE;
281	}
282	reg_prefs.default_ext = SendDlgItemMessage (dlg, IDC_PREFS_DEFEXT, CB_GETCURSEL, 0, 0);
283	reg_prefs.word_wrap = rc;
284	reg_prefs.use_viewer = IsDlgButtonChecked (dlg, IDC_PREFS_VIEWER)? 1 : 0;
285	reg_prefs.backup.mode = IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME ) ? 1 :
286	IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER)? 2 : 0;
287	if (reg_prefs.backup.mode == 2) {
288	if (!GetDlgItemText (dlg, IDC_PREFS_BAKPATH, path, sizeof (path)-1)
289	\|\| dir_exist_check (path)) {
290	msg_box (dlg, _("The specified backup folder is invalid."),
291	_("Preferences"), MB_ERR);
292	return TRUE;
293	}
294	free_if_alloc (reg_prefs.backup.path);
295	p = reg_prefs.backup.path = m_strdup (path);
296	if (!p)
297	BUG (0);
298	}
299
300	cb = GetDlgItem (dlg, IDC_PREFS_WIPEMODE);
301	reg_prefs.wipe_mode = SendMessage (cb, CB_GETCURSEL, 0, 0);
302
303	if (IsDlgButtonChecked (dlg, IDC_PREFS_DISABLE_HOTKEYS)) {
304	hotkeys_unregister (glob_hwnd);
305	reg_prefs.no_hotkeys = 1;
306	}
307	else {
308	reg_prefs.no_hotkeys = 0;
309	for (i = 0; hotkeys[i]; i++) {
310	rc = GetDlgItemText (dlg, hotkeys[i], t, sizeof (t)-1);
311	if (rc > 0 && check_hotkey (&t[0]))
312	hotkey_enable (&wpt_hotkeys[i], t);
313	else
314	hotkey_disable (&wpt_hotkeys[i]);
315	}
316	set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "DisableHotkeys", "0");
317	reg_prefs.no_hotkeys = 0;
318	}
319
320	rc = set_reg_winpt_prefs (&reg_prefs);
321	if (rc)
322	msg_box (dlg, winpt_strerror (rc), _("Preferences"), MB_ERR);
323
324	if (reg_prefs.no_hotkeys == 0) {
325	hotkeys_unregister (glob_hwnd);
326	rc = hotkeys_register (glob_hwnd);
327	if (rc)
328	msg_box (NULL, winpt_strerror (rc), _("Hotkeys"), MB_ERR);
329	}
330	EndDialog (dlg, TRUE);
331	return TRUE;
332
333	case IDCANCEL:
334	/* Reset backup mode if no mode was chosen. */
335	if (reg_prefs.auto_backup == 1 &&
336	!IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME) &&
337	!IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
338	reg_prefs.auto_backup = 0;
339	EndDialog (dlg, FALSE);
340	return FALSE;
341	}
342	break;
343	}
344
345	return FALSE;
346	}