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);
        if (reg_prefs.kserv_conf)
            SetDlgItemText (dlg, IDC_PREFS_KSERVER, reg_prefs.kserv_conf);

        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 IDC_PREFS_KSELFILE: {
            const char * name;
            name = get_fileopen_dlg (dlg, _("Please select a keyserver.conf file"),
                                     NULL, NULL);
            if (name != NULL)
                SetDlgItemText (dlg, IDC_PREFS_KSERVER, name);
            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);
            }
            free_if_alloc (reg_prefs.kserv_conf);
            if (!GetDlgItemText (dlg, IDC_PREFS_KSERVER, path, sizeof (path)-1)
                || file_exist_check (path)) {
                rc = msg_box (dlg, _("The specified keyserver config file is invalid.\n\n"
                                     "Create new default config file?"),
                         _("Preferences"), MB_ERR|MB_YESNO);
                if (rc == IDNO)
                    return TRUE;
                else
                {
                    char cwd[256], * fn;
                    FILE * fp = fopen ("keyserver.conf", "wb");
                    if (fp) {
                        fprintf (fp, "%s\r\n", DEF_HKP_KEYSERVER);
                        fclose (fp);
                    }
                    GetCurrentDirectory (DIM (cwd)-1, cwd);
                    fn = make_filename (cwd, "keyserver", "conf");
                    memset (path, 0, sizeof( path));
                    strncpy (path, fn, DIM (path)-1);
                    free_if_alloc (fn);
                }
            }
            p = reg_prefs.kserv_conf = 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			if (reg_prefs.kserv_conf)
