trunk/Src/wptMainProc.cpp

/* wptMainProc.cpp - Main window procedure
 *      Copyright (C) 2000-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

#define _WIN32_IE 0x0600

#include <windows.h>
#include <commctrl.h>
#include <io.h>

#include "resource.h"
#include "wptTypes.h"
#include "wptGPG.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptCommonCtl.h"
#include "wptContext.h" /* for passphrase_s */
#include "wptDlgs.h"
#include "wptErrors.h"
#include "wptNLS.h"
#include "wptHotkey.h"
#include "wptRegistry.h"
#include "wptKeyserver.h"
#include "wptAgent.h"
#include "wptUTF8.h"
#include "wptKeyManager.h"
#include "wptCard.h"
#include "wptCardEdit.h"


int update_keycache (HWND hwnd);

/* Command for the Key Manager dialog. (0=no command) */
static int cmd = 0;

/* 1 indicates that the clipboard will be emptied o exit. */
static int wipe_contents = 0;


/* Dialog box procedure to display all insecure all ElGamal keys. */
BOOL CALLBACK
elgamal_warn_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    gpg_keycache_t pc;
    gpgme_key_t key;
    char *uid;
    char tmp[128+64+1];

    switch (msg) {
    case WM_INITDIALOG:
        pc = keycache_get_ctx (1);
        while (!gpg_keycache_next_key (pc, 0, &key)) {
            if (key->subkeys->pubkey_algo == GPGME_PK_ELG) {
                uid = utf8_to_native (key->uids->uid);
                _snprintf (tmp, sizeof (tmp)-1, "(0x%s) %s",
                           key->subkeys->keyid+8, uid);
                SendDlgItemMessage (dlg, IDC_ELGWARN_LIST, LB_ADDSTRING,
                                    0, (LPARAM)(const char *)tmp);
                free_if_alloc (uid);
            }
        }
        gpg_keycache_rewind (pc);
        center_window (dlg, NULL);
        SetForegroundWindow (dlg);
        break;

    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDOK:
            EndDialog (dlg, TRUE);
            break;
        }
        break;
    }
    return FALSE;
}


/* Dialog box procedure to confirm to delete the clipboard contents. */
static BOOL CALLBACK
confirm_delclipboard_dlg (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    switch (msg) {
    case WM_INITDIALOG:
        SetWindowText (dlg, _("Delete Clipboard Contents"));
        SetDlgItemText (dlg, IDC_CONFDELCLIP_BRAIN, 
                        _("&Remember the answer"));
        SetDlgItemText (dlg, IDC_CONFDELCLIP_INFO, 
                        _("Do you want to delete the contents from the clipboard?"));
        SetDlgItemText (dlg, IDYES, _("&Yes"));
        SetDlgItemText (dlg, IDNO, _("&No"));
        center_window (dlg, NULL);
        SetForegroundWindow (dlg);
        break;

    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDYES:
            wipe_contents = 1;
            if (IsDlgButtonChecked (dlg, IDC_CONFDELCLIP_BRAIN))
                set_reg_winpt_flag ("WipeClipboard", 1);
            EndDialog (dlg, 1);
            break;

        case IDNO:
            wipe_contents = 0;
            if (IsDlgButtonChecked (dlg, IDC_CONFDELCLIP_BRAIN))
                set_reg_winpt_flag ("WipeClipboard", 0);
            EndDialog (dlg, 0);
            break;
        }
        break;
    }
    return FALSE;
}


/* Handle the various command requests for the clipboard
   and the current window. */
static void
clip_gpg_dlg (HWND hwnd, UINT id, int *r_upd_window)
{
    gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
    int type;
    int disable_viewer = 0;
    
    if (r_upd_window) {
        *r_upd_window = 1;
        /* for the current window mode it makes no sense to
           use the clipboard viewer for decryption because the
           text will be pasted directly into the window. */
        disable_viewer = 1;
    }
    if ((id == ID_WINPT_SIGN || id == ID_WINPT_SIGNENCRYPT)
        && gnupg_access_keyring (0)) {
        msg_box (hwnd, _("Could not access secret keyring."), _("Sign"), MB_ERR);
        return;
    }
    
    switch (id) {
    case ID_WINPT_SYMENC:
    case ID_WINPT_CURRWND_SYMENC:
        err = gpg_clip_sym_encrypt ();
        if (err && r_upd_window)
            *r_upd_window = 0;
        break;
        
    case ID_WINPT_ENCRYPT:
    case ID_WINPT_CURRWND_ENCRYPT:
        dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_ENCRYPT, hwnd, 
                          clip_encrypt_dlg_proc, 0,
                          _("Encryption"), IDS_WINPT_ENCRYPT);
        break;
        
    case ID_WINPT_SIGN:
    case ID_WINPT_CURRWND_SIGN:
        dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_SIGN, hwnd, 
                          clip_sign_dlg_proc, 0, 
                          _("Signing"), IDS_WINPT_SIGN);
        break;
        
    case ID_WINPT_SIGNENCRYPT:
    case ID_WINPT_CURRWND_SIGNENCRYPT:
        dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_SIGNENC, hwnd, 
                          clip_signenc_dlg_proc, 0, 
                          _("Sign & Encrypt"), IDS_WINPT_SIGNENC);
        break;
        
    case ID_WINPT_DECRYPT_VERIFY:
    case ID_WINPT_CURRWND_DECRYPT_VERIFY:
        err = gpg_clip_get_pgptype (&type);
        if (err) {
            msg_box (hwnd, gpgme_strerror (err), _("Clipboard"), MB_ERR);
            if (r_upd_window)
                *r_upd_window = 0;
            break;
        }
        if ((type & PGP_MESSAGE) && !(type & PGP_CLEARSIG))
            err = clip_decrypt_dlg (hwnd, disable_viewer? 
                                          0 : reg_prefs.use_viewer);
        else if ((type & PGP_SIG) && !(type & PGP_CLEARSIG)) {
            text_input_s input;
            gpgme_data_t sig;
            
            memset (&input, 0, sizeof (input));
            err = gpg_data_new_from_clipboard (&sig, 0);
            if (err) {
                msg_box (hwnd, gpgme_strerror (err),_("Verify"), MB_ERR);
                if (r_upd_window)
                    *r_upd_window = 0;
                return;
            }
            input.type = 0;
            dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_TEXT, hwnd,
                              text_input_dlg_proc, (LPARAM)&input, 
                              _("Text Input"), IDS_WINPT_TEXT);
            
            /* the dialog might have changed the clipboard, so we restore
               the original state (again). */
            gpg_data_release_and_set_clipboard (sig, 0);
            if (input.length > 0) {
                dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_VERIFY, hwnd,
                                  clip_verify_dlg_proc, (LPARAM)&input,
                                  _("Verify"), IDS_WINPT_VERIFY);
                input.length = 0;
                free_if_alloc (input.data);
            }
            if (r_upd_window)
                *r_upd_window = 0;
        }
        else if (type & PGP_CLEARSIG) {
            dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_VERIFY, hwnd,
                              clip_verify_dlg_proc, 0,
                              _("Verify"), IDS_WINPT_VERIFY);
            if (r_upd_window)
                *r_upd_window = 0;
        }
        else if ((type & PGP_PUBKEY) || (type & PGP_SECKEY)) {
            km_clip_import (GetDesktopWindow (), NULL, NULL);
            if (r_upd_window)
                *r_upd_window = 0;
        }
        else {
            msg_box (hwnd, _("Unknown OpenPGP type."), _("Clipboard"), MB_ERR);
            if (r_upd_window)
                *r_upd_window = 0;
        }
    }
}


