trunk/Src/wptPreferencesDlg.cpp

/* wptPreferencesDlg.cpp - Dialog for the preferences
 *      Copyright (C) 2001, 2002, 2003, 2005 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_SIGN,
    IDC_PREFS_CLIP_SIGNENC,
    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 combox in the dialog @dlg with the valid list modes. */
static void
init_keylist_modes (HWND dlg)
{
    HWND cb = GetDlgItem (dlg, IDC_PREFS_LISTMODE);
    combox_add_string (cb, (char *)"NORMAL");
    combox_add_string (cb, (char *)"MINIMAL");
    SendMessage (cb, CB_SETCURSEL, (WPARAM)reg_prefs.keylist_mode, 0);
}


/* 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);
}


/* Dialog box procedure for the WinPT preferences. */
BOOL CALLBACK
prefs_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    int rc;
    int i, id;
    char t[2];
    char path[256], * p;
    HWND cb;
    
    switch (msg) {
    case WM_INITDIALOG:
        SetWindowText (dlg, _("WinPT Preferences"));
        SetDlgItemText (dlg, IDC_PREFS_SECMODE, _("Do not use any &temporary files"));
        SetDlgItemText (dlg, IDC_PREFS_VIEWER, _("Use clipboard &viewer to display the plaintext"));
        SetDlgItemText (dlg, IDC_PREFS_WWINFO, _("Word wrap cleartext &signatures at column"));
        SetDlgItemText (dlg, IDC_PREFS_DISABLE_HOTKEYS, _("&Disable hotkeys (Not recommended!)"));
        SetDlgItemText (dlg, IDC_PREFS_TRUST, _("Skip key validation and assume that keys are always fully trusted"));
        SetDlgItemText (dlg, IDC_PREFS_AUTOBACKUP, _("&Automatic keyring backup when WinPT closes"));
        SetDlgItemText (dlg, IDC_PREFS_BAKHOME, _("Backup to &keyring folder"));
        SetDlgItemText (dlg, IDC_PREFS_BAKUSER, _("Backup to:"));
        SetDlgItemText (dlg, IDC_PREFS_KEYLISTINF, _("Select &key list mode"));
        SetDlgItemText (dlg, IDC_PREFS_WIPEINF, _("Select &wipe mode"));
        SetDlgItemText (dlg, IDC_PREFS_KSINF, _("Keyserver &config"));
        SetDlgItemText (dlg, IDC_PREFS_CACHEINF, _("Cache &passphrases for 'n' seconds"));
        SetDlgItemText (dlg, IDC_PREFS_CACHEHINT, _("(CTRL+ALT+F to clear the cache)"));
        SetDlgItemText (dlg, IDC_PREFS_ALLOPTINF, _("General options"));
        SetDlgItemText (dlg, IDC_PREFS_CLIPINF, _("Clipboard hotkeys"));
        SetDlgItemText (dlg, IDC_PREFS_CURRINF, _("Current window hotkeys"));
        SetDlgItemText (dlg, IDC_PREFS_KSELFILE, _("Browse..."));
        SetDlgItemText (dlg, IDC_PREFS_BAKSELECT, _("Browse..."));
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));

        SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, reg_prefs.cache_time, TRUE);
        SetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, reg_prefs.word_wrap, TRUE);
        if (reg_prefs.backup.path)
            SetDlgItemText (dlg, IDC_PREFS_BAKPATH, reg_prefs.backup.path);

        for (i=0; (id=hotkeys[i]); i++)
            SetDlgItemText (dlg, id, reg_hotkeys[i].key);
        CheckDlgButton( dlg, IDC_PREFS_DISABLE_HOTKEYS, 
                        reg_prefs.no_hotkeys ? BST_CHECKED : BST_UNCHECKED );
        CheckDlgButton( dlg, IDC_PREFS_SECMODE, 
                        reg_prefs.use_tmpfiles ? BST_UNCHECKED : BST_CHECKED );
        CheckDlgButton( dlg, IDC_PREFS_VIEWER,
                        reg_prefs.use_viewer ? BST_CHECKED: BST_UNCHECKED );
        CheckDlgButton( dlg, IDC_PREFS_TRUST,
                        reg_prefs.always_trust? BST_CHECKED : BST_UNCHECKED );
        CheckDlgButton( dlg, IDC_PREFS_AUTOBACKUP,
                        reg_prefs.auto_backup? BST_CHECKED : BST_UNCHECKED );
        CheckDlgButton( dlg, IDC_PREFS_BAKHOME, 
                        reg_prefs.backup.mode==1? BST_CHECKED : BST_UNCHECKED );
        CheckDlgButton( dlg, IDC_PREFS_BAKUSER,
                        reg_prefs.backup.mode==2? BST_CHECKED : BST_UNCHECKED );
        if (reg_prefs.no_hotkeys)
            disable_hotkey_items (dlg, 1);
        if (!reg_prefs.auto_backup)
            enable_backup_items (dlg, 0);
        EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), 
                      reg_prefs.backup.mode==1?FALSE : TRUE);
        EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT),
                      reg_prefs.backup.mode==1? FALSE : TRUE);
        init_keylist_modes (dlg);
        init_wipe_modes (dlg);
        center_window (dlg, NULL);
        SetForegroundWindow (dlg);
        return TRUE;
        
    case WM_SYSCOMMAND:
        if (LOWORD (wparam) == SC_CLOSE)
            EndDialog (dlg, TRUE);
        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)
                reg_prefs.cache_time = 0;
            else if (rc > 3600) {
                msg_box( dlg, _("Please enter a value that is between 1-3600.\nIt is not "
                                "a good idea to cache the passphrase more than one hour."),
                                _("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;
            rc = GetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, NULL, FALSE);
            if (!rc)
                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_LISTMODE );
            reg_prefs.keylist_mode = SendMessage( cb, CB_GETCURSEL, 0, 0 );

            cb = GetDlgItem( dlg, IDC_PREFS_WIPEMODE );
            reg_prefs.wipe_mode = SendMessage( cb, CB_GETCURSEL, 0, 0 );
            
            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; (id = hotkeys[i]); i++ ) {
                    rc = GetDlgItemText( dlg, id, t, 2 );
                    if( rc && check_hotkey( &t[0] ) )
                        hotkey_enable( &reg_hotkeys[i], t );
                    else
                        hotkey_disable( &reg_hotkeys[i] );
                }
                set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "DisableHotkeys", "0");
                reg_prefs.no_hotkeys = 0;
            }

            if ((rc = set_reg_winpt_prefs (&reg_prefs)))
                msg_box (dlg, winpt_strerror (rc), _("Preferences"), MB_ERR);
            
            if (reg_prefs.no_hotkeys == 0) {
                hotkeys_unregister (glob_hwnd);
                hotkeys_modify ();
                if ((rc = hotkeys_register (glob_hwnd)))
                    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			* Copyright (C) 2001, 2002, 2003, 2005 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	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_SIGN,
47			IDC_PREFS_CLIP_SIGNENC,
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	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 combox in the dialog @dlg with the valid list modes. */
98			static void
99			init_keylist_modes (HWND dlg)
100			{
101			HWND cb = GetDlgItem (dlg, IDC_PREFS_LISTMODE);
102			combox_add_string (cb, (char *)"NORMAL");
103			combox_add_string (cb, (char *)"MINIMAL");
104			SendMessage (cb, CB_SETCURSEL, (WPARAM)reg_prefs.keylist_mode, 0);
105			}
106
107
108			/* Initialize the combobox in the dialog @dlg with the valid wipe modes. */
109			static void
110			init_wipe_modes (HWND dlg)
111			{
112			HWND cb = GetDlgItem (dlg, IDC_PREFS_WIPEMODE);
113			combox_add_string (cb, (char *)"Simple");
114			combox_add_string (cb, (char *)"DoD");
115			combox_add_string (cb, (char *)"Gutmann");
116			SendMessage (cb, CB_SETCURSEL, (WPARAM)reg_prefs.wipe_mode, 0);
117			}
118
119
120			/* Dialog box procedure for the WinPT preferences. */
121			BOOL CALLBACK
122			prefs_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
123			{
124			int rc;
125			int i, id;
126			char t[2];
127			char path[256], * p;
128			HWND cb;
129
130	twoaday	88	switch (msg) {
131	werner	36	case WM_INITDIALOG:
132			SetWindowText (dlg, _("WinPT Preferences"));
133			SetDlgItemText (dlg, IDC_PREFS_SECMODE, _("Do not use any &temporary files"));
134			SetDlgItemText (dlg, IDC_PREFS_VIEWER, _("Use clipboard &viewer to display the plaintext"));
135			SetDlgItemText (dlg, IDC_PREFS_WWINFO, _("Word wrap cleartext &signatures at column"));
136			SetDlgItemText (dlg, IDC_PREFS_DISABLE_HOTKEYS, _("&Disable hotkeys (Not recommended!)"));
137			SetDlgItemText (dlg, IDC_PREFS_TRUST, _("Skip key validation and assume that keys are always fully trusted"));
138			SetDlgItemText (dlg, IDC_PREFS_AUTOBACKUP, _("&Automatic keyring backup when WinPT closes"));
139	twoaday	144	SetDlgItemText (dlg, IDC_PREFS_BAKHOME, _("Backup to &keyring folder"));
140	werner	36	SetDlgItemText (dlg, IDC_PREFS_BAKUSER, _("Backup to:"));
141	twoaday	80	SetDlgItemText (dlg, IDC_PREFS_KEYLISTINF, _("Select &key list mode"));
142			SetDlgItemText (dlg, IDC_PREFS_WIPEINF, _("Select &wipe mode"));
143			SetDlgItemText (dlg, IDC_PREFS_KSINF, _("Keyserver &config"));
144			SetDlgItemText (dlg, IDC_PREFS_CACHEINF, _("Cache &passphrases for 'n' seconds"));
145			SetDlgItemText (dlg, IDC_PREFS_CACHEHINT, _("(CTRL+ALT+F to clear the cache)"));
146	twoaday	88	SetDlgItemText (dlg, IDC_PREFS_ALLOPTINF, _("General options"));
147			SetDlgItemText (dlg, IDC_PREFS_CLIPINF, _("Clipboard hotkeys"));
148			SetDlgItemText (dlg, IDC_PREFS_CURRINF, _("Current window hotkeys"));
149	twoaday	147	SetDlgItemText (dlg, IDC_PREFS_KSELFILE, _("Browse..."));
150			SetDlgItemText (dlg, IDC_PREFS_BAKSELECT, _("Browse..."));
151	twoaday	105	SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
152	twoaday	80
153	twoaday	117	SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, reg_prefs.cache_time, TRUE);
154			SetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, reg_prefs.word_wrap, TRUE);
155	werner	36	if (reg_prefs.backup.path)
156			SetDlgItemText (dlg, IDC_PREFS_BAKPATH, reg_prefs.backup.path);
157
158			for (i=0; (id=hotkeys[i]); i++)
159			SetDlgItemText (dlg, id, reg_hotkeys[i].key);
160			CheckDlgButton( dlg, IDC_PREFS_DISABLE_HOTKEYS,
161			reg_prefs.no_hotkeys ? BST_CHECKED : BST_UNCHECKED );
162			CheckDlgButton( dlg, IDC_PREFS_SECMODE,
163			reg_prefs.use_tmpfiles ? BST_UNCHECKED : BST_CHECKED );
164			CheckDlgButton( dlg, IDC_PREFS_VIEWER,
165			reg_prefs.use_viewer ? BST_CHECKED: BST_UNCHECKED );
166			CheckDlgButton( dlg, IDC_PREFS_TRUST,
167			reg_prefs.always_trust? BST_CHECKED : BST_UNCHECKED );
168			CheckDlgButton( dlg, IDC_PREFS_AUTOBACKUP,
169			reg_prefs.auto_backup? BST_CHECKED : BST_UNCHECKED );
170			CheckDlgButton( dlg, IDC_PREFS_BAKHOME,
171			reg_prefs.backup.mode==1? BST_CHECKED : BST_UNCHECKED );
172			CheckDlgButton( dlg, IDC_PREFS_BAKUSER,
173			reg_prefs.backup.mode==2? BST_CHECKED : BST_UNCHECKED );
174	twoaday	117	if (reg_prefs.no_hotkeys)
175			disable_hotkey_items (dlg, 1);
176	werner	36	if (!reg_prefs.auto_backup)
177			enable_backup_items (dlg, 0);
178			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH),
179			reg_prefs.backup.mode==1?FALSE : TRUE);
180			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT),
181			reg_prefs.backup.mode==1? FALSE : TRUE);
182			init_keylist_modes (dlg);
183			init_wipe_modes (dlg);
184			center_window (dlg, NULL);
185			SetForegroundWindow (dlg);
186			return TRUE;
187
188			case WM_SYSCOMMAND:
189			if (LOWORD (wparam) == SC_CLOSE)
190			EndDialog (dlg, TRUE);
191			return FALSE;
192
193			case WM_COMMAND:
194			switch( HIWORD(wparam) ) {
195			case BN_CLICKED:
196			switch( (int)LOWORD( wparam ) ) {
197			case IDC_PREFS_DISABLE_HOTKEYS:
198			reg_prefs.no_hotkeys ^= 1;
199	twoaday	117	disable_hotkey_items (dlg, reg_prefs.no_hotkeys);
200	werner	36	break;
201
202			case IDC_PREFS_TRUST:
203			reg_prefs.always_trust ^= 1;
204	twoaday	117	if (reg_prefs.always_trust) {
205	werner	36	msg_box (dlg,
206			_("In most cases it is not a good idea to enable this setting.\n"
207			"If you know what you are doing let this flag enabled, otherwise\n"
208			"it is safe to leave this flag untouched."),
209	twoaday	117	_("Preferences"), MB_ICONWARNING\|MB_OK);
210	werner	36	}
211			break;
212
213			case IDC_PREFS_AUTOBACKUP:
214			reg_prefs.auto_backup ^= 1;
215			enable_backup_items (dlg, reg_prefs.auto_backup);
216			if (reg_prefs.auto_backup == 1) {
217			if (!IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME) &&
218			!IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
219			CheckDlgButton (dlg, IDC_PREFS_BAKHOME, BST_CHECKED);
220			}
221	twoaday	130	if (IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME))
222			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
223	werner	36	break;
224
225			case IDC_PREFS_BAKHOME:
226			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), FALSE);
227			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
228			break;
229
230			case IDC_PREFS_BAKUSER:
231			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), TRUE);
232			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), TRUE);
233			break;
234			}
235			break;
236			}
237			switch( LOWORD( wparam ) ) {
238			case IDC_PREFS_BAKSELECT:
239			const char *bpath;
240			bpath = get_folder_dlg (dlg, _("Select GPG backup path"), NULL);
241			if (bpath)
242			SetDlgItemText (dlg, IDC_PREFS_BAKPATH, bpath);
243			break;
244
245			case IDOK:
246			rc = GetDlgItemInt( dlg, IDC_PREFS_CACHETIME, NULL, FALSE );
247	twoaday	117	if (!rc)
248	werner	36	reg_prefs.cache_time = 0;
249	twoaday	117	else if (rc > 3600) {
250	werner	36	msg_box( dlg, _("Please enter a value that is between 1-3600.\nIt is not "
251			"a good idea to cache the passphrase more than one hour."),
252	twoaday	117	_("Preferences"), MB_ERR);
253			SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, 0, FALSE);
254	werner	36	return TRUE;
255			}
256			if (reg_prefs.cache_time != rc)
257			agent_flush_cache ();
258			reg_prefs.cache_time = rc;
259	twoaday	117	rc = GetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, NULL, FALSE);
260			if (!rc)
261	werner	36	reg_prefs.word_wrap = 0;
262	twoaday	117	else if (rc > 80) {
263			msg_box (dlg, _("Please enter a value between 1-80."), _("Preferences"), MB_ERR);
264	werner	36	return TRUE;
265			}
266			reg_prefs.word_wrap = rc;
267			reg_prefs.use_tmpfiles = IsDlgButtonChecked( dlg, IDC_PREFS_SECMODE )? 0 : 1;
268			reg_prefs.use_viewer = IsDlgButtonChecked( dlg, IDC_PREFS_VIEWER )? 1 : 0;
269			reg_prefs.backup.mode = IsDlgButtonChecked( dlg, IDC_PREFS_BAKHOME ) ? 1 :
270			IsDlgButtonChecked( dlg, IDC_PREFS_BAKUSER )? 2 : 0;
271			if( reg_prefs.backup.mode == 2 ) {
272			if( !GetDlgItemText( dlg, IDC_PREFS_BAKPATH, path, sizeof (path)-1 )
273			\|\| dir_exist_check( path ) ) {
274			msg_box( dlg, _("The specified backup folder is invalid."),
275			_("Preferences"), MB_ERR );
276			return TRUE;
277			}
278			free_if_alloc (reg_prefs.backup.path);
279			p = reg_prefs.backup.path = m_strdup (path);
280			if (!p)
281			BUG (0);
282			}
283
284			cb = GetDlgItem( dlg, IDC_PREFS_LISTMODE );
285			reg_prefs.keylist_mode = SendMessage( cb, CB_GETCURSEL, 0, 0 );
286
287			cb = GetDlgItem( dlg, IDC_PREFS_WIPEMODE );
288			reg_prefs.wipe_mode = SendMessage( cb, CB_GETCURSEL, 0, 0 );
289
290			if (IsDlgButtonChecked (dlg, IDC_PREFS_DISABLE_HOTKEYS)) {
291			hotkeys_unregister (glob_hwnd);
292			reg_prefs.no_hotkeys = 1;
293			}
294			else {
295			reg_prefs.no_hotkeys = 0;
296			for( i = 0; (id = hotkeys[i]); i++ ) {
297			rc = GetDlgItemText( dlg, id, t, 2 );
298			if( rc && check_hotkey( &t[0] ) )
299			hotkey_enable( &reg_hotkeys[i], t );
300			else
301			hotkey_disable( &reg_hotkeys[i] );
302			}
303			set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "DisableHotkeys", "0");
304			reg_prefs.no_hotkeys = 0;
305			}
306
307			if ((rc = set_reg_winpt_prefs (&reg_prefs)))
308			msg_box (dlg, winpt_strerror (rc), _("Preferences"), MB_ERR);
309
310			if (reg_prefs.no_hotkeys == 0) {
311			hotkeys_unregister (glob_hwnd);
312			hotkeys_modify ();
313			if ((rc = hotkeys_register (glob_hwnd)))
314			msg_box (NULL, winpt_strerror (rc), _("Hotkeys"), MB_ERR);
315			}
316			EndDialog (dlg, TRUE);
317			return TRUE;
318
319			case IDCANCEL:
320	twoaday	117	/* Reset backup mode if no mode was chosen. */
321			if (reg_prefs.auto_backup == 1 &&
322			!IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME) &&
323			!IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
324			reg_prefs.auto_backup = 0;
325			EndDialog (dlg, FALSE);
326	werner	36	return FALSE;
327			}
328			break;
329			}
330
331			return FALSE;
332			}