trunk/Src/wptFileManagerDlg.cpp

/* wptFileMangerDlg.cpp - File Manager
 *      Copyright (C) 2001-2006, 2008-2009 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.
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <commctrl.h>
#include <sys/stat.h>
#include <stdio.h>

#include "resource.h"
#include "wptCommonCtl.h"
#include "wptGPG.h"
#include "wptW32API.h"
#include "wptKeylist.h"
#include "wptErrors.h"
#include "wptContext.h" /* for passphrase_s */
#include "wptDlgs.h"
#include "wptTypes.h"
#include "wptNLS.h"
#include "wptVersion.h"
#include "wptFileManager.h"
#include "wptRegistry.h"
#include "wptCrypto.h"

#define FM_SEPARATOR_ID 10001

#define send_cmd_id(hwnd, id) \
    PostMessage ((hwnd), WM_COMMAND, MAKEWPARAM((id), 0), 0)

static subclass_s filelist_proc;


int is_openpgp_ext (const char *name);

/* Return 1 if the selected file in the listview has a valid GPG extension. */
static int
is_openpgp_file (listview_ctrl_t lv)
{
    char name[MAX_PATH+32];

    listview_get_item_text (lv, listview_get_curr_pos (lv), FM_COL_NAME, 
                            name, DIM (name)-1);
    return is_openpgp_ext (name);
}


/* Dialog procedure for selecting recipients for encryption. */
BOOL CALLBACK
file_encrypt_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static keylist_ctrl_t kl = NULL;
    static fm_state_t c;
    static keylist_t list = NULL;
    gpg_keycache_t kc;
    gpgme_ctx_t ctx;
    int force_trust = 0;
    
    switch (msg) {
    case WM_INITDIALOG:
        c = (fm_state_t)lparam;
        if (!c)
            BUG (0);
        kc = keycache_get_ctx (KEYCACHE_PUB);
        SetWindowText (dlg, _("File Encrypt"));
        SetDlgItemText (dlg, IDC_ENCRYPT_ARMOR, _("&Text Output"));
        SetDlgItemText (dlg, IDC_ENCRYPT_ANON, _("Anonymize (throw keyid)"));
        SetDlgItemText (dlg, IDC_ENCRYPT_SIGN, _("&Select Key for signing"));
        SetDlgItemText (dlg, IDC_ENCRYPT_OPTINF, _("Options"));
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));

        // TODO: support --hidden-recipient
        EnableWindow (GetDlgItem (dlg, IDC_ENCRYPT_ANON), FALSE);

        if (c->req_signer) {
            EnableWindow (GetDlgItem (dlg, IDC_ENCRYPT_SIGN), TRUE);
            seclist_init (dlg, IDC_ENCRYPT_SECLIST, KEYLIST_FLAG_SHORT, &list);
        }
        kl = keylist_load (GetDlgItem (dlg, IDC_ENCRYPT_LIST), kc, NULL,
                           KEYLIST_ENCRYPT_MIN|KEYLIST_FLAG_FILE, 
                           KEY_SORT_USERID);
        SetForegroundWindow (dlg);
        return TRUE;
        
    case WM_DESTROY:
        seclist_destroy (&list);
        if (kl) {
            keylist_delete (kl);
            kl = NULL;
        }
        balloon_msg_disable ();
        break;

    case WM_NOTIFY:
        NMHDR *notify;
        notify = (NMHDR *)lparam;
        if (notify && notify->code == LVN_COLUMNCLICK 
            && notify->idFrom == IDC_ENCRYPT_LIST) {
            NMLISTVIEW *p = (LPNMLISTVIEW) lparam;
            int sortby = 0;

            switch (p->iSubItem) {
            case 0: sortby = KEY_SORT_USERID; break;
            case 1: sortby = KEY_SORT_KEYID; break;
            case 2: sortby = KEY_SORT_LEN; break;
            case 4: sortby = KEY_SORT_VALIDITY; break;
            default:sortby = KEY_SORT_USERID; break;
            }
            keylist_sort (kl, sortby);
        }
        break;
        
    case WM_COMMAND:
        if (HIWORD (wparam) == BN_CLICKED
            && LOWORD (wparam) == IDC_ENCRYPT_SIGN) {
            int req_signer = IsDlgButtonChecked (dlg, IDC_ENCRYPT_SIGN);
            EnableWindow (GetDlgItem (dlg, IDC_ENCRYPT_SECLIST),
                          req_signer? TRUE : FALSE);
        }
        switch (LOWORD (wparam)) {
        case IDOK:
            ctx = c->ctx;
            safe_free (c->recp);
            c->recp = keylist_get_recipients (kl, &force_trust, &c->n_recp);
            if (!c->n_recp) {
                show_balloon_msg (GetDlgItem (dlg, IDC_ENCRYPT_LIST),
                                  _("Please select at least one recipient."),
                                  IDI_ERROR);
                safe_free (c->recp);
                c->recp = NULL;
                c->cancel = 1;
                return TRUE;
            }
            if (IsDlgButtonChecked (dlg, IDC_ENCRYPT_SIGN)) {
                gpgme_key_t key;

                if (seclist_select_key (dlg, IDC_ENCRYPT_SECLIST, &key))
                    return TRUE;
                else
                    gpgme_signers_add (c->ctx, key);
            }

            if (IsDlgButtonChecked (dlg, IDC_ENCRYPT_ARMOR))
                gpgme_set_armor (ctx, 1);
            /* XXX: implement this
            if (IsDlgButtonChecked (dlg, IDC_ENCRYPT_ANON))
                ;
            */
            c->cancel = 0;
            EndDialog (dlg, TRUE);
            return TRUE;
            
        case IDCANCEL:
            c->cancel = 1;
            EndDialog (dlg, FALSE);
            return TRUE;
        }
        return TRUE;
    }
    
    return FALSE;
}