158			SetDlgItemText (dlg, IDC_PREFS_KSERVER, reg_prefs.kserv_conf);
159
160			for (i=0; (id=hotkeys[i]); i++)
161			SetDlgItemText (dlg, id, reg_hotkeys[i].key);
162			CheckDlgButton( dlg, IDC_PREFS_DISABLE_HOTKEYS,
163			reg_prefs.no_hotkeys ? BST_CHECKED : BST_UNCHECKED );
164			CheckDlgButton( dlg, IDC_PREFS_SECMODE,
165			reg_prefs.use_tmpfiles ? BST_UNCHECKED : BST_CHECKED );
166			CheckDlgButton( dlg, IDC_PREFS_VIEWER,
167			reg_prefs.use_viewer ? BST_CHECKED: BST_UNCHECKED );
168			CheckDlgButton( dlg, IDC_PREFS_TRUST,
169			reg_prefs.always_trust? BST_CHECKED : BST_UNCHECKED );
170			CheckDlgButton( dlg, IDC_PREFS_AUTOBACKUP,
171			reg_prefs.auto_backup? BST_CHECKED : BST_UNCHECKED );
172			CheckDlgButton( dlg, IDC_PREFS_BAKHOME,
173			reg_prefs.backup.mode==1? BST_CHECKED : BST_UNCHECKED );
174			CheckDlgButton( dlg, IDC_PREFS_BAKUSER,
175			reg_prefs.backup.mode==2? BST_CHECKED : BST_UNCHECKED );
176	twoaday	117	if (reg_prefs.no_hotkeys)
177			disable_hotkey_items (dlg, 1);
178	werner	36	if (!reg_prefs.auto_backup)
179			enable_backup_items (dlg, 0);
180			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH),
181			reg_prefs.backup.mode==1?FALSE : TRUE);
182			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT),
183			reg_prefs.backup.mode==1? FALSE : TRUE);
184			init_keylist_modes (dlg);
185			init_wipe_modes (dlg);
186			center_window (dlg, NULL);
187			SetForegroundWindow (dlg);
188			return TRUE;
189
190			case WM_SYSCOMMAND:
191			if (LOWORD (wparam) == SC_CLOSE)
192			EndDialog (dlg, TRUE);
193			return FALSE;
194
195			case WM_COMMAND:
196			switch( HIWORD(wparam) ) {
197			case BN_CLICKED:
198			switch( (int)LOWORD( wparam ) ) {
199			case IDC_PREFS_DISABLE_HOTKEYS:
200			reg_prefs.no_hotkeys ^= 1;
201	twoaday	117	disable_hotkey_items (dlg, reg_prefs.no_hotkeys);
202	werner	36	break;
203
204			case IDC_PREFS_TRUST:
205			reg_prefs.always_trust ^= 1;
206	twoaday	117	if (reg_prefs.always_trust) {
207	werner	36	msg_box (dlg,
208			_("In most cases it is not a good idea to enable this setting.\n"
209			"If you know what you are doing let this flag enabled, otherwise\n"
210			"it is safe to leave this flag untouched."),
211	twoaday	117	_("Preferences"), MB_ICONWARNING\|MB_OK);
212	werner	36	}
213			break;
214
215			case IDC_PREFS_AUTOBACKUP:
216			reg_prefs.auto_backup ^= 1;
217			enable_backup_items (dlg, reg_prefs.auto_backup);
218			if (reg_prefs.auto_backup == 1) {
219			if (!IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME) &&
220			!IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
221			CheckDlgButton (dlg, IDC_PREFS_BAKHOME, BST_CHECKED);
222			}
223	twoaday	130	if (IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME))
224			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
225	werner	36	break;
226
227			case IDC_PREFS_BAKHOME:
228			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), FALSE);
229			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
230			break;
231
232			case IDC_PREFS_BAKUSER:
233			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), TRUE);
234			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), TRUE);
235			break;
236			}
237			break;
238			}
239			switch( LOWORD( wparam ) ) {
240			case IDC_PREFS_BAKSELECT:
241			const char *bpath;
242			bpath = get_folder_dlg (dlg, _("Select GPG backup path"), NULL);
243			if (bpath)
244			SetDlgItemText (dlg, IDC_PREFS_BAKPATH, bpath);
245			break;
246
247			case IDC_PREFS_KSELFILE: {
248			const char * name;
249	twoaday	77	name = get_fileopen_dlg (dlg, _("Please select a keyserver.conf file"),
250	werner	36	NULL, NULL);
251			if (name != NULL)
252			SetDlgItemText (dlg, IDC_PREFS_KSERVER, name);
253			break; }
254
255			case IDOK:
256			rc = GetDlgItemInt( dlg, IDC_PREFS_CACHETIME, NULL, FALSE );
257	twoaday	117	if (!rc)
258	werner	36	reg_prefs.cache_time = 0;
259	twoaday	117	else if (rc > 3600) {
260	werner	36	msg_box( dlg, _("Please enter a value that is between 1-3600.\nIt is not "
261			"a good idea to cache the passphrase more than one hour."),
262	twoaday	117	_("Preferences"), MB_ERR);
263			SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, 0, FALSE);
264	werner	36	return TRUE;
265			}
266			if (reg_prefs.cache_time != rc)
267			agent_flush_cache ();
268			reg_prefs.cache_time = rc;
269	twoaday	117	rc = GetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, NULL, FALSE);
270			if (!rc)
271	werner	36	reg_prefs.word_wrap = 0;
272	twoaday	117	else if (rc > 80) {
273			msg_box (dlg, _("Please enter a value between 1-80."), _("Preferences"), MB_ERR);
274	werner	36	return TRUE;
275			}
276			reg_prefs.word_wrap = rc;
277			reg_prefs.use_tmpfiles = IsDlgButtonChecked( dlg, IDC_PREFS_SECMODE )? 0 : 1;
278			reg_prefs.use_viewer = IsDlgButtonChecked( dlg, IDC_PREFS_VIEWER )? 1 : 0;
279			reg_prefs.backup.mode = IsDlgButtonChecked( dlg, IDC_PREFS_BAKHOME ) ? 1 :
280			IsDlgButtonChecked( dlg, IDC_PREFS_BAKUSER )? 2 : 0;
281			if( reg_prefs.backup.mode == 2 ) {
282			if( !GetDlgItemText( dlg, IDC_PREFS_BAKPATH, path, sizeof (path)-1 )
283			\|\| dir_exist_check( path ) ) {
284			msg_box( dlg, _("The specified backup folder is invalid."),
285			_("Preferences"), MB_ERR );
286			return TRUE;
287			}
288			free_if_alloc (reg_prefs.backup.path);
289			p = reg_prefs.backup.path = m_strdup (path);
290			if (!p)
291			BUG (0);
292			}
293			free_if_alloc (reg_prefs.kserv_conf);
294			if (!GetDlgItemText (dlg, IDC_PREFS_KSERVER, path, sizeof (path)-1)
295			\|\| file_exist_check (path)) {
296			rc = msg_box (dlg, _("The specified keyserver config file is invalid.\n\n"
297			"Create new default config file?"),
298			_("Preferences"), MB_ERR\|MB_YESNO);
299			if (rc == IDNO)
300			return TRUE;
301			else
302			{
303			char cwd[256], * fn;
304			FILE * fp = fopen ("keyserver.conf", "wb");
305			if (fp) {
306			fprintf (fp, "%s\r\n", DEF_HKP_KEYSERVER);
307			fclose (fp);
308			}
309			GetCurrentDirectory (DIM (cwd)-1, cwd);
310			fn = make_filename (cwd, "keyserver", "conf");
311			memset (path, 0, sizeof( path));
312			strncpy (path, fn, DIM (path)-1);
313			free_if_alloc (fn);
314			}
315			}
316			p = reg_prefs.kserv_conf = m_strdup (path);
317			if (!p)
318			BUG (0);
319
320			cb = GetDlgItem( dlg, IDC_PREFS_LISTMODE );
321			reg_prefs.keylist_mode = SendMessage( cb, CB_GETCURSEL, 0, 0 );
322
323			cb = GetDlgItem( dlg, IDC_PREFS_WIPEMODE );
324			reg_prefs.wipe_mode = SendMessage( cb, CB_GETCURSEL, 0, 0 );
325
326			if (IsDlgButtonChecked (dlg, IDC_PREFS_DISABLE_HOTKEYS)) {
327			hotkeys_unregister (glob_hwnd);
328			reg_prefs.no_hotkeys = 1;
329			}
330			else {
331			reg_prefs.no_hotkeys = 0;
332			for( i = 0; (id = hotkeys[i]); i++ ) {
333			rc = GetDlgItemText( dlg, id, t, 2 );
334			if( rc && check_hotkey( &t[0] ) )
335			hotkey_enable( &reg_hotkeys[i], t );
336			else
337			hotkey_disable( &reg_hotkeys[i] );
338			}
339			set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "DisableHotkeys", "0");
340			reg_prefs.no_hotkeys = 0;
341			}
342
343			if ((rc = set_reg_winpt_prefs (&reg_prefs)))
344			msg_box (dlg, winpt_strerror (rc), _("Preferences"), MB_ERR);
345
346			if (reg_prefs.no_hotkeys == 0) {
347			hotkeys_unregister (glob_hwnd);
348			hotkeys_modify ();
349			if ((rc = hotkeys_register (glob_hwnd)))
350			msg_box (NULL, winpt_strerror (rc), _("Hotkeys"), MB_ERR);
351			}
352			EndDialog (dlg, TRUE);
353			return TRUE;
354
355			case IDCANCEL:
356	twoaday	117	/* Reset backup mode if no mode was chosen. */
357			if (reg_prefs.auto_backup == 1 &&
358			!IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME) &&
359			!IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
360			reg_prefs.auto_backup = 0;
361			EndDialog (dlg, FALSE);
362	werner	36	return FALSE;
363			}
364			break;
365			}
366
367			return FALSE;
368			}