/* Load the Card Manager with the current card. */
static void
load_card_manager (void)
{
    gpg_card_t card;

    card = gpg_card_load ();
    if (!card)
        return;

    dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_CARD_EDIT,
                      GetDesktopWindow (), card_edit_dlg_proc,
                      (LPARAM)card,
                       _("Card Edit"), IDS_WINPT_CARD_EDIT);
    gpg_card_release (card);
}


/* Add the winpt symbol to the task bar. */
static void
add_taskbar_icon (HWND hwnd, NOTIFYICONDATA *nid)
{
    nid->cbSize = sizeof (NOTIFYICONDATA);
    nid->uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
    nid->uCallbackMessage = WM_USER;
    nid->hWnd = hwnd;
    nid->hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
    strcpy (nid->szTip, "Windows Privacy Tray v"PGM_VERSION);
    Shell_NotifyIcon (NIM_ADD, nid);
    DestroyIcon (nid->hIcon);
}


/* Initialize all needed common controls. */
static void
init_common_controls (void)
{
    INITCOMMONCONTROLSEX cce;

    /* date control, toolbar, trackbar, ... */
    cce.dwSize = sizeof (INITCOMMONCONTROLSEX);
    cce.dwICC = ICC_DATE_CLASSES|ICC_BAR_CLASSES;
    InitCommonControlsEx (&cce);
}


/* Wipe the clipboard if the user requested it. */
static void
wipe_clipboard (int manual_shutdown)
{
    int has_data = 0;

    if (!gpg_clip_istext_avail (&has_data) && has_data) {
        int chk = get_reg_winpt_flag ("WipeClipboard");
        if (chk == -1 && manual_shutdown)
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_CONFDELCLIP,
                            GetDesktopWindow (), confirm_delclipboard_dlg, 0);
        if (wipe_contents || chk)
            set_clip_text (NULL, " ", 1);    
        wipe_contents = 0;
    }
}