/* Dialog box procedure for importing keys. */
BOOL CALLBACK
file_import_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static listview_ctrl_t lv = NULL;
    static fm_state_t c;
    static int is_revcert = 0, has_seckeys = 0;
    
    switch (msg) {
    case WM_INITDIALOG:
        c = (fm_state_s *)lparam;
        if (!c)
            BUG (0);
        ShowWindow (GetDlgItem (dlg, IDC_IMPORT_KEYMNGT), WS_DISABLED);
        implist_build (&lv, GetDlgItem (dlg, IDC_IMPORT_KEYLIST));
        implist_load (lv, c->import.is_clip? NULL: c->opaque, 
                      &is_revcert, &has_seckeys);
        if (!listview_count_items (lv, 0)) {
            msg_box (dlg, _("No valid OpenPGP data found."), _("Key Import"), MB_ERR);
            c->cancel = 1;
            EndDialog (dlg, FALSE);
            return TRUE;
        }
        else {
            const char *fmt = _("%s contain(s) %d key(s).");
            const char *name = c->import.is_clip? _("Clipboard") : _("File");
            char *p = new char[strlen (fmt) + strlen (name) + 32 + 1];
            if (!p)
                BUG (NULL);
            sprintf (p, fmt, name, listview_count_items (lv, 0));
            SetDlgItemText (dlg, IDC_IMPORT_INFO, p);
            free_if_alloc (p);
        }
        SetWindowText (dlg, _("Key Import"));
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
        center_window (dlg, NULL);
        SetForegroundWindow (dlg);      
        return TRUE;
        
    case WM_DESTROY:
        if (lv) {
            listview_release (lv);
            lv = NULL;
        }
        return FALSE;
        
    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDC_IMPORT_DOIT:
            /* Make sure the user knows the consequence if he/she imports
               a key revocation certificate. */
            if (is_revcert) {
                int ret = msg_box (dlg, _("The file contains at least one revocation certificate.\n"
                                          "If you contine the import, the key will be rendered useless.\n"
                                          "Really proceed?"), _("Import"), MB_ICONWARNING|MB_YESNO);
                if (ret == IDNO) {
                    c->cancel = 1;
                    EndDialog (dlg, FALSE);
                    return TRUE;
                }
            }
            if (has_seckeys > 0) {
                msg_box (dlg, _("Some of the imported keys are secret keys.\n\n"
                                "The ownertrust values of these keys must be\n"
                                "set manually via the Key Properties dialog."),
                         _("Import"), MB_INFO);
            }
            c->cancel = 0;
            c->import.revcert = is_revcert? 1 : 0;
            c->import.has_seckey = has_seckeys? 1 : 0;
            EndDialog (dlg, TRUE);
            return TRUE;
            
        case IDCANCEL:
            c->cancel = 1;
            EndDialog (dlg, FALSE);
            return TRUE;
        }
        break;
    }
    
    return FALSE;
}


