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	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	twoaday	218	{IDC_PREFS_EXTINF, _("Default extension for encrypted files")},
133	twoaday	176	{IDCANCEL, _("&Cancel")},
134			{0, NULL}};
135			int i;
136	twoaday	218	HWND cb;
137	twoaday	176
138			gettext_localize_dialog (dlg, prefs, _("WinPT Preferences"));
139	twoaday	180
140			SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, reg_prefs.cache_time/60, TRUE);
141	twoaday	176	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	twoaday	180	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	twoaday	218	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	twoaday	176	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	twoaday	218	SendDlgItemMessage (dlg, IDC_PREFS_DEFEXT, CB_SETCURSEL,
171			reg_prefs.default_ext, 0);
172	twoaday	176	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	werner	36	/* 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	twoaday	176	int i;
192	twoaday	180	char t[3];
193	twoaday	176	char path[256], *p;
194	werner	36	HWND cb;
195
196	twoaday	88	switch (msg) {
197	werner	36	case WM_INITDIALOG:
198	twoaday	176	on_init_dialog (dlg);
199	werner	36	return TRUE;
200
201			case WM_SYSCOMMAND:
202			if (LOWORD (wparam) == SC_CLOSE)
203	twoaday	176	EndDialog (dlg, FALSE);
204	werner	36	return FALSE;
205
206			case WM_COMMAND:
207	twoaday	180	switch (HIWORD (wparam)) {
208	werner	36	case BN_CLICKED:
209	twoaday	180	switch ((int)LOWORD (wparam)) {
210	werner	36	case IDC_PREFS_DISABLE_HOTKEYS:
211			reg_prefs.no_hotkeys ^= 1;
212	twoaday	117	disable_hotkey_items (dlg, reg_prefs.no_hotkeys);
213	werner	36	break;
214
215			case IDC_PREFS_TRUST:
216			reg_prefs.always_trust ^= 1;
217	twoaday	117	if (reg_prefs.always_trust) {
218	werner	36	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	twoaday	117	_("Preferences"), MB_ICONWARNING\|MB_OK);
223	werner	36	}
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	twoaday	130	if (IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME))
235			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
236	werner	36	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	twoaday	180	switch (LOWORD (wparam)) {
251	werner	36	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	twoaday	180	rc = GetDlgItemInt (dlg, IDC_PREFS_CACHETIME, NULL, FALSE);
260	twoaday	181	if (rc <= 0) {
261	werner	36	reg_prefs.cache_time = 0;
262	twoaday	181	agent_flush_cache ();
263			}
264	twoaday	180	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	twoaday	117	_("Preferences"), MB_ERR);
268			SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, 0, FALSE);
269	werner	36	return TRUE;
270			}
271			if (reg_prefs.cache_time != rc)
272			agent_flush_cache ();
273	twoaday	180	reg_prefs.cache_time = rc*60;
274	twoaday	117	rc = GetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, NULL, FALSE);
275	twoaday	180	if (rc <= 0)
276	werner	36	reg_prefs.word_wrap = 0;
277	twoaday	117	else if (rc > 80) {
278	twoaday	176	msg_box (dlg, _("Please enter a value between 1-80."),
279			_("Preferences"), MB_ERR);
280	werner	36	return TRUE;
281			}
282	twoaday	218	reg_prefs.default_ext = SendDlgItemMessage (dlg, IDC_PREFS_DEFEXT, CB_GETCURSEL, 0, 0);
283	werner	36	reg_prefs.word_wrap = rc;
284	twoaday	180	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	werner	36	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	twoaday	180	cb = GetDlgItem (dlg, IDC_PREFS_WIPEMODE);
301			reg_prefs.wipe_mode = SendMessage (cb, CB_GETCURSEL, 0, 0);
302	werner	36
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	twoaday	180	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	werner	36	else
314	twoaday	180	hotkey_disable (&wpt_hotkeys[i]);
315	werner	36	}
316			set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "DisableHotkeys", "0");
317			reg_prefs.no_hotkeys = 0;
318			}
319
320	twoaday	180	rc = set_reg_winpt_prefs (&reg_prefs);
321			if (rc)
322	werner	36	msg_box (dlg, winpt_strerror (rc), _("Preferences"), MB_ERR);
323
324			if (reg_prefs.no_hotkeys == 0) {
325			hotkeys_unregister (glob_hwnd);
326	twoaday	180	rc = hotkeys_register (glob_hwnd);
327			if (rc)
328	werner	36	msg_box (NULL, winpt_strerror (rc), _("Hotkeys"), MB_ERR);
329			}
330			EndDialog (dlg, TRUE);
331			return TRUE;
332
333			case IDCANCEL:
334	twoaday	117	/* 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	werner	36	return FALSE;
341			}
342			break;
343			}
344
345			return FALSE;
346			}