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 GPG &home 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, 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);
                }
                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			SetDlgItemText (dlg, IDC_PREFS_BAKHOME, _("Backup to GPG &home folder"));
140			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	105	SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
150	twoaday	80
151	twoaday	117	SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, reg_prefs.cache_time, TRUE);
152			SetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, reg_prefs.word_wrap, TRUE);
153	werner	36	if (reg_prefs.backup.path)
154			SetDlgItemText (dlg, IDC_PREFS_BAKPATH, reg_prefs.backup.path);
155			if (reg_prefs.kserv_conf)
156			SetDlgItemText (dlg, IDC_PREFS_KSERVER, reg_prefs.kserv_conf);
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			break;
222
223			case IDC_PREFS_BAKHOME:
224			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), FALSE);
225			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), FALSE);
226			break;
227
228			case IDC_PREFS_BAKUSER:
229			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKSELECT), TRUE);
230			EnableWindow (GetDlgItem (dlg, IDC_PREFS_BAKPATH), TRUE);
231			break;
232			}
233			break;
234			}
235			switch( LOWORD( wparam ) ) {
236			case IDC_PREFS_BAKSELECT:
237			const char *bpath;
238			bpath = get_folder_dlg (dlg, _("Select GPG backup path"), NULL);
239			if (bpath)
240			SetDlgItemText (dlg, IDC_PREFS_BAKPATH, bpath);
241			break;
242
243			case IDC_PREFS_KSELFILE: {
244			const char * name;
245	twoaday	77	name = get_fileopen_dlg (dlg, _("Please select a keyserver.conf file"),
246	werner	36	NULL, NULL);
247			if (name != NULL)
248			SetDlgItemText (dlg, IDC_PREFS_KSERVER, name);
249			break; }
250
251			case IDOK:
252			rc = GetDlgItemInt( dlg, IDC_PREFS_CACHETIME, NULL, FALSE );
253	twoaday	117	if (!rc)
254	werner	36	reg_prefs.cache_time = 0;
255	twoaday	117	else if (rc > 3600) {
256	werner	36	msg_box( dlg, _("Please enter a value that is between 1-3600.\nIt is not "
257			"a good idea to cache the passphrase more than one hour."),
258	twoaday	117	_("Preferences"), MB_ERR);
259			SetDlgItemInt (dlg, IDC_PREFS_CACHETIME, 0, FALSE);
260	werner	36	return TRUE;
261			}
262			if (reg_prefs.cache_time != rc)
263			agent_flush_cache ();
264			reg_prefs.cache_time = rc;
265	twoaday	117	rc = GetDlgItemInt (dlg, IDC_PREFS_WORDWRAP, NULL, FALSE);
266			if (!rc)
267	werner	36	reg_prefs.word_wrap = 0;
268	twoaday	117	else if (rc > 80) {
269			msg_box (dlg, _("Please enter a value between 1-80."), _("Preferences"), MB_ERR);
270	werner	36	return TRUE;
271			}
272			reg_prefs.word_wrap = rc;
273			reg_prefs.use_tmpfiles = IsDlgButtonChecked( dlg, IDC_PREFS_SECMODE )? 0 : 1;
274			reg_prefs.use_viewer = IsDlgButtonChecked( dlg, IDC_PREFS_VIEWER )? 1 : 0;
275			reg_prefs.backup.mode = IsDlgButtonChecked( dlg, IDC_PREFS_BAKHOME ) ? 1 :
276			IsDlgButtonChecked( dlg, IDC_PREFS_BAKUSER )? 2 : 0;
277			if( reg_prefs.backup.mode == 2 ) {
278			if( !GetDlgItemText( dlg, IDC_PREFS_BAKPATH, path, sizeof (path)-1 )
279			\|\| dir_exist_check( path ) ) {
280			msg_box( dlg, _("The specified backup folder is invalid."),
281			_("Preferences"), MB_ERR );
282			return TRUE;
283			}
284			free_if_alloc (reg_prefs.backup.path);
285			p = reg_prefs.backup.path = m_strdup (path);
286			if (!p)
287			BUG (0);
288			}
289			free_if_alloc (reg_prefs.kserv_conf);
290			if (!GetDlgItemText (dlg, IDC_PREFS_KSERVER, path, sizeof (path)-1)
291			\|\| file_exist_check (path)) {
292			rc = msg_box (dlg, _("The specified keyserver config file is invalid.\n\n"
293			"Create new default config file?"),
294			_("Preferences"), MB_ERR\|MB_YESNO);
295			if (rc == IDNO)
296			return TRUE;
297			else
298			{
299			char cwd[256], * fn;
300			FILE * fp = fopen ("keyserver.conf", "wb");
301			if (fp) {
302			fprintf (fp, "%s\r\n", DEF_HKP_KEYSERVER);
303			fclose (fp);
304			}
305			GetCurrentDirectory (DIM (cwd)-1, cwd);
306			fn = make_filename (cwd, "keyserver", "conf");
307			memset (path, 0, sizeof( path));
308			strncpy (path, fn, DIM (path)-1);
309			free_if_alloc (fn);
310			}
311			}
312			p = reg_prefs.kserv_conf = m_strdup (path);
313			if (!p)
314			BUG (0);
315
316			cb = GetDlgItem( dlg, IDC_PREFS_LISTMODE );
317			reg_prefs.keylist_mode = SendMessage( cb, CB_GETCURSEL, 0, 0 );
318
319			cb = GetDlgItem( dlg, IDC_PREFS_WIPEMODE );
320			reg_prefs.wipe_mode = SendMessage( cb, CB_GETCURSEL, 0, 0 );
321
322			if (IsDlgButtonChecked (dlg, IDC_PREFS_DISABLE_HOTKEYS)) {
323			hotkeys_unregister (glob_hwnd);
324			reg_prefs.no_hotkeys = 1;
325			}
326			else {
327			reg_prefs.no_hotkeys = 0;
328			for( i = 0; (id = hotkeys[i]); i++ ) {
329			rc = GetDlgItemText( dlg, id, t, 2 );
330			if( rc && check_hotkey( &t[0] ) )
331			hotkey_enable( &reg_hotkeys[i], t );
332			else
333			hotkey_disable( &reg_hotkeys[i] );
334			}
335			set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "DisableHotkeys", "0");
336			reg_prefs.no_hotkeys = 0;
337			}
338
339			if ((rc = set_reg_winpt_prefs (&reg_prefs)))
340			msg_box (dlg, winpt_strerror (rc), _("Preferences"), MB_ERR);
341
342			if (reg_prefs.no_hotkeys == 0) {
343			hotkeys_unregister (glob_hwnd);
344			hotkeys_modify ();
345			if ((rc = hotkeys_register (glob_hwnd)))
346			msg_box (NULL, winpt_strerror (rc), _("Hotkeys"), MB_ERR);
347			}
348			EndDialog (dlg, TRUE);
349			return TRUE;
350
351			case IDCANCEL:
352	twoaday	117	/* Reset backup mode if no mode was chosen. */
353			if (reg_prefs.auto_backup == 1 &&
354			!IsDlgButtonChecked (dlg, IDC_PREFS_BAKHOME) &&
355			!IsDlgButtonChecked (dlg, IDC_PREFS_BAKUSER))
356			reg_prefs.auto_backup = 0;
357			EndDialog (dlg, FALSE);
358	werner	36	return FALSE;
359			}
360			break;
361			}
362
363			return FALSE;
364			}