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;
                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.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	werner	36	/* wptPreferencesDlg.cpp - Dialog for the preferences
2	twoaday	180	* Copyright (C) 2001, 2002, 2003, 2005, 2006 Timo Schulz
3	werner	36	*
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	werner	47	#include "resource.h"
40	werner	36
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	twoaday	180	IDC_PREFS_CLIP_SIGN,
48	werner	36	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	twoaday	180	check_hotkey (char *key)
59	werner	36	{
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	twoaday	32	}
68	werner	36
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	twoaday	176	/* 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	twoaday	180	{IDC_PREFS_CACHEINF, _("Cache &passphrases for 'n' minutes")},
126	twoaday	176	{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	twoaday	180
138			SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, reg_prefs.cache_time/60, TRUE);
139	twoaday	176	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	twoaday	180	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	twoaday	176	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	werner	36	/* 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	twoaday	176	int i;
185	twoaday	180	char t[3];
186	twoaday	176	char path[256], *p;
187	werner	36	HWND cb;
188
189	twoaday	88	switch (msg) {
190	werner	36	case WM_INITDIALOG:
191	twoaday	176	on_init_dialog (dlg);
192	werner	36	return TRUE;
193
194			case WM_SYSCOMMAND:
195			if (LOWORD (wparam) == SC_CLOSE)
196	twoaday	176	EndDialog (dlg, FALSE);
197	werner	36	return FALSE;
198
199			case WM_COMMAND:
200	twoaday	180	switch (HIWORD (wparam)) {
201	werner	36	case BN_CLICKED:
202	twoaday	180	switch ((int)LOWORD (wparam)) {
203	werner	36	case IDC_PREFS_DISABLE_HOTKEYS:
204			reg_prefs.no_hotkeys ^= 1;
205	twoaday	117	disable_hotkey_items (dlg, reg_prefs.no_hotkeys);
206	werner	36	break;
207
208			case IDC_PREFS_TRUST:
209			reg_prefs.always_trust ^= 1;
210	twoaday	117	if (reg_prefs.always_trust) {
211	werner	36	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	twoaday	117	_("Preferences"), MB_ICONWARNING\|MB_OK);
216	werner	36	}
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	twoaday	130	if (IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME))
228			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
229	werner	36	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	twoaday	180	switch (LOWORD (wparam)) {
244	werner	36	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	twoaday	180	rc = GetDlgItemInt (dlg, IDC_PREFS_CACHETIME, NULL, FALSE);
253	twoaday	181	if (rc <= 0) {
254	werner	36	reg_prefs.cache_time = 0;
255	twoaday	181	agent_flush_cache ();
256			}
257	twoaday	180	else if (rc > 720) {
258			msg_box( dlg, _("Please enter a value that is between 1-720.\nIt is not "
259			"a good idea to cache the passphrase more than 12 hours."),
260	twoaday	117	_("Preferences"), MB_ERR);
261			SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, 0, FALSE);
262	werner	36	return TRUE;
263			}
264			if (reg_prefs.cache_time != rc)
265			agent_flush_cache ();
266	twoaday	180	reg_prefs.cache_time = rc*60;
267	twoaday	117	rc = GetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, NULL, FALSE);
268	twoaday	180	if (rc <= 0)
269	werner	36	reg_prefs.word_wrap = 0;
270	twoaday	117	else if (rc > 80) {
271	twoaday	176	msg_box (dlg, _("Please enter a value between 1-80."),
272			_("Preferences"), MB_ERR);
273	werner	36	return TRUE;
274			}
275			reg_prefs.word_wrap = rc;
276	twoaday	180	reg_prefs.use_tmpfiles = IsDlgButtonChecked (dlg, IDC_PREFS_SECMODE)? 0 : 1;
277			reg_prefs.use_viewer = IsDlgButtonChecked (dlg, IDC_PREFS_VIEWER)? 1 : 0;
278			reg_prefs.backup.mode = IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME ) ? 1 :
279			IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER)? 2 : 0;
280			if (reg_prefs.backup.mode == 2) {
281			if (!GetDlgItemText (dlg, IDC_PREFS_BAKPATH, path, sizeof (path)-1)
282			\|\| dir_exist_check (path)) {
283			msg_box (dlg, _("The specified backup folder is invalid."),
284			_("Preferences"), MB_ERR);
285	werner	36	return TRUE;
286			}
287			free_if_alloc (reg_prefs.backup.path);
288			p = reg_prefs.backup.path = m_strdup (path);
289			if (!p)
290			BUG (0);
291			}
292
293	twoaday	180	cb = GetDlgItem (dlg, IDC_PREFS_WIPEMODE);
294			reg_prefs.wipe_mode = SendMessage (cb, CB_GETCURSEL, 0, 0);
295	werner	36
296			if (IsDlgButtonChecked (dlg, IDC_PREFS_DISABLE_HOTKEYS)) {
297			hotkeys_unregister (glob_hwnd);
298			reg_prefs.no_hotkeys = 1;
299			}
300			else {
301			reg_prefs.no_hotkeys = 0;
302	twoaday	180	for (i = 0; hotkeys[i]; i++) {
303			rc = GetDlgItemText (dlg, hotkeys[i], t, sizeof (t)-1);
304			if (rc > 0 && check_hotkey (&t[0]))
305			hotkey_enable (&wpt_hotkeys[i], t);
306	werner	36	else
307	twoaday	180	hotkey_disable (&wpt_hotkeys[i]);
308	werner	36	}
309			set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "DisableHotkeys", "0");
310			reg_prefs.no_hotkeys = 0;
311			}
312
313	twoaday	180	rc = set_reg_winpt_prefs (&reg_prefs);
314			if (rc)
315	werner	36	msg_box (dlg, winpt_strerror (rc), _("Preferences"), MB_ERR);
316
317			if (reg_prefs.no_hotkeys == 0) {
318			hotkeys_unregister (glob_hwnd);
319	twoaday	180	rc = hotkeys_register (glob_hwnd);
320			if (rc)
321	werner	36	msg_box (NULL, winpt_strerror (rc), _("Hotkeys"), MB_ERR);
322			}
323			EndDialog (dlg, TRUE);
324			return TRUE;
325
326			case IDCANCEL:
327	twoaday	117	/* 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	werner	36	return FALSE;
334			}
335			break;
336			}
337
338			return FALSE;
339			}