/* Dialog box procedure for file signing. */
BOOL CALLBACK
file_sign_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static fm_state_t c;
    static keylist_ctrl_t kl;
    gpg_keycache_t kc, sec_kc;    
    gpgme_key_t key;
    int lv_idx;
    char signer[32+1];
    
    switch (msg) {
    case WM_INITDIALOG:
        c = (fm_state_s *)lparam;
        if (!c)
            BUG (0);
        SetWindowText (dlg, _("File Sign"));
        SetDlgItemText (dlg, IDC_FILE_SIG_ARMOR, _("&Text Output") );
        SetDlgItemText (dlg, IDC_FILE_SIG_NORMAL, _("&Normal Signature"));
        SetDlgItemText (dlg, IDC_FILE_SIG_DETACH, _("&Detached Signature"));
        SetDlgItemText (dlg, IDC_FILE_SIG_CLEAR, _("&Cleartext Signature"));
        SetDlgItemText (dlg, IDC_FILE_SIG_SIGINF, _("Signature mode"));
        SetDlgItemText (dlg, IDC_FILE_SIG_OPTINF, _("Options"));
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
        CheckDlgButton (dlg, IDC_FILE_SIG_DETACH, BST_CHECKED);
        kc = keycache_get_ctx (KEYCACHE_PUB);
        if (!kc)
            BUG (dlg);
        sec_kc = keycache_get_ctx (KEYCACHE_PRV);
        if (!sec_kc)
            BUG (dlg);
        kl = keylist_load (GetDlgItem (dlg, IDC_FILE_SIG_LIST), kc, sec_kc,
                           KEYLIST_SIGN, KEY_SORT_USERID);
        SetForegroundWindow (dlg);
        return TRUE;
        
    case WM_DESTROY:
        if (kl) {
            keylist_delete (kl);
            kl = NULL;
        }
        return FALSE;
        
    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDOK:
            if (IsDlgButtonChecked (dlg, IDC_FILE_SIG_ARMOR))
                gpgme_set_armor (c->ctx, 1);
            if (IsDlgButtonChecked (dlg, IDC_FILE_SIG_NORMAL))
                c->sigmode = GPGME_SIG_MODE_NORMAL;
            else if (IsDlgButtonChecked (dlg, IDC_FILE_SIG_DETACH))
                c->sigmode = GPGME_SIG_MODE_DETACH;
            else if (IsDlgButtonChecked( dlg, IDC_FILE_SIG_CLEAR))
                c->sigmode = GPGME_SIG_MODE_CLEAR;
            else {
                /* default is to produce detached signatures */
                c->sigmode = GPGME_SIG_MODE_DETACH;
            }
            lv_idx = listview_get_selected_item (kl->lv);
            if (lv_idx == -1) {
                if (listview_count_items (kl->lv, 0) == 1)
                    lv_idx = 0;
                else {
                    msg_box (dlg, _("Please select a key."), _("File Sign"), MB_ERR);
                    return FALSE;
                }
            }
            listview_get_item_text (kl->lv, lv_idx, 1, signer, DIM (signer)-1);
            if (get_seckey (signer, &key))
                BUG (NULL);
            gpgme_signers_clear (c->ctx);
            gpgme_signers_add (c->ctx, key);
            free_if_alloc (c->opaque);
            c->opaque = m_strdup (signer); /* store for later use */
            c->cancel = 0;
            EndDialog (dlg, TRUE);
            return TRUE;
            
        case IDCANCEL:
            c->cancel = 1;
            EndDialog (dlg, FALSE);
            return TRUE;
        }
        break;
    }
    
    return FALSE;
}


/* Setup status bar for the main window @dlg. */
static HWND
setup_status_bar (HWND dlg)
{
    HWND statbar;
    RECT r;
    int partpos[3];
    int i;

    GetClientRect (dlg, &r);
    for (i=1; i <= 3; i++)
        partpos[i-1] = r.right/3*i;

    statbar = CreateStatusWindow (WS_CHILD | WS_VISIBLE | CCS_BOTTOM, 
                                   "", dlg, FM_SEPARATOR_ID);
    ShowWindow (statbar, SW_SHOW);
    SendMessage (statbar, SB_SETPARTS, (WPARAM)3, (LPARAM)partpos);
    return statbar;
}


/* Refresh the status bar text with the selected item from @lv. */
static void
update_status_bar (HWND statbar, listview_ctrl_t lv)
{
    struct stat st;
    char buf[128];
    int i, n;
    DWORD len = 0;

    if (!lv) { /* flush */
        SendMessage (statbar, SB_SETTEXT, 1, (LPARAM)"0 Byte");
        SendMessage (statbar, SB_SETTEXT, 0, (LPARAM)_("0 Objects marked"));
        return;
    }
    n = listview_count_items (lv, 1);
    _snprintf (buf, DIM (buf)-1, _("%d Object(s) marked"), n);
    SendMessage (statbar, SB_SETTEXT, 0, (LPARAM)buf);
    if (!n)
        return;
    for (i=0; i < listview_count_items (lv, 0); i++) {
        if (!listview_get_item_state (lv, i))
            continue;
        listview_get_item_text (lv, i, 1, buf, DIM (buf)-1);
        if (stat (buf, &st) == 0)
            len += st.st_size;
    }
    if (!len)
        _snprintf (buf, DIM (buf)-1, "0 Byte");
    else if (len < 1024)
        _snprintf (buf, DIM (buf)-1, "%d Byte", len);
    else if (st.st_size < 1048576)
        _snprintf (buf, DIM (buf)-1, "%d KB", len/1024);
    else
        _snprintf (buf, DIM (buf)-1, "%d MB", len/1024/1024);
    SendMessage (statbar, SB_SETTEXT, 1, (LPARAM)buf);
}

#ifndef VK_A
#define VK_A 65
#endif

/* Subclass procedure to detect common hotkeys. */
static BOOL CALLBACK
filelist_subclass_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    switch (msg) {
    case WM_KEYUP:
        if ((int)wparam == VK_A) {
            if (GetAsyncKeyState (VK_CONTROL)) {
                struct listview_ctrl_s fm_lv;
                fm_lv.ctrl = GetDlgItem (filelist_proc.dlg, IDC_FILE_LIST);
                listview_select_all (&fm_lv);
            }
        }
        break;
    }
    return CallWindowProc (filelist_proc.old, dlg, msg, wparam, lparam);
}


/* Enable or disabled menu entries from the dialog window @hwnd.
   @lv is used to find out the state of the selected file entry. */