/* Main message loop for the tray window. */
LRESULT CALLBACK 
winpt_main_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{               
    static NOTIFYICONDATA NID;
    static DWORD cookie;
    static int use_hotkey = 0;
    static int manual_shutdown = 0;
    HWND wnd;
    gpgme_error_t err;
    curr_wnd_ctx currwnd = {0};
    const char *s;
    int rc, set_wc = 0;
    int has_data = 0;

    switch (msg) {
    case WM_CREATE:
        add_taskbar_icon (hwnd, &NID);
        rc = wsock_init ();
        if (rc)
            msg_box (NULL, winpt_strerror (rc), "Winsock2 DLL", MB_ERR);
        if (!reg_prefs.no_hotkeys) {
            rc = hotkeys_register (hwnd);
            if (rc)
                msg_box (hwnd, hotkeys_strerror (), winpt_strerror (rc), MB_ERR);
        }
        rc = PTD_initialize ();
        if (!rc)
            msg_box (hwnd, _("Could not set current window mode hooks."), 
                     _("WinPT Error"), MB_OK);
        mapi_init ();
        init_common_controls ();
        html_help_init (&cookie);
        LoadLibrary ("RichEd32.Dll");
        manual_shutdown = 0;
        break;
        
    case WM_ENDSESSION:
    case WM_DESTROY:
    case WM_CLOSE:
    case WM_QUIT:
        mapi_deinit ();
        wsock_end ();        
        keycache_release (1);
        gnupg_backup_keyrings (reg_prefs.auto_backup, 
                               reg_prefs.backup.mode,
                               reg_prefs.backup.include_secr);
        free_reg_prefs ();      
        free_gnupg_table ();
        gettext_free_current_domain ();
        hotkeys_unregister (hwnd);
        PTD_delete ();
        agent_flush_cache ();
        html_help_deinit (cookie);
        wipe_clipboard (manual_shutdown);
        debug_end ();
        Shell_NotifyIcon (NIM_DELETE, &NID);
        PostQuitMessage (0);
        ExitProcess (0);
        break;
        
    case WM_USER:
        switch (lparam) {
        case WM_RBUTTONUP:
            HMENU hm, popup;
            POINT p;

            if (!wait_for_progress_cb (0))
                break;
            gpg_read_only = gpg_check_permissions (0) == 0? 0 : 1;
            SetForegroundWindow (hwnd);
            GetCursorPos (&p);
            hm = LoadMenu (glob_hinst, MAKEINTRESOURCE (IDR_WINPT));
            popup = GetSubMenu (hm, 0);

            if (!scard_support)
                set_menu_state (popup, ID_WINPT_CARD, MF_DISABLED|MF_GRAYED);
            set_menu_text (popup, ID_WINPT_FILE, _("File Manager"));
            set_menu_text (popup, ID_WINPT_KEY, _("Key Manager"));
            set_menu_text (popup, ID_WINPT_CARD, _("Card Manager"));
            set_menu_text (popup, ID_WINPT_EDIT, _("Edit"));
            set_menu_text (popup, ID_WINPT_ABOUT, _("About..."));
            set_menu_text (popup, ID_WINPT_QUIT, _("Exit"));
            set_menu_text (popup, ID_WINPT_SYMENC, _("Symmetric"));
            set_menu_text (popup, ID_WINPT_ENCRYPT, _("Encrypt"));
            set_menu_text (popup, ID_WINPT_SIGN, _("Sign"));
            set_menu_text (popup, ID_WINPT_SIGNENCRYPT, _("Sign && Encrypt"));
            set_menu_text (popup, ID_WINPT_DECRYPT, _("Decrypt/Verify"));
            set_menu_text (popup, ID_WINPT_VERIFY, _("Verify"));
            set_menu_text (popup, ID_WINPT_CURRWND_ENCRYPT, _("Encrypt"));
            set_menu_text (popup, ID_WINPT_CURRWND_SIGNENCRYPT, _("Sign && Encrypt"));
            set_menu_text (popup, ID_WINPT_CURRWND_DECRYPT_VERIFY, _("Decrypt/Verify"));
            set_menu_text (popup, ID_WINPT_CURRWND_SIGN, _("Sign"));
            set_menu_text (popup, ID_WINPT_CURRWND_SYMENC, _("Symmetric"));
            if (!secret_key_available ()) {
                set_menu_state (popup, ID_WINPT_SIGN, MF_DISABLED|MF_GRAYED);
                set_menu_state (popup, ID_WINPT_CURRWND_SIGN, MF_DISABLED|MF_GRAYED);
                set_menu_state (popup, ID_WINPT_SIGNENCRYPT, MF_DISABLED|MF_GRAYED);
                set_menu_state (popup, ID_WINPT_CURRWND_SIGNENCRYPT, MF_DISABLED|MF_GRAYED);
            }
            /* change popup texts */      
            set_menu_text_bypos (popup, 4, _("Clipboard"));
            set_menu_text_bypos (popup, 5, _("Current Window"));
            set_menu_text_bypos (popup, 7, _("Preferences"));

            TrackPopupMenu (popup, TPM_RIGHTALIGN, p.x, p.y, 0, hwnd, NULL);
            PostMessage (hwnd, WM_USER, 0, 0);
            DestroyMenu (popup);
            DestroyMenu (hm);
            break;
            
        case WM_LBUTTONDBLCLK:
            if (!wait_for_progress_cb (0))
                break;
            gpg_read_only = gpg_check_permissions (0) == 0? 0 : 1;
            SendMessage (hwnd, WM_COMMAND, ID_WINPT_KEY, 0);
            break;
        }
        break;
        
    case WM_HOTKEY:
        cmd = 0;
        switch (wparam) {
        case WPT_CLIP_ENCRYPT_ID:                       
            SendMessage( hwnd, WM_COMMAND, ID_WINPT_ENCRYPT, 0 );
            break;
            
        case WPT_CLIP_DECRYPT_VERIFY_ID:
            SendMessage( hwnd, WM_COMMAND, ID_WINPT_DECRYPT_VERIFY, 0 );
            break;
            
        case WPT_CLIP_SIGN_ID:
            SendMessage( hwnd, WM_COMMAND, ID_WINPT_SIGN, 0 );
            break;
            
        case WPT_CLIP_SIGN_ENCRYPT_ID:
            SendMessage( hwnd, WM_COMMAND, ID_WINPT_SIGNENCRYPT, 0 );
            break;
            
        case WPT_CURRWND_ENCRYPT_ID:
            use_hotkey = 1;
            SendMessage( hwnd, WM_COMMAND, ID_WINPT_CURRWND_ENCRYPT, 0 );
            break;                              
            
        case WPT_CURRWND_SIGN_ID:
            use_hotkey = 1;
            SendMessage( hwnd, WM_COMMAND, ID_WINPT_CURRWND_SIGN, 0 );
            break;
            
        case WPT_CURRWND_SIGN_ENCRYPT_ID:
            use_hotkey = 1;
            SendMessage( hwnd, WM_COMMAND, ID_WINPT_CURRWND_SIGNENCRYPT, 0 );
            break;
            
        case WPT_CURRWND_DECRYPT_VERIFY_ID:
            use_hotkey = 1;
            SendMessage( hwnd, WM_COMMAND, ID_WINPT_CURRWND_DECRYPT_VERIFY, 0 );
            break;
            
        case WPT_AGENT_FORGET_ID:
            rc = msg_box (hwnd, _("Remove all passphrases from cache?"),
                          _("WinPT"), MB_YESNO|MB_ICONQUESTION);
            if (rc == IDYES)
                agent_flush_cache ();
            break;
        }               
        break;
        
    case WM_COMMAND:
        if (gnupg_access_keyring (1)) {
            if (log_box( "WinPT", MB_ERR|MB_YESNO,
                _("Could not access public keyring, exit WinPT?") ) == IDYES)
                SendMessage (hwnd, WM_DESTROY, 0, 0);
            break;
        }
        switch (wparam) {
            /** Clipboard operations **/
        case ID_WINPT_SYMENC:
        case ID_WINPT_ENCRYPT:
        case ID_WINPT_SIGN:
        case ID_WINPT_SIGNENCRYPT:
        case ID_WINPT_DECRYPT_VERIFY:
            err = gpg_clip_istext_avail (&has_data);
            if (err) {
                msg_box (hwnd, gpgme_strerror (err),_("Clipboard"), MB_ERR);
                break;
            }
            if (!has_data) {
                msg_box (hwnd, winpt_strerror (WPTERR_CLIP_EMPTY),
                         _("Clipboard"), MB_ERR);
                break;
            }
            clip_gpg_dlg (hwnd, (int)wparam, NULL);
            break;

            /** Current window operations **/
        case ID_WINPT_CURRWND_SYMENC:
        case ID_WINPT_CURRWND_ENCRYPT:
        case ID_WINPT_CURRWND_SIGNENCRYPT:
        case ID_WINPT_CURRWND_DECRYPT_VERIFY:
        case ID_WINPT_CURRWND_SIGN:
            rc = get_window_contents (hwnd, &currwnd, &use_hotkey);
            if (rc) {
                log_box (_("WinPT Error"), MB_ERR, 
                         _("Make sure that the window contains text.\n"
                           "%s."),
                        winpt_strerror (WPTERR_CURR_WND));
                break;
            }
            clip_gpg_dlg (hwnd, (int)wparam, &set_wc);
            if (set_wc == 1)
                set_window_contents (hwnd, &currwnd);
            break;
            
            /** File handling **/
        case ID_WINPT_FILE:
            s = _("File Manager (use drag & drop to add files)");
            wnd = FindWindow (NULL, s);
            if (wnd && IsIconic (wnd))
                ShowWindow (wnd, SW_RESTORE);
            dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_FILE,
                              GetDesktopWindow (), file_manager_dlg_proc, 0,
                              s, IDS_WINPT_FILE);
            break;
            
            /** Misc **/
        case ID_WINPT_KEY:
            wnd = FindWindow (NULL, _("Key Manager"));
            if (wnd && IsIconic (wnd))
                ShowWindow (wnd, SW_RESTORE);
            if (wnd)
                SetForegroundWindow (wnd);
            dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYMISC, 
                              GetDesktopWindow(), keymanager_dlg_proc, 
                              cmd != 0? (LPARAM)cmd : 0, 
                              _("Key Manager"), IDS_WINPT_KEYMISC);
            cmd = 0;
            break;

        case ID_WINPT_CARD:
            load_card_manager ();
            break;
            
        case ID_WINPT_EDIT:
            dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_CLIPEDIT,
                              GetDesktopWindow(), clip_edit_dlg_proc, 0,
                             _("Clipboard Editor"), IDS_WINPT_CLIPEDIT );
            break;
            
        case ID_WINPT_ABOUT:
            dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_ABOUT, GetDesktopWindow(), 
                              about_winpt_dlg_proc, 0, 
                             _("About WinPT"), IDS_WINPT_ABOUT );
            break;
            
        case ID_WINPT_PREFS:
            dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_PREFS, GetDesktopWindow(),
                              prefs_dlg_proc, 0,
                             _("WinPT Preferences"), IDS_WINPT_PREFS );
            break;
            
        case ID_WINPT_GPGPREFS:
            rc = dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_GPGPREFS, 
                                    GetDesktopWindow(), gpgprefs_dlg_proc, 0,
                              _("GnuPG Preferences"), IDS_WINPT_GPGPREFS);
            if (rc == TRUE)
                update_keycache (GetDesktopWindow ());
            break;
            
        case ID_WINPT_QUIT:
            manual_shutdown = 1;
            SendMessage (hwnd, WM_DESTROY, 0, 0);
            break;
        }
        break;
    }
    
    return DefWindowProc (hwnd, msg, wparam, lparam);
}
1	werner	36	/* wptMainProc.cpp - Main window procedure
2	twoaday	150	* Copyright (C) 2000-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
21			#ifdef HAVE_CONFIG_H
22			#include <config.h>
23			#endif
24
25	twoaday	262	#define _WIN32_IE 0x0600
26
27	werner	36	#include <windows.h>
28			#include <commctrl.h>
29			#include <io.h>
30
31	werner	47	#include "resource.h"
32	werner	36	#include "wptTypes.h"
33			#include "wptGPG.h"
34			#include "wptW32API.h"
35			#include "wptVersion.h"
36			#include "wptCommonCtl.h"
37			#include "wptContext.h" /* for passphrase_s */
38			#include "wptDlgs.h"
39			#include "wptErrors.h"
40			#include "wptNLS.h"
41			#include "wptHotkey.h"
42			#include "wptRegistry.h"
43			#include "wptKeyserver.h"
44			#include "wptAgent.h"
45	twoaday	248	#include "wptUTF8.h"
46	werner	36	#include "wptKeyManager.h"
47			#include "wptCard.h"
48			#include "wptCardEdit.h"
49
50	twoaday	190
51	twoaday	255	int update_keycache (HWND hwnd);
52	twoaday	190
53	twoaday	248	/* Command for the Key Manager dialog. (0=no command) */
54	werner	36	static int cmd = 0;
55	twoaday	248
56			/* 1 indicates that the clipboard will be emptied o exit. */
57	werner	36	static int wipe_contents = 0;
58
59
60			/* Dialog box procedure to display all insecure all ElGamal keys. */
61			BOOL CALLBACK
62			elgamal_warn_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
63			{
64			gpg_keycache_t pc;
65			gpgme_key_t key;
66	twoaday	248	char *uid;
67	werner	36	char tmp[128+64+1];
68
69	twoaday	72	switch (msg) {
70	werner	36	case WM_INITDIALOG:
71			pc = keycache_get_ctx (1);
72			while (!gpg_keycache_next_key (pc, 0, &key)) {
73			if (key->subkeys->pubkey_algo == GPGME_PK_ELG) {
74	twoaday	248	uid = utf8_to_native (key->uids->uid);
75	werner	36	_snprintf (tmp, sizeof (tmp)-1, "(0x%s) %s",
76	twoaday	248	key->subkeys->keyid+8, uid);
77	werner	36	SendDlgItemMessage (dlg, IDC_ELGWARN_LIST, LB_ADDSTRING,
78	twoaday	248	0, (LPARAM)(const char *)tmp);
79			free_if_alloc (uid);
80	werner	36	}
81			}
82			gpg_keycache_rewind (pc);
83			center_window (dlg, NULL);
84			SetForegroundWindow (dlg);
85			break;
86
87			case WM_COMMAND:
88			switch (LOWORD (wparam)) {
89			case IDOK:
90			EndDialog (dlg, TRUE);
91			break;
92			}
93			break;
94			}
95			return FALSE;
96	twoaday	32	}
97	werner	36
98
99			/* Dialog box procedure to confirm to delete the clipboard contents. */
100			static BOOL CALLBACK
101			confirm_delclipboard_dlg (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
102			{
103			switch (msg) {
104			case WM_INITDIALOG:
105			SetWindowText (dlg, _("Delete Clipboard Contents"));
106	twoaday	226	SetDlgItemText (dlg, IDC_CONFDELCLIP_BRAIN,
107			_("&Remember the answer"));
108			SetDlgItemText (dlg, IDC_CONFDELCLIP_INFO,
109			_("Do you want to delete the contents from the clipboard?"));
110	twoaday	105	SetDlgItemText (dlg, IDYES, _("&Yes"));
111	twoaday	121	SetDlgItemText (dlg, IDNO, _("&No"));
112	werner	36	center_window (dlg, NULL);
113			SetForegroundWindow (dlg);
114			break;
115
116			case WM_COMMAND:
117			switch (LOWORD (wparam)) {
118			case IDYES:
119			wipe_contents = 1;
120			if (IsDlgButtonChecked (dlg, IDC_CONFDELCLIP_BRAIN))
121			set_reg_winpt_flag ("WipeClipboard", 1);
122	twoaday	248	EndDialog (dlg, 1);
123	werner	36	break;
124
125			case IDNO:
126			wipe_contents = 0;
127			if (IsDlgButtonChecked (dlg, IDC_CONFDELCLIP_BRAIN))
128			set_reg_winpt_flag ("WipeClipboard", 0);
129	twoaday	248	EndDialog (dlg, 0);
130	werner	36	break;
131			}
132			break;
133			}
134			return FALSE;
135			}
136
137
138	twoaday	255	/* Handle the various command requests for the clipboard
139			and the current window. */
140			static void
141			clip_gpg_dlg (HWND hwnd, UINT id, int *r_upd_window)
142	werner	36	{
143	twoaday	68	gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
144	werner	36	int type;
145	twoaday	255	int disable_viewer = 0;
146	werner	36
147	twoaday	255	if (r_upd_window) {
148			*r_upd_window = 1;
149			/* for the current window mode it makes no sense to
150			use the clipboard viewer for decryption because the
151			text will be pasted directly into the window. */
152			disable_viewer = 1;
153	werner	36	}
154	twoaday	129	if ((id == ID_WINPT_SIGN \|\| id == ID_WINPT_SIGNENCRYPT)
155			&& gnupg_access_keyring (0)) {
156			msg_box (hwnd, _("Could not access secret keyring."), _("Sign"), MB_ERR);
157	werner	36	return;
158			}
159
160	twoaday	255	switch (id) {
161	werner	36	case ID_WINPT_SYMENC:
162	twoaday	255	case ID_WINPT_CURRWND_SYMENC:
163			err = gpg_clip_sym_encrypt ();
164			if (err && r_upd_window)
165			*r_upd_window = 0;
166	werner	36	break;
167
168			case ID_WINPT_ENCRYPT:
169	twoaday	255	case ID_WINPT_CURRWND_ENCRYPT:
170			dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_ENCRYPT, hwnd,
171	twoaday	68	clip_encrypt_dlg_proc, 0,
172	twoaday	255	_("Encryption"), IDS_WINPT_ENCRYPT);
173	werner	36	break;
174
175			case ID_WINPT_SIGN:
176	twoaday	255	case ID_WINPT_CURRWND_SIGN:
177			dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_SIGN, hwnd,
178	twoaday	68	clip_sign_dlg_proc, 0,
179	twoaday	255	_("Signing"), IDS_WINPT_SIGN);
180	werner	36	break;
181
182			case ID_WINPT_SIGNENCRYPT:
183	twoaday	255	case ID_WINPT_CURRWND_SIGNENCRYPT:
184			dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_SIGNENC, hwnd,
185	twoaday	68	clip_signenc_dlg_proc, 0,
186	twoaday	255	_("Sign & Encrypt"), IDS_WINPT_SIGNENC);
187	werner	36	break;
188
189			case ID_WINPT_DECRYPT_VERIFY:
190	twoaday	255	case ID_WINPT_CURRWND_DECRYPT_VERIFY:
191	werner	36	err = gpg_clip_get_pgptype (&type);
192			if (err) {
193	twoaday	255	msg_box (hwnd, gpgme_strerror (err), _("Clipboard"), MB_ERR);
194			if (r_upd_window)
195			*r_upd_window = 0;
196	werner	36	break;
197			}
198	twoaday	255	if ((type & PGP_MESSAGE) && !(type & PGP_CLEARSIG))
199			err = clip_decrypt_dlg (hwnd, disable_viewer?
200			0 : reg_prefs.use_viewer);
201	twoaday	229	else if ((type & PGP_SIG) && !(type & PGP_CLEARSIG)) {
202	werner	36	text_input_s input;
203			gpgme_data_t sig;
204
205	twoaday	225	memset (&input, 0, sizeof (input));
206	werner	36	err = gpg_data_new_from_clipboard (&sig, 0);
207	twoaday	225	if (err) {
208	twoaday	255	msg_box (hwnd, gpgme_strerror (err),_("Verify"), MB_ERR);
209			if (r_upd_window)
210			*r_upd_window = 0;
211	werner	36	return;
212			}
213			input.type = 0;
214	twoaday	225	dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_TEXT, hwnd,
215			text_input_dlg_proc, (LPARAM)&input,
216			_("Text Input"), IDS_WINPT_TEXT);
217
218			/* the dialog might have changed the clipboard, so we restore
219			the original state (again). */
220			gpg_data_release_and_set_clipboard (sig, 0);
221			if (input.length > 0) {
222			dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_VERIFY, hwnd,
223			clip_verify_dlg_proc, (LPARAM)&input,
224			_("Verify"), IDS_WINPT_VERIFY);
225	werner	36	input.length = 0;
226	twoaday	225	free_if_alloc (input.data);
227	werner	36	}
228	twoaday	255	if (r_upd_window)
229			*r_upd_window = 0;
230	werner	36	}
231			else if (type & PGP_CLEARSIG) {
232	twoaday	255	dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_VERIFY, hwnd,
233			clip_verify_dlg_proc, 0,
234			_("Verify"), IDS_WINPT_VERIFY);
235			if (r_upd_window)
236			*r_upd_window = 0;
237	werner	36	}
238	twoaday	255	else if ((type & PGP_PUBKEY) \|\| (type & PGP_SECKEY)) {
239	twoaday	165	km_clip_import (GetDesktopWindow (), NULL, NULL);
240	twoaday	255	if (r_upd_window)
241			*r_upd_window = 0;
242			}
243			else {
244	werner	36	msg_box (hwnd, _("Unknown OpenPGP type."), _("Clipboard"), MB_ERR);
245	twoaday	255	if (r_upd_window)
246			*r_upd_window = 0;
247			}
248	werner	36	}
249	twoaday	72	}
250	werner	36
251
252			/* Load the Card Manager with the current card. */
253			static void
254	twoaday	121	load_card_manager (void)
255	werner	36	{
256			gpg_card_t card;
257
258			card = gpg_card_load ();
259	twoaday	193	if (!card)
260			return;
261
262			dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_CARD_EDIT,
263			GetDesktopWindow (), card_edit_dlg_proc,
264			(LPARAM)card,
265			_("Card Edit"), IDS_WINPT_CARD_EDIT);
266			gpg_card_release (card);
267	werner	36	}
268
269
270			/* Add the winpt symbol to the task bar. */
271			static void
272			add_taskbar_icon (HWND hwnd, NOTIFYICONDATA *nid)
273			{
274			nid->cbSize = sizeof (NOTIFYICONDATA);
275			nid->uFlags = NIF_MESSAGE \| NIF_ICON \| NIF_TIP;
276			nid->uCallbackMessage = WM_USER;
277			nid->hWnd = hwnd;
278			nid->hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
279			strcpy (nid->szTip, "Windows Privacy Tray v"PGM_VERSION);
280			Shell_NotifyIcon (NIM_ADD, nid);
281			DestroyIcon (nid->hIcon);
282			}
283
284
285	twoaday	229	/* Initialize all needed common controls. */
286	twoaday	193	static void
287			init_common_controls (void)
288			{
289			INITCOMMONCONTROLSEX cce;
290
291			/* date control, toolbar, trackbar, ... */
292			cce.dwSize = sizeof (INITCOMMONCONTROLSEX);
293			cce.dwICC = ICC_DATE_CLASSES\|ICC_BAR_CLASSES;
294			InitCommonControlsEx (&cce);
295			}
296
297
298	twoaday	248	/* Wipe the clipboard if the user requested it. */
299			static void
300			wipe_clipboard (int manual_shutdown)
301			{
302			int has_data = 0;
303
304			if (!gpg_clip_istext_avail (&has_data) && has_data) {
305			int chk = get_reg_winpt_flag ("WipeClipboard");
306			if (chk == -1 && manual_shutdown)
307			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_CONFDELCLIP,
308			GetDesktopWindow (), confirm_delclipboard_dlg, 0);
309			if (wipe_contents \|\| chk)
310			set_clip_text (NULL, " ", 1);
311			wipe_contents = 0;
312			}
313			}
314
315
316	twoaday	270
317	werner	36	/* Main message loop for the tray window. */
318			LRESULT CALLBACK
319			winpt_main_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
320			{
321			static NOTIFYICONDATA NID;
322	twoaday	174	static DWORD cookie;
323	twoaday	139	static int use_hotkey = 0;
324	twoaday	193	static int manual_shutdown = 0;
325	twoaday	139	HWND wnd;
326			gpgme_error_t err;
327			curr_wnd_ctx currwnd = {0};
328			const char *s;
329	twoaday	248	int rc, set_wc = 0;
330			int has_data = 0;
331	werner	36
332			switch (msg) {
333			case WM_CREATE:
334			add_taskbar_icon (hwnd, &NID);
335			rc = wsock_init ();
336			if (rc)
337			msg_box (NULL, winpt_strerror (rc), "Winsock2 DLL", MB_ERR);
338			if (!reg_prefs.no_hotkeys) {
339			rc = hotkeys_register (hwnd);
340			if (rc)
341			msg_box (hwnd, hotkeys_strerror (), winpt_strerror (rc), MB_ERR);
342			}
343			rc = PTD_initialize ();
344			if (!rc)
345			msg_box (hwnd, _("Could not set current window mode hooks."),
346			_("WinPT Error"), MB_OK);
347			mapi_init ();
348	twoaday	193	init_common_controls ();
349	twoaday	174	html_help_init (&cookie);
350	werner	36	LoadLibrary ("RichEd32.Dll");
351	twoaday	193	manual_shutdown = 0;
352	werner	36	break;
353
354			case WM_ENDSESSION:
355			case WM_DESTROY:
356			case WM_CLOSE:
357			case WM_QUIT:
358			mapi_deinit ();
359			wsock_end ();
360			keycache_release (1);
361	twoaday	222	gnupg_backup_keyrings (reg_prefs.auto_backup,
362	twoaday	248	reg_prefs.backup.mode,
363			reg_prefs.backup.include_secr);
364	twoaday	270	free_reg_prefs ();
365	werner	36	free_gnupg_table ();
366	twoaday	278	gettext_free_current_domain ();
367	werner	36	hotkeys_unregister (hwnd);
368			PTD_delete ();
369			agent_flush_cache ();
370	twoaday	174	html_help_deinit (cookie);
371	twoaday	248	wipe_clipboard (manual_shutdown);
372	werner	36	debug_end ();
373			Shell_NotifyIcon (NIM_DELETE, &NID);
374			PostQuitMessage (0);
375			ExitProcess (0);
376	twoaday	72	break;
377	werner	36
378			case WM_USER:
379			switch (lparam) {
380			case WM_RBUTTONUP:
381			HMENU hm, popup;
382			POINT p;
383
384	twoaday	244	if (!wait_for_progress_cb (0))
385			break;
386	twoaday	248	gpg_read_only = gpg_check_permissions (0) == 0? 0 : 1;
387	werner	36	SetForegroundWindow (hwnd);
388			GetCursorPos (&p);
389			hm = LoadMenu (glob_hinst, MAKEINTRESOURCE (IDR_WINPT));
390			popup = GetSubMenu (hm, 0);
391	twoaday	72
392	twoaday	248	if (!scard_support)
393			set_menu_state (popup, ID_WINPT_CARD, MF_DISABLED\|MF_GRAYED);
394	twoaday	193	set_menu_text (popup, ID_WINPT_FILE, _("File Manager"));
395			set_menu_text (popup, ID_WINPT_KEY, _("Key Manager"));
396			set_menu_text (popup, ID_WINPT_CARD, _("Card Manager"));
397	twoaday	246	set_menu_text (popup, ID_WINPT_EDIT, _("Edit"));
398	werner	36	set_menu_text (popup, ID_WINPT_ABOUT, _("About..."));
399			set_menu_text (popup, ID_WINPT_QUIT, _("Exit"));
400			set_menu_text (popup, ID_WINPT_SYMENC, _("Symmetric"));
401			set_menu_text (popup, ID_WINPT_ENCRYPT, _("Encrypt"));
402	twoaday	72	set_menu_text (popup, ID_WINPT_SIGN, _("Sign"));
403	werner	36	set_menu_text (popup, ID_WINPT_SIGNENCRYPT, _("Sign && Encrypt"));
404			set_menu_text (popup, ID_WINPT_DECRYPT, _("Decrypt/Verify"));
405			set_menu_text (popup, ID_WINPT_VERIFY, _("Verify"));
406			set_menu_text (popup, ID_WINPT_CURRWND_ENCRYPT, _("Encrypt"));
407			set_menu_text (popup, ID_WINPT_CURRWND_SIGNENCRYPT, _("Sign && Encrypt"));
408			set_menu_text (popup, ID_WINPT_CURRWND_DECRYPT_VERIFY, _("Decrypt/Verify"));
409			set_menu_text (popup, ID_WINPT_CURRWND_SIGN, _("Sign"));
410	twoaday	234	set_menu_text (popup, ID_WINPT_CURRWND_SYMENC, _("Symmetric"));
411	twoaday	72	if (!secret_key_available ()) {
412			set_menu_state (popup, ID_WINPT_SIGN, MF_DISABLED\|MF_GRAYED);
413			set_menu_state (popup, ID_WINPT_CURRWND_SIGN, MF_DISABLED\|MF_GRAYED);
414			set_menu_state (popup, ID_WINPT_SIGNENCRYPT, MF_DISABLED\|MF_GRAYED);
415			set_menu_state (popup, ID_WINPT_CURRWND_SIGNENCRYPT, MF_DISABLED\|MF_GRAYED);
416			}
417	twoaday	246	/* change popup texts */
418			set_menu_text_bypos (popup, 4, _("Clipboard"));
419			set_menu_text_bypos (popup, 5, _("Current Window"));
420			set_menu_text_bypos (popup, 7, _("Preferences"));
421	werner	36
422	twoaday	72	TrackPopupMenu (popup, TPM_RIGHTALIGN, p.x, p.y, 0, hwnd, NULL);
423			PostMessage (hwnd, WM_USER, 0, 0);
424			DestroyMenu (popup);
425			DestroyMenu (hm);
426	werner	36	break;
427
428			case WM_LBUTTONDBLCLK:
429	twoaday	244	if (!wait_for_progress_cb (0))
430			break;
431	twoaday	78	gpg_read_only = gpg_check_permissions (0) == 0? 0 : 1;
432			SendMessage (hwnd, WM_COMMAND, ID_WINPT_KEY, 0);
433	werner	36	break;
434			}
435			break;
436
437			case WM_HOTKEY:
438			cmd = 0;
439	twoaday	229	switch (wparam) {
440	werner	36	case WPT_CLIP_ENCRYPT_ID:
441			SendMessage( hwnd, WM_COMMAND, ID_WINPT_ENCRYPT, 0 );
442			break;
443
444			case WPT_CLIP_DECRYPT_VERIFY_ID:
445			SendMessage( hwnd, WM_COMMAND, ID_WINPT_DECRYPT_VERIFY, 0 );
446			break;
447
448			case WPT_CLIP_SIGN_ID:
449			SendMessage( hwnd, WM_COMMAND, ID_WINPT_SIGN, 0 );
450			break;
451
452			case WPT_CLIP_SIGN_ENCRYPT_ID:
453			SendMessage( hwnd, WM_COMMAND, ID_WINPT_SIGNENCRYPT, 0 );
454			break;
455
456			case WPT_CURRWND_ENCRYPT_ID:
457			use_hotkey = 1;
458			SendMessage( hwnd, WM_COMMAND, ID_WINPT_CURRWND_ENCRYPT, 0 );
459			break;
460
461			case WPT_CURRWND_SIGN_ID:
462			use_hotkey = 1;
463			SendMessage( hwnd, WM_COMMAND, ID_WINPT_CURRWND_SIGN, 0 );
464			break;
465
466			case WPT_CURRWND_SIGN_ENCRYPT_ID:
467			use_hotkey = 1;
468			SendMessage( hwnd, WM_COMMAND, ID_WINPT_CURRWND_SIGNENCRYPT, 0 );
469			break;
470
471			case WPT_CURRWND_DECRYPT_VERIFY_ID:
472			use_hotkey = 1;
473			SendMessage( hwnd, WM_COMMAND, ID_WINPT_CURRWND_DECRYPT_VERIFY, 0 );
474			break;
475
476			case WPT_AGENT_FORGET_ID:
477	twoaday	248	rc = msg_box (hwnd, _("Remove all passphrases from cache?"),
478			_("WinPT"), MB_YESNO\|MB_ICONQUESTION);
479			if (rc == IDYES)
480			agent_flush_cache ();
481	werner	36	break;
482			}
483			break;
484
485			case WM_COMMAND:
486	twoaday	248	if (gnupg_access_keyring (1)) {
487			if (log_box( "WinPT", MB_ERR\|MB_YESNO,
488			_("Could not access public keyring, exit WinPT?") ) == IDYES)
489			SendMessage (hwnd, WM_DESTROY, 0, 0);
490	werner	36	break;
491			}
492	twoaday	248	switch (wparam) {
493	werner	36	/ Clipboard operations /
494			case ID_WINPT_SYMENC:
495			case ID_WINPT_ENCRYPT:
496			case ID_WINPT_SIGN:
497			case ID_WINPT_SIGNENCRYPT:
498			case ID_WINPT_DECRYPT_VERIFY:
499	twoaday	193	err = gpg_clip_istext_avail (&has_data);
500			if (err) {
501			msg_box (hwnd, gpgme_strerror (err),_("Clipboard"), MB_ERR);
502	werner	36	break;
503			}
504	twoaday	193	if (!has_data) {
505			msg_box (hwnd, winpt_strerror (WPTERR_CLIP_EMPTY),
506			_("Clipboard"), MB_ERR);
507	werner	36	break;
508			}
509	twoaday	255	clip_gpg_dlg (hwnd, (int)wparam, NULL);
510	werner	36	break;
511	twoaday	193
512	werner	36	/ Current window operations /
513			case ID_WINPT_CURRWND_SYMENC:
514			case ID_WINPT_CURRWND_ENCRYPT:
515			case ID_WINPT_CURRWND_SIGNENCRYPT:
516			case ID_WINPT_CURRWND_DECRYPT_VERIFY:
517			case ID_WINPT_CURRWND_SIGN:
518	twoaday	248	rc = get_window_contents (hwnd, &currwnd, &use_hotkey);
519			if (rc) {
520			log_box (_("WinPT Error"), MB_ERR,
521	werner	36	_("Make sure that the window contains text.\n"
522			"%s."),
523	twoaday	248	winpt_strerror (WPTERR_CURR_WND));
524	werner	36	break;
525			}
526	twoaday	255	clip_gpg_dlg (hwnd, (int)wparam, &set_wc);
527			if (set_wc == 1)
528	twoaday	129	set_window_contents (hwnd, &currwnd);
529	werner	36	break;
530
531			/ File handling /
532			case ID_WINPT_FILE:
533	twoaday	139	s = _("File Manager (use drag & drop to add files)");
534			wnd = FindWindow (NULL, s);
535			if (wnd && IsIconic (wnd))
536			ShowWindow (wnd, SW_RESTORE);
537			dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_FILE,
538			GetDesktopWindow (), file_manager_dlg_proc, 0,
539			s, IDS_WINPT_FILE);
540	werner	36	break;
541
542			/ Misc /
543			case ID_WINPT_KEY:
544	twoaday	139	wnd = FindWindow (NULL, _("Key Manager"));
545			if (wnd && IsIconic (wnd))
546			ShowWindow (wnd, SW_RESTORE);
547	twoaday	180	if (wnd)
548			SetForegroundWindow (wnd);
549	twoaday	139	dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYMISC,
550	twoaday	193	GetDesktopWindow(), keymanager_dlg_proc,
551			cmd != 0? (LPARAM)cmd : 0,
552	twoaday	139	_("Key Manager"), IDS_WINPT_KEYMISC);
553	werner	36	cmd = 0;
554			break;
555
556			case ID_WINPT_CARD:
557	twoaday	121	load_card_manager ();
558	werner	36	break;
559
560			case ID_WINPT_EDIT:
561			dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_CLIPEDIT,
562	twoaday	68	GetDesktopWindow(), clip_edit_dlg_proc, 0,
563	werner	36	_("Clipboard Editor"), IDS_WINPT_CLIPEDIT );
564			break;
565
566			case ID_WINPT_ABOUT:
567			dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_ABOUT, GetDesktopWindow(),
568	twoaday	68	about_winpt_dlg_proc, 0,
569	werner	36	_("About WinPT"), IDS_WINPT_ABOUT );
570			break;
571
572			case ID_WINPT_PREFS:
573			dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_PREFS, GetDesktopWindow(),
574	twoaday	68	prefs_dlg_proc, 0,
575	werner	36	_("WinPT Preferences"), IDS_WINPT_PREFS );
576			break;
577
578			case ID_WINPT_GPGPREFS:
579	twoaday	190	rc = dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_GPGPREFS,
580			GetDesktopWindow(), gpgprefs_dlg_proc, 0,
581	werner	36	_("GnuPG Preferences"), IDS_WINPT_GPGPREFS);
582	twoaday	190	if (rc == TRUE)
583			update_keycache (GetDesktopWindow ());
584	werner	36	break;
585
586			case ID_WINPT_QUIT:
587	twoaday	193	manual_shutdown = 1;
588	werner	36	SendMessage (hwnd, WM_DESTROY, 0, 0);
589			break;
590			}
591			break;
592			}
593
594			return DefWindowProc (hwnd, msg, wparam, lparam);
595			}