static void
update_ui_items (HWND hwnd, HMENU hm, bool is_popup, listview_ctrl_t lv)
{
    int ids[2][7] = {
        {ID_FILEMISC_SEND, ID_FILEMISC_DECRYPT, ID_FILEMISC_VERIFY,
         ID_FILEMISC_ENCRYPT, ID_FILEMISC_SIGN, ID_FILEMISC_SIGNENC},   
        {ID_FILECTX_SEND,  ID_FILECTX_DECRYPT,  ID_FILECTX_VERIFY,
         ID_FILECTX_ENCRYPT, ID_FILECTX_SIGN,   ID_FILECTX_SIGNENC}
    };
    enum id_type_t { SEND, DECRYPT, VERIFY, ENCR, SIGN, SIGENC };
    int pos, idx = is_popup? 1: 0;

    pos = listview_get_curr_pos (lv);
    if (fm_check_file_type (lv, pos, FM_DECRYPT))
        set_menu_state (hm, ids[idx][SEND], MF_ENABLED);        

    if (fm_check_file_type (lv, pos, FM_ENCRYPT)) {     
        set_menu_state (hm, ids[idx][DECRYPT], MF_GRAYED|MF_DISABLED);  
        set_menu_state (hm, ids[idx][VERIFY], MF_GRAYED|MF_DISABLED);
        set_menu_state (hm, ids[idx][ENCR], MF_ENABLED);
        set_menu_state (hm, ids[idx][SIGN], MF_ENABLED);
        set_menu_state (hm, ids[idx][SIGENC], MF_ENABLED);
    }
    if (fm_check_file_type (lv, pos, FM_DECRYPT)) {
        set_menu_state (hm, ids[idx][ENCR], MF_GRAYED|MF_DISABLED);
        set_menu_state (hm, ids[idx][SIGN], MF_GRAYED|MF_DISABLED);
        set_menu_state (hm, ids[idx][SIGENC], MF_GRAYED|MF_DISABLED);
        set_menu_state (hm, ids[idx][DECRYPT], MF_ENABLED);
    }       
    if (fm_check_file_type (lv, pos, FM_VERIFY)) {
        set_menu_state (hm, ids[idx][ENCR], MF_GRAYED|MF_DISABLED);
        set_menu_state (hm, ids[idx][VERIFY], MF_ENABLED);
        set_menu_state (hm, ids[idx][SIGN], MF_GRAYED|MF_DISABLED);     
        set_menu_state (hm, ids[idx][SIGENC], MF_GRAYED|MF_DISABLED);
    }

    /* disable all operation which need a secret key. */
    if (!secret_key_available ()) {
        set_menu_state (hm, ids[idx][DECRYPT], MF_GRAYED|MF_DISABLED);
        set_menu_state (hm, ids[idx][SIGN], MF_GRAYED|MF_DISABLED);     
        set_menu_state (hm, ids[idx][SIGENC], MF_GRAYED|MF_DISABLED);
    }
}


/* Dialog box procedure for the File Manager. */
BOOL CALLBACK
file_manager_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static fm_info_t fm = NULL;
    static int always_ontop = 0;
    char sel_fname[MAX_PATH+1];
    HWND fl;
    
    switch (msg) {
    case WM_INITDIALOG:
        always_ontop = get_reg_winpt_flag ("AlwaysOnTop");
        if (always_ontop == -1)
            always_ontop = 0;
        SetWindowText (dlg, _("File Manager (use drag & drop to add files)"));
        fm_build (&fm, GetDlgItem (dlg, IDC_FILE_LIST));
        fm->menu = LoadMenu (glob_hinst, (LPCSTR)IDR_WINPT_FILEMISC);
        set_menu_text_bypos (fm->menu, 0, _("File"));
        set_menu_text_bypos (fm->menu, 1, _("Edit"));
        set_menu_text_bypos (fm->menu, 2, _("View"));
        set_menu_text (fm->menu, ID_FILEMISC_OPEN, _("&Open...") );
        set_menu_text (fm->menu, ID_FILEMISC_ENCRYPT, _("&Encrypt...") );
        set_menu_text (fm->menu, ID_FILEMISC_DECRYPT, _("&Decrypt...") );
        set_menu_text (fm->menu, ID_FILEMISC_SIGN, _("&Sign..."));
        set_menu_text (fm->menu, ID_FILEMISC_SIGNENC, _("Sign && Encrypt..."));
        set_menu_text (fm->menu, ID_FILEMISC_VERIFY, _("&Verify..."));        
        set_menu_text (fm->menu, ID_FILEMISC_SYMENC, _("S&ymmetric..."));
        set_menu_text (fm->menu, ID_FILEMISC_IMPORT, _("&Import...") );
        set_menu_text (fm->menu, ID_FILEMISC_EXPORT, _("E&xport...") );
        set_menu_text (fm->menu, ID_FILEMISC_QUIT, _("Exit"));
        set_menu_text (fm->menu, ID_FILEMISC_CLEAR, _("&Reset") );
        set_menu_text (fm->menu, ID_FILEMISC_ONTOP, _("Always on Top"));
        set_menu_text (fm->menu, ID_FILEMISC_SELALL, _("&Select All"));
        set_menu_text (fm->menu, ID_FILEMISC_PREFS, _("&Preferences..."));
        set_menu_text (fm->menu, ID_FILEMISC_LIST, _("&List Packets..."));

        fl = GetDlgItem (dlg, IDC_FILE_LIST);
        filelist_proc.dlg = dlg;
        filelist_proc.current = (WNDPROC)filelist_subclass_proc;
        filelist_proc.old = (WNDPROC)GetWindowLong (fl, GWL_WNDPROC);
        if (filelist_proc.old) {
            if (!SetWindowLong (fl, GWL_WNDPROC, (LONG)filelist_proc.current)) {
                msg_box (dlg, "Could not set filelist window procedure.", 
                         _("File Manager"), MB_ERR);
                BUG (NULL);
            }
        }
        SendMessage (dlg, WM_SETICON, (WPARAM)ICON_SMALL, 
                     (LPARAM)LoadIcon (glob_hinst, (LPCTSTR)IDI_WINPT));
        SetMenu (dlg, fm->menu);
        if (!always_ontop)
            set_menu_state (fm->menu, ID_FILEMISC_ONTOP, MFS_UNCHECKED);
        else
            center_window2 (dlg, NULL, HWND_TOPMOST);
        center_window (dlg, NULL);
        SetForegroundWindow (dlg);
        fm->statbar = setup_status_bar (dlg);
        filelist_proc.opaque = (void*)fm->statbar;
        return TRUE;

    case WM_DESTROY:
        if (fm) {
            fm_delete (fm);
            fm = NULL;
        }
        set_reg_winpt_flag ("AlwaysOnTop", always_ontop);
        return FALSE;
        
    case WM_DROPFILES:
        fm_add_dropped_files (fm, (HDROP)wparam);
        return TRUE;
        
    case WM_NOTIFY:
        NMHDR *notify;
        int pos;
        HMENU hm;       

        notify = (NMHDR *)lparam;
        if (notify && notify->code == LVN_COLUMNCLICK 
            && notify->idFrom == IDC_FILE_LIST) {
            NMLISTVIEW *p = (LPNMLISTVIEW) lparam;
            fm_sort (fm->lv, p->iSubItem);
        }       

        if (notify && notify->code == NM_CLICK &&
            notify->idFrom == IDC_FILE_LIST)
            update_status_bar (fm->statbar, fm->lv);
        if (notify && notify->code == NM_RCLICK
            && notify->idFrom == IDC_FILE_LIST) {
            POINT p;
            HMENU popup;
            
            /* If the selected file does not exist any longer,
               delete the entry and supress the popup. */    
            pos = listview_get_curr_pos (fm->lv);
            listview_get_item_text (fm->lv, pos, FM_COL_NAME, 
                                    sel_fname, DIM (sel_fname)-1);
            if (file_exist_check (sel_fname) != 0) {
                listview_del_item (fm->lv, pos);
                break;
            }

            GetCursorPos (&p);
            hm = LoadMenu (glob_hinst, MAKEINTRESOURCE (IDR_WINPT_FILEMISC_CTX));
            popup = GetSubMenu (hm, 0);
            set_menu_text (popup, ID_FILECTX_ENCRYPT, _("Encrypt"));
            set_menu_text (popup, ID_FILECTX_DECRYPT, _("Decrypt"));
            set_menu_text (popup, ID_FILECTX_SIGN, _("Sign"));
            set_menu_text (popup, ID_FILECTX_SIGNENC, _("Sign && Encrypt"));
            set_menu_text (popup, ID_FILECTX_VERIFY, _("Verify"));
            set_menu_text (popup, ID_FILECTX_SEND, _("Send as Mail"));
            set_menu_text (popup, ID_FILECTX_LIST, _("List Packets"));
            if (!is_openpgp_file (fm->lv))
                set_menu_state (popup, ID_FILECTX_LIST, MF_GRAYED|MF_DISABLED);
            update_ui_items (dlg, popup, true, fm->lv);
            TrackPopupMenu (popup, TPM_RIGHTALIGN, p.x, p.y, 0, dlg, NULL);
            DestroyMenu (popup);
            DestroyMenu (hm);
        }
        if (notify && notify->code == NM_CLICK
            && notify->idFrom == IDC_FILE_LIST) {
            hm = GetMenu (dlg);
            pos = listview_get_curr_pos (fm->lv);
            if (!fm_check_file_type (fm->lv, pos, FM_DECRYPT))
                set_menu_state (hm, ID_FILEMISC_SEND, MF_GRAYED|MF_DISABLED);
            else
                set_menu_state (hm, ID_FILEMISC_SEND, MF_ENABLED);
        }
        if (notify && notify->code == LVN_ITEMCHANGED &&
            ((LPNMLISTVIEW)lparam)->uNewState) { /* item selected? */
            update_ui_items (dlg, GetMenu (dlg), false, fm->lv);
            update_status_bar (fm->statbar, fm->lv);
        }
        return TRUE;

    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDCANCEL:
        case ID_FILEMISC_QUIT:
            EndDialog (dlg, TRUE);
            return TRUE;
            
        case ID_FILEMISC_SELALL:
            listview_select_all (fm->lv);
            break;

        case ID_FILEMISC_ONTOP:
            always_ontop ^= 1;                  
            set_menu_state (fm->menu, ID_FILEMISC_ONTOP, 
                            always_ontop == 0? MFS_UNCHECKED : MFS_CHECKED);
            center_window2 (dlg, NULL, 
                            always_ontop == 0? HWND_NOTOPMOST : HWND_TOPMOST);
            break;

        case ID_FILEMISC_SEND:
            fm_send_file (fm->lv);
            break;

        case ID_FILEMISC_PREFS:
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_FILE_PREFS, dlg,
                            file_preferences_dlg_proc, 0);
            break;

        case ID_FILEMISC_LIST:
        case ID_FILEMISC_ENCRYPT:
        case ID_FILEMISC_SYMENC:
        case ID_FILEMISC_DECRYPT:
        case ID_FILEMISC_SIGN:
        case ID_FILEMISC_SIGNENC:
        case ID_FILEMISC_VERIFY:
            fm_parse_files (fm->lv, dlg, LOWORD (wparam));
            SetForegroundWindow (dlg);
            return TRUE;
           
        case ID_FILEMISC_CLEAR:
            fm_reset (fm);
            update_status_bar (fm->statbar, NULL);
            return TRUE;
            
        case ID_FILEMISC_OPEN:
            fm_add_opened_files (fm, dlg);
            return TRUE;
            
            /* context menu entries */
        case ID_FILECTX_ENCRYPT: send_cmd_id (dlg, ID_FILEMISC_ENCRYPT);break;
        case ID_FILECTX_DECRYPT: send_cmd_id (dlg, ID_FILEMISC_DECRYPT);break;
        case ID_FILECTX_SIGN:    send_cmd_id (dlg, ID_FILEMISC_SIGN);   break;
        case ID_FILECTX_SIGNENC: send_cmd_id (dlg, ID_FILEMISC_SIGNENC);break;
        case ID_FILECTX_VERIFY:  send_cmd_id (dlg, ID_FILEMISC_VERIFY); break;
        case ID_FILECTX_LIST:    send_cmd_id (dlg, ID_FILEMISC_LIST);   break;
        case ID_FILECTX_SEND:    send_cmd_id (dlg, ID_FILEMISC_SEND);   break;
        }
        break;
    }
    
    return FALSE;
}


/* Dialog box procedure for the FM preferences. */
BOOL CALLBACK
file_preferences_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    switch (msg) {
    case WM_INITDIALOG:
        CheckDlgButton (dlg, IDC_FPREFS_PROGRESS, 
                        reg_prefs.fm.progress? BST_CHECKED : BST_UNCHECKED);
        SetForegroundWindow (dlg);
        center_window (dlg, NULL);
        break;

    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDOK:
            reg_prefs.fm.progress = IsDlgButtonChecked (dlg, IDC_FPREFS_PROGRESS)? 1 : 0;
            set_reg_winpt_prefs (&reg_prefs);
            EndDialog (dlg, TRUE);
            break;

        case IDCANCEL:
            EndDialog (dlg, FALSE);
            break;
        }
        break;
    }

    return FALSE;
}