珠穆朗玛: 技术

用于 Symbian OS 的 CString 类

Thu, 20 Mar 2008 14:46:01 GMT

在 Google 上搜 Symbian 和 CString，会发现有很多人在寻找这个东西，可惜的很，就是没有一个人愿意写一个玩玩。不知道是不是大部分的人到后来都屈服于描述符的淫威之下了。

老汉不才，扛起了这面大旗，把原来用在 TWL 里的 str.h 又加工了一番，增加了对 Symbian 操作系统的初步支持。有感兴趣的朋友可以到 http://cid-3569fea80c717fd4.skydrive.live.com/browse.aspx/Public 下载。

出于发布方便的目的，该头文件中的 lstrtoxl 函数没有提取到单独的文件中，使用者自己稍作一些剪切/粘贴的工作即可。

如果发现 BUG，请反馈给我。

调出系统的证书管理界面

Fri, 07 Dec 2007 11:25:50 GMT

好久没有贴代码了，今天贴一个。目的和作用如题。


// copied from cryptuiapi.h
typedef struct _CRYPTUI_CERT_MGR_STRUCT
{
    DWORD dwSize;
    HWND hwndParent;
    DWORD dwFlags;
    LPCWSTR pwszTitle;
    LPCSTR pszInitUsageOID;
} CRYPTUI_CERT_MGR_STRUCT, *PCRYPTUI_CERT_MGR_STRUCT;
typedef const CRYPTUI_CERT_MGR_STRUCT *PCCRYPTUI_CERT_MGR_STRUCT;

int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE, LPTSTR pszCmdLine, int nCmdShow)
{
 	HINSTANCE hCryptui = LoadLibrary(TEXT("cryptui.dll"));
	if(!hCryptui)
		return 0;

	typedef BOOL (WINAPI* fnCryptUIDlgCertMgr)(PCCRYPTUI_CERT_MGR_STRUCT pCryptUICertMgr);

	fnCryptUIDlgCertMgr CryptUIDlgCertMgr = NULL;
	((FARPROC&)CryptUIDlgCertMgr) = GetProcAddress(hCryptui, TEXT("CryptUIDlgCertMgr"));
	if(CryptUIDlgCertMgr)
	{
		CRYPTUI_CERT_MGR_STRUCT ccm = { sizeof(CRYPTUI_CERT_MGR_STRUCT) };
		CryptUIDlgCertMgr(&ccm);
	}

	FreeLibrary(hCryptui);

	return 0;
}

译：Windows Vista for Developers - 第二部分深入任务对话框

Thu, 08 Mar 2007 13:34:23 GMT

正如 Aero 向导相比传统向导带来了更佳的用户体验那样，任务对话框则是带来了比高龄的消息框更好的用户体验。不过，任务对话框要比低级的消息框提供了多得多的一长串的特性以及可定制性。而随这些而来的则是相当深的复杂度。在此 Windows Vista for Developers 系列的这第二个部分里，我将会为你展示如何通过 C++ 有效地使用任务对话框 API 来既简单又容易地构建出形形色色的对话框。如果你现在就迫不及待，你可以跳到文章的末尾，在那儿你可以找到一份供下载的源代码，里面有对任务对话框 API 的完整 C++ 封装。

在 comctl32.dll 库的内部，隐藏着一个名为 CTaskDialog 的 C++ 类，它负责实现了任务对话框提供的所有功能。由 comctl32.dll 导出的 TaskDialog 和 TaskDialogIndirect 函数会为你调用到它。TaskDialog 函数仅仅是 TaskDialogIndirect 的一个简化版本，它提供了较少的功能，不过也更容易使用一些。由于无论哪一个都并不是即刻就很有用，所以本文将专注于 TaskDialogIndirect，并演示如何使用一个 C++ 的小小辅助就可以使得它相当的便于使用。

以下代码创建一个最简单的任务对话框：

TASKDIALOGCONFIG config = { sizeof (TASKDIALOGCONFIG) };

int selectedButtonId = 0;
int selectedRadioButtonId = 0;
BOOL verificationChecked = FALSE;

HRESULT result = ::TaskDialogIndirect(&config,
                                      &selectedButtonId,
                                      &selectedRadioButtonId,
                                      &verificationChecked);

TASKDIALOGCONFIG 结构提供了一大堆你可以填充的成员域以及标志，其中还有一个你可以用来提供对任务对话框发出的事件作出响应的回调函数：

struct TASKDIALOGCONFIG
{
    UINT cbSize;
    HWND hwndParent;
    HINSTANCE hInstance;
    TASKDIALOG_FLAGS dwFlags;
    TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons;
    PCWSTR pszWindowTitle;
    union
    {
        HICON hMainIcon;
        PCWSTR pszMainIcon;
    };
    PCWSTR pszMainInstruction;
    PCWSTR pszContent;
    UINT cButtons;
    const TASKDIALOG_BUTTON* pButtons;
    int nDefaultButton;
    UINT cRadioButtons;
    const TASKDIALOG_BUTTON* pRadioButtons;
    int nDefaultRadioButton;
    PCWSTR pszVerificationText;
    PCWSTR pszExpandedInformation;
    PCWSTR pszExpandedControlText;
    PCWSTR pszCollapsedControlText;
    union
    {
        HICON hFooterIcon;
        PCWSTR pszFooterIcon;
    };
    PCWSTR pszFooter;
    PFTASKDIALOGCALLBACK pfCallback;
    LONG_PTR lpCallbackData;
    UINT cxWidth;
};

正如你能想象到的，恰如其分地填充这个结构简直是个挑战，而出错的机会却相当的大。尽管其中的很多域可以置零，但为了能达到预期的效果，下列的域通常是要进行设置的：

cbSize 域在编译时指定了此结构的大小，这是一种常用技术，用以在 C 中表示数据结构的版本。它使得操作系统可以知道应用程序编译时采用了哪种版本结构，并据此来像应用程序所期望的那样来对其中的域以及功能性作一个确定的推断。

hwndParent 域保存了父窗口的句柄。这就允许结果对话框以模态窗口的方式工作，而且还可以使你对它进行相对于父窗口的定位。

hInstance 域对 C++ 开发人员有用，因为它能使你使用 ID 来指定字符串以及图标资源而不必使用代码来加载或者创建它们。

dwFlags 域保存了若干个允许你控制对话框的行为以及外观的标志。本分的后续篇幅会分别探讨这些标志。

文本标题

TASKDIALOGCONFIG 结构提供了以下在任务对话框上设置不同的文本标题的域：

pszWindowTitle
pszMainInstruction
pszContent
pszVerificationText
pszExpandedInformation
pszExpandedControlText
pszCollapsedControlText
pszFooter

所有的这些域都可以被初始化为字符串指针或者是用 MAKEINTRESOURCE 宏创建的资源标识符。除此之外，你还可以为自定义按钮设置标题，我们会在下一节里涉及这些。

下面的窗口截图展示了不同的文本标题：

“Window title” 可以在对话框创建之前通过 pszWindowTitle 域来指定。一旦创建，就可以使用常规的 SetWindowText 函数更新标题了。

“Main instruction” 可以在对话框创建之前通过 pszMainInstruction 域来指定。一旦创建，你就必须使用 TDM_SET_ELEMENT_TEXT 消息来更新文本。设置 WPARAM 为 TDE_MAIN_INSTRUCTION，设置 LPARAM 为字符串指针或者用 MAKEINTRESOURCE 宏创建的资源标识符。同样的方法也可用在 “Content”、“Verification text”、“Expanded information” 以及 “Footer” 文本标题上，只要为 WPARAM 传递不同的需要更新文本的控件的标识符即可。

“Expanded control text” 和 “Collapsed control text” 仅能在对话框创建之前通过 pszExpandedControlText 和 pszCollapsedControlText 域指定。Windows Vista Build 5456 中，在展开和收缩扩充信息的控件里有一个 bug。如果该控件失去了焦点，文本会恢复到为收缩状态所指定的值。

设置文本标题是否是一个挑战取决于你从哪儿取得文本以及你什么时候要设置它。在后文中，我们会看到如何使用 C++ 来梦幻般地简化这一工作。

按钮

任务对话框支持公用按钮与自定义按钮的任意组合。当前定义的公用按钮有：

TDCBF_OK_BUTTON (IDOK)
TDCBF_YES_BUTTON (IDYES)
TDCBF_NO_BUTTON (IDNO)
TDCBF_CANCEL_BUTTON (IDCANCEL)
TDCBF_RETRY_BUTTON (IDRETRY)
TDCBF_CLOSE_BUTTON (IDCLOSE)

你可以在 dwCommonButtons 域中指定这些按钮标志的任意组合。括号中的常量标明了当特定按钮被点击之后用以标识该按钮的按钮标识符。

可在文末找到的下载里的 Common Buttons 示例演示了公用按钮的使用：

你不能直接操纵公用按钮的事情之一是对它们重新排序或者改变它们的标题。要完全控制这些按钮，你需要提供一组 TASKDIALOG_BUTTON 结构。下面是指定了两个自定义按钮的简单例子：

TASKDIALOGCONFIG config = { sizeof (TASKDIALOGCONFIG) };

TASKDIALOG_BUTTON buttons[] =
{
    { 101, L"First Button" },
    { 102, L"Second Button" }
};

config.pButtons = buttons;
config.cButtons = _countof(buttons);

你也可以使用 MAKEINTRESOURCE 宏来为按钮所用到的字符串表中的字符串指定一个资源标识符。

除按钮外，任务对话框还可以容纳一组单选按钮。它们也可以使用一组 TASKDIALOG_BUTTON 结构来描述：

TASKDIALOG_BUTTON radioButtons[] =
{
    { 201, L"First Radio Button" },
    { 202, L"Second Radio Button" }
};

config.pRadioButtons = radioButtons;
config.cRadioButtons = _countof(radioButtons);

下面是以上代码的结果：

你还可以指定 TDF_USE_COMMAND_LINKS 标志把自定义按钮显示为命令链接。如果你不愿看到标题边的图标的话可以使用 TDF_USE_COMMAND_LINKS_NO_ICON 标志。

正如你看到的，这些标志仅仅影响自定义按钮。你指定的任何公用按钮仍然显示为常规按钮。

你还可以在你的按钮旁边显示那个声名狼藉的用户帐号控制（User Account Control）的盾形图标，只要给窗口发送 TDM_SET_BUTTON_ELEVATION_REQUIRED_STATE 消息即可。WPARAM 指定按钮标识符，LPARAM 指定一个指示要显示还是隐藏盾标的 BOOL 值。

无论你的按钮是命令链接还是常规按钮，它都会生效。同样，它还可以工作于像 OK 和 Cancel 这样的公用按钮，尽管通常都不会为这样一个按钮准备一个漂亮的用户体验去获取权限的提升。

图标

任务对话框可以选择性地显示一个“主”图标以及一个“脚注”图标。主图标出现在主指令（main instruction）文本的边上，而且，如果指定了 TDF_CAN_BE_MINIMIZED 标志，也可以显示在标题栏上。当存在脚注文本的时候，脚注图标显示在其附近。

指定图标需要点技巧。在对话框创建之前可以使用 pszMainIcon 域来指定一个使用了 MAKEINTRESOURCE 宏的图标资源标识符。如果你用这种方法，要确保 TDF_USE_HICON_MAIN 标志没有设置。另外，你还可以在 hMainIcon 域里指定一个图标句柄，在这种情况下，你就要确保设置了 the TDF_USE_HICON_MAIN 标志。

脚注图标是用同样的方式工作的。在对话框创建之前，可以使用 pszFooterIcon 域指定一个图标资源标识符。此外，还可以在 hFooterIcon 中指定一个图标句柄。对于脚注图标，表明你是要使用一个句柄的标志是 TDF_USE_HICON_FOOTER。

对话框创建后，你可以发送 TDM_UPDATE_ICON 消息来更新图标。把 WPARAM 设置为 TDIE_ICON_MAIN 来更新主图标，设置为 TDIE_ICON_FOOTER 来更新脚注图标。LPARAM 是要设置成图标资源标识符还是图标句柄则取决于创建时指定的标志是 TDF_USE_HICON_MAIN 还是 TDF_USE_HICON_FOOTER。

如同文本标题一样，把这些全部搞妥也是个挑战，本文稍后献上的 C++ 解决方案会在相当程度上简化这一问题。

进度条

任务对话框的显著特性之一是它提供了一个进度条。只要简单地指定一下 TDF_SHOW_PROGRESS_BAR 标志，你的任务对话框就会包含一个进度条。如果你希望把进度条显示为来回摆动的形式，可以使用 TDF_SHOW_MARQUEE_PROGRESS_BAR 标志。对话框创建之后，你还可以使用 TDM_SET_PROGRESS_BAR_MARQUEE 消息在常规进度条和往返进度条之间切换。把 WPARAM 设置为 TRUE 来显示为往返进度条，设置为 FALSE 来显示常规进度条。LPARAM 则以毫秒为单位用以控制往返动画的时延。

可以用 TDM_SET_PROGRESS_BAR_RANGE 消息来指定进度条的范围。LPARAM 中指定了范围的两个值，低位字中是范围的最小值而高位字中为范围的最大致。TDM_SET_PROGRESS_BAR_POS 消息用来设置进度条的居于范围内的位置。WPARAM 指定了位置的值。

还可以用 TDM_SET_PROGRESS_BAR_STATE 消息来改变进度条的状态。WPARAM 可以设置为 PBST_NORMAL、PBST_PAUSED 或者 PBST_ERROR。

本文下载里的 Progress 示例以及 Progress Effects 示例中演示了进度条的所有功能。

通知

任务对话框提供了一组通知，允许你加入行为以及事件发生时的响应。这些通知会被传递到你在 pfCallback 域中指定的一个回调函数。此回调函数的原型如下：

HRESULT __stdcall Callback(HWND handle,
                           UINT notification,
                           WPARAM wParam,
                           LPARAM lParam,
                           LONG_PTR data);

不过这一原型有些误导，因为没有任何消息是返回一个 HRESULT。仅有的一个返回了点东西的消息也仅仅是返回一个值为 TRUE 或者 FALSE 的布尔值。我希望这个问题能在发布之前解决（译者注：文本成文于 Windows Vista 正式版发布之前）。其中的 handle 参数提供了任务对话框的窗口句柄，你可以保存下来以备其他时间使用，直到收到 TDN_DESTROYED 通知为止。data 参数提供了你在 lpCallbackData 中指定的指针。这通常用于传递一个 C++ 窗口对象的指针到静态回调函数中。现在我们看一下这些通知。

TDN_DIALOG_CONSTRUCTED 是第一个到达的通知。它在对话框创建完毕而即将要显示的时候触发，因而随之提供了任务对话框的窗口句柄。在这个时候，你可以发送任何你想在显示之前修改对话框的外观的消息。随在本通知之后的是 TDN_CREATED 通知，不过你通常不需要理会它，除非你要执行一些针对特定窗口的初始化操作。这两个通知消息都可以用来执行初始化操作，只不过在导航页面发生时不会发送 TDN_CREATED 而只发送 TDN_DIALOG_CONSTRUCTED。下一节里会讨论导航。

毫无惊奇可言，TDN_BUTTON_CLICKED 通知表示一个按钮被点击过了。这既包括公用按钮也包括自定义按钮。这一通知还会在通过点击右上角的 X 或者按 Esc 键以取消对话框的情况下发出，不过这个功能仅在创建之前指定了 TDF_ALLOW_DIALOG_CANCELLATION 标志才有效。WPARAM 中为指示哪个按钮被点击了的按钮标识符。在前文里，我已经讨论过了按钮和按钮标识符。回调函数如果对此通知返回 FALSE 则会使对话框关闭，返回 TRUE 则会组织对话框被关闭。

TDN_RADIO_BUTTON_CLICKED 通知表示有一个单选按钮被点击了。WPARAM 中为指示哪个单选按钮被点击了的按钮标识符。。回调函数对此通知的返回值会被忽略掉。

TDN_HELP 通知表示用户在键盘上按下了 F1（帮助）键。试着提供些帮助吧。

TDN_VERIFICATION_CLICKED 通知表示确认复选框的状态发生了改变。WPARAM 为 FALSE 则为未选中状态，为 TRUE 则为选中状态。

TDN_EXPANDO_BUTTON_CLICKED 通知表示展开或者收缩“扩充信息”区域的控件被点击了。WPARAM 为 FALSE 则为收缩状态，为 TRUE 则为展开状态。

TDN_HYPERLINK_CLICKED 通知表示任务对话框中的某个文本域内的超链接被点击了。只有“内容”、“扩充信息”和“脚注”文本标题内才支持超链接，而且需要指定 TDF_ENABLE_HYPERLINKS 标志。超链接可以使用 HTML 中的 A（nchor）元素来定义，如下所示：

<a href="uri">text</a>

仅支持双引号，所以在必要时你可能需要转义。链接可以出现在大一些的串中间。在 href 属性中指定的值会由 LPARAM 提供，你可以用它来做任何你喜欢做的事，比如打开一个网页。任务对话框没有聪明到可以给它提供任何缺省的行为。本文下载里的 MainWindow 类演示了超链接的使用。

TDN_TIMER 通知用以提供一个定时器，你的对话框可以用它做各种事情，从更新对话框控件到在一段时间后自动关闭对话框。如果指定了 TDF_CALLBACK_TIMER 标志，则定时器通知会大约每 200 毫秒发送一次。本文下载里的 Timer 示例演示了定时器功能的使用：

消息

任务对话框会响应一些消息以便你用来按需模拟特定的动作。

TDM_CLICK_BUTTON 和 TDM_CLICK_RADIO_BUTTON 消息可以分别模拟按钮或者单选按钮的点击。WPARAM 中指定按钮标识符，LPARAM 参数会被忽略。

TDM_CLICK_VERIFICATION 消息模拟确认复选框的点击。WPARAM 里指示它应该是选中的（TRUE）还是未选中的（FALSE）。LPARAM 用以指示它是否应该接受焦点，TRUE 为是 FALSE 为否。

TDM_ENABLE_BUTTON 和 TDM_ENABLE_RADIO_BUTTON 消息分别可以启用或者禁用一个按钮或者单选按钮。WPARAM 指定按钮标识符，LPARAM 指示是要启用（TRUE）还是禁用（FALSE）。

我在前一节里避免提及的最后一个通知是 TDN_NAVIGATED，这个通知在本文写作之时还没有任何文档。它直接关系到 TDM_NAVIGATE_PAGE 消息，因此我认为应该在这儿讨论它。自从 TDM_NAVIGATE_PAGE 消息出现以来，它也是毫无任何文档。在调试器中经过几分钟的单步追踪汇编（当然有操作系统符号的配合）之后，我就可以把它说出来了。这些消息允许你转换，或者说是导航，从一个任务对话框到另一个，就像一个只能前进的向导一样。“新”的任务对话框有效地接管了前一个对话框的窗口，因此对于新的任务对话框来说，并不会有一个新的窗口创建出来。当我在反汇编器里跟踪到 comctl32.dll 的代码内部时，我发现 TDM_NAVIGATE_PAGE 的消息处理器并不读取 WPARAM，而是预期 LPARAM 中有一个指向描述了将要导航到的下一个对话框的外观和行为的 TASKDIALOGCONFIG 结构。然后 TDN_NAVIGATED 通知被发送到新任务对话框的回调函数里。本文的 Error 示例演示了这个功能。

C++ 的援助

任务对话框确实很强大，但是带来了使用性上的损失。尽管只暴露了两个函数，但任务对话框的 C API 却相当的复杂。为了解决这个问题，我使用自然 C++ 代码（译者注：自然 C++ 代码，原文为 native C++ code，作者可能是相对于托管 C++ 代码而言）写了 TaskDialog C++ 类来简化对任务对话框的使用。TaskDialog 类继承于 ATL 的 CWindow 类，封装了决大多数（如果不是全部的话）的任务对话框的功能，简化掉了有关准备 TASKDIALOGCONFIG 结构、发送消息以及响应通知的许多复杂性。本文下载中的所有示例都使用了我的 TaskDialog 类，所以你应该算是有了充足的可靠的例子。

下面是包含在本文的下载中的一个示例任务对话框的源代码：

class TimerDialog : public Kerr::TaskDialog
{
public:

    TimerDialog() :
        m_reset(false)
    {
        SetWindowTitle(L"Timer Sample");
        SetMainInstruction(L"Time elapsed: 0 seconds");
        AddButton(L"Reset", Button_Reset);

        m_config.dwFlags |= TDF_ALLOW_DIALOG_CANCELLATION |
                            TDF_CALLBACK_TIMER;
    }

private:

    enum
    {
        Button_Reset = 101
    };

    virtual void OnTimer(DWORD milliseconds,
                         bool&reset)
    {
        CString text;

        text.Format(L"Time elapsed: %.2f seconds",
                    static_cast<double>(milliseconds) / 1000);

        SetMainInstruction(text.GetString());

        reset = m_reset;
        m_reset = false;
    }

    virtual void OnButtonClicked(int buttonId,
                                 bool&closeDialog)
    {
        switch (buttonId)
        {
            case Button_Reset:
            {
                m_reset = true;
                break;
            }
            case IDCANCEL:
            {
                closeDialog = true;
                break;
            }
            default:
            {
                ASSERT(false);
            }
        }
    }

    bool m_reset;
};

如你所见，它为任务对话框提供了一个简单的、面向对象的模型。你不需要直接填充各种结构或者管理按钮定义的数组。TaskDialog 基类考虑到了所有的细节。提供了设置（以及更新）不同的文本标题和图标的方法，也提供了添加按钮以及发送各种消息的方法。最后，还提供了响应通知的虚方法。

使用如上定义的任务对话框是再简单不过了：

TimerDialog dialog;
Dialog.DoModal();

一旦 DoModal 方法返回，你就可以使用 GetSelectedButtonId、GetSelectedRadioButtonId 和 VerificiationChecked 方法来获取用户选定的各个按钮。

为了给你一个由 TaskDialog 类隐藏起来的复杂性的概念性认识，可以看一下 SetWindowTitle 方法的实现：

void Kerr::TaskDialog::SetWindowTitle(ATL::_U_STRINGorID text)
{
    if (0 == m_hWnd)
    {
        m_config.pszWindowTitle = text.m_lpstr;
    }
    else if (IS_INTRESOURCE(text.m_lpstr))
    {
        CString string;

        // Since we know that text is actually a resource Id we can ignore the pointer truncation warning.
        #pragma warning(push)
        #pragma warning(disable: 4311)

        VERIFY(string.LoadString(m_config.hInstance,
                                 reinterpret_cast<UINT>(text.m_lpstr)));

        #pragma warning(pop)

        VERIFY(SetWindowText(string));
    }
    else
    {
        VERIFY(SetWindowText(text.m_lpstr));
    }
}

ATL 的 _U_STRINGorID 类使得你可以轻易地指定一个字符串指针或者资源标识符。如果任务对话框还没有创建，则简单地更新内部的 TASKDIALOGCONFIG 结构。否则，就会使用 SetWindowText 函来更新窗口标题。使用这种方法，开发人员就可以在任意位置调用 SetWindowTitle 方法而无需根据窗口标题指定的时间或者数据来提供不同的代码。

示例

下载区中提供的本文的示例生动地演示了文章中讲到的所有特性。

这篇文章的终稿比我预计的要长一些。Windows Vista 任务对话框 API 实在是提供了太多的功能，简直使我无法适时地完成本文。这也是我所知道的关于任务对话框的唯一的完整的文档。我希望它能使许多的读者受益。

我原本计划使用托管代码来介绍任务对话框，可是 Daniel Moth 已经使用 C# 出色地完成了介绍任务对话框的工作。他还创建了一个 webcast，演示了许多创建任务对话框的方案，其中的 Task Dialog Designer 来源于我的 MSDN 杂志文章。我必须指出的是，该 webcast 中不正确地把 Kerr.Vista 配件说成是一个 COM DLL，而其实它仅仅是一个简单使用 C++/CLI 写就的 .NET 配件。

阅读第三部分：桌面窗口管理器

原文地址：http://weblogs.asp.net/kennykerr/archive/2006/07/18/Windows-Vista-for-Developers-_1320_-Part-2-_1320_-Task-Dialogs-in-Depth.aspx

译：Windows Vista for Developers - 第一部分 Aero 向导

Wed, 07 Mar 2007 13:26:32 GMT

Aero 向导体现了向导界面自从在 Windows 95 操作系统家族中首次推广以来的演变。它们为普通的向导界面提供了崭新的外观，而且被设计为可以为用户提供更专注的体验。在本 Windows Vista for Developers 系列的这第一个部分里，我将向你展示如何你就可以使用少量的代码把一个简单的向导转换为一个 Aero 向导。

属性表

扼要地讲，向导其实只是属性表的一个变体，属性表由 PROPSHEETHEADER 结构来定义而由 PropertySheet 函数实现。ATL 提供了 CPropertySheetImpl 类模板来生成使用 PropertySheet 函数牵涉到的许多代码。我们从一个简单的属性表开始，然后再看怎样把它改变为一个 Aero 向导：

class SampleWizard :
    public CPropertySheetImpl<SampleWizard>
{
public:

    BEGIN_MSG_MAP(SampleWizard)
        CHAIN_MSG_MAP(__super)
    END_MSG_MAP()

    SampleWizard() :
        CPropertySheetImpl<SampleWizard>(IDS_TITLE)
    {
        VERIFY(AddPage(m_page));
    }

private:

    SamplePage m_page;

};

SampleWizard 类派生于上述的 CPropertySheetImpl 类模板，该类模板提供了属性表的大部分功能。消息映射简单地把消息导向基类。构造函数调用了基类的构造函数以设置向导的标题，并使用继承自 CPropertySheetImpl 的 AddPage 方法向向导中添加了一个页面. SamplePage 类具有如下定义：

class SamplePage :
    public CPropertyPageImpl<SamplePage>
{
public:

    BEGIN_MSG_MAP(SamplePage)
        CHAIN_MSG_MAP(__super)
    END_MSG_MAP()

    enum { IDD = IDD_SAMPLE_PAGE };

};

SamplePage 类派生于 CPropertyPageImpl 类模板，该类模板提供了属性页的大部分功能。它也有一个简单的消息映射把消息都导向基类。一个 enum 定义了基类中所期望的 IDD 常量，用以标识属性页用到的对话框资源。

现在，你就可以用下列简单代码创建并显示一个模态属性表了：

SampleWizard sampleWizard;
sampleWizard.DoModal();

第一行创建了 SampleWizard 对象，其中，各个基类会负责构造调用 PropertySheet 函数所需的结构。SampleWizard 继承自 CPropertySheetImpl 类模板的 DoModal 方法则负责调用 PropertySheet 函数。其结果就是一个简单的属性表：

经典向导

要把属性表变为一个经典的向导，你所需的全部工作就是把下列语句添加到 SampleWizard 的构造函数中：

m_psh.dwFlags |= PSH_WIZARD97;

它所做的就是把 PSH_WIZARD97 标志合并到已经在 PROPSHEETHEADER 结构里已经设置过的标志中。由于向导提供了一个额外的顶头区域，所以还要更新 SamplePage 类来指定此页的标头文字：

class SamplePage :
    public CPropertyPageImpl<SamplePage>
{
public:

    BEGIN_MSG_MAP(SamplePage)
        CHAIN_MSG_MAP(__super)
    END_MSG_MAP()

    enum { IDD = IDD_BLANK_PAGE };

    SamplePage()
    {
        VERIFY(m_title.LoadString(IDS_PAGE_TITLE));
        SetHeaderTitle(m_title);
    }

private:

    CString m_title;

};

SamplePage 的构造函数使用继承于 CPropertyPageImpl 的 SetHeaderTitle 方法来设置页面的标头标题。要记住的是在页面的 PROPSHEETPAGE 结构里存储的是一个字符串指针，因此，字符串的生命期必须要超出构造函数。

经过这些适当的小改动，结果发生了相当引人注目的不同：

正如你可能注意到的，先前出现在标签上的文字已经把窗口标题替换了。

Aero 向导

现在，将 SampleWizard 构造函数中的 PSH_WIZARD97 替换为 PSH_AEROWIZARD，然后你就得到了新式的 Aero 向导界面：

你应该注意到窗口标题又变了回来而原来出现在属性表标签上的对话框标题已经不再使用了。

新消息

Aero 向导支持几个新的消息，用以更好地控制由向导提供的标准控件。

PSM_SHOWWIZBUTTONS 消息显示或者隐藏修饰向导的任意标准按钮。PropSheet_ShowWizButtons 宏可以简化此消息的发送。使用它并不是特别的自然，不过一旦掌握了它，你就不该再有任何问题了。尽管只是一个宏，不过把它想象为一个如下定义的函数更有用（宏易于误解）：

void PropSheet_ShowWizButtons(HWND handle,
DWORD buttons,
DWORD mask);

handle 参数标识了向导窗口，buttons 参数指示要显示哪些按钮，而 mask 参数指示要操作哪些按钮。如果一个按钮标志同时出现于 buttons 和 masks 参数中则会被显示。如果一个按钮仅出现于 mask 参数中则会被隐藏。共有下列按钮标志可以使用：

PSWIZB_BACK
PSWIZB_NEXT
PSWIZB_FINISH
PSWIZB_CANCEL

例如，下面的调用将显示 Next 按钮而隐藏 Back 按钮：

PropSheet_ShowWizButtons(handle,
PSWIZB_NEXT,
PSWIZB_BACK | PSWIZB_NEXT);

PSM_ENABLEWIZBUTTONS 消息启用或者禁用任意标准按钮。PropSheet_EnableWizButtons 宏简化了此消息的发送：

void PropSheet_EnableWizButtons(HWND handle,
DWORD buttons,
DWORD mask);

在如何标识按钮上此消息与 PSM_SHOWWIZBUTTONS 的工作方式是一致的。buttons 参数指示那些按钮要启用或者禁用而 mask 参数指示要操作哪些按钮。例如，下列调用将启用 Next 按钮并禁用 Back 按钮。

PropSheet_EnableWizButtons(handle,
PSWIZB_NEXT,
PSWIZB_BACK | PSWIZB_NEXT);

PSM_SETBUTTONTEXT 消息可以修改 Next、Finish 以及 Cancel 按钮的文字。PropSheet_SetButtonText 宏简化了此消息的发送：

void PropSheet_SetButtonText(HWND handle,
DWORD button,
PCWSTR text);

示例

为了让你能简单地试验 Aero 向导提供的各种选项，我创建了一个简单的向导工程你可以下载并用它进行实践：

阅读第二部分：深入任务对话框

原文地址：http://weblogs.asp.net/kennykerr/archive/2006/07/12/Windows-Vista-for-Developers-_1320_-Part-1-_1320_-Aero-Wizards.aspx

为 Windows Live Messenger 设置自动回复功能

Tue, 30 Jan 2007 02:16:30 GMT

微软为编制 Windows Live Messenger 的插件提供了良好的支持。要使插件可以工作，需要以下三个步骤：

1、开启 Windows Live Messenger 的插件功能
2、编制插件
3、注册插件

1、开启 Windows Live Messenger 的插件功能。
这个非常简单，打开注册表编辑器，展开 HKEY_CURRENT_USER\Software\Microsoft\MSNMessenger，查看 AddInFeatureEnabled 键值是否存在，不在则创建之，数据类型为 DWORD。将键值置为 1。然后重新启动 MSN Live Messenger。

2、编制插件
   用 C# 或者任意其他的 .NET 语言新建工程，向工程中添加对 MessengerClient.dll 的引用。为了避免总是使用完整规格的名称，你可以添加 using Microsoft.Messenger 语句。
   接下来创建一个类，名字随便，此处以 AddIn 代之。该类需要实现一个名为 IMessengerAddIn 的接口。该接口中的 Initialize 方法需要实现，因为我们仅是要实现自动回复，仅需如下这样注册 IncomingTextMessage 事件：
   Client.IncomingTextMessage += new EventHandler<IncomingTextMessageEventArgs>(Client_IncomingTextMessage);
   然后再实现这个事件处理器：
   public void Client_IncomingTextMessage(Object Sender, IncomingTextMessageEventArgs e)
   {
     User userFrom = e.UserFrom;
     Client.SendNudgeMessage(userFrom);
     Client.SendTextMessage("Hey, I m busy. Please leave your message.", userFrom);
   }
   编译得到 DLL，DLL 的默认名字为名字空间.DLL，把它改为名字空间.类名.DLL。而且，类名要注意大小写。

3、注册插件
打开 Windows Live Messenger，打开选项对话框，左侧列表的最下方就会多出一项“加载项”，选中它，然后点击“添加至 Messenger”按钮，找到你上面生成的 DLL 即可。

4、友情提示
不工作不要找我。

本文为意译，原文在 www.codeproject.com 上。

好玩的浏览器

Tue, 19 Dec 2006 14:07:42 GMT

//
// Integrated browser mode - package up a bunch of data into a COPYDATASTRUCT,
// and send it to the desktop window via SendMessage(WM_COPYDATA).
//
void LaunchInternetExplorerWithoutProcess()
{
#define MAX_IEEVENTNAME 32

    // First piece of data is a wide string version of the command line.
    WCHAR wsz[MAX_IEEVENTNAME] = L"";
    COPYDATASTRUCT cds = { SW_NORMAL, sizeof(WCHAR), wsz };

    // Second piece of data is the event to fire when the browser window reaches WM_CREATE.
    static DWORD dwNextId = 0;
    TCHAR szEvent[MAX_IEEVENTNAME + 1];
    wsprintf(szEvent, TEXT("IE-%08X-%08X"), GetCurrentThreadId(), dwNextId++);

    HANDLE hEventReady = CreateEvent(NULL, FALSE, FALSE, szEvent);
    if(hEventReady)
    {
        // Put the (UNICODE) event name at the end of the cds data
        LPWSTR pwszEvent = &wsz[1];
#ifdef UNICODE
        lstrcpy(pwszEvent, szEvent);
#else
        MultiByteToWideChar(CP_ACP, 0, szEvent, -1, pwszEvent, sizeof(szEvent) / sizeof(szEvent[0]));
#endif
        cds.cbData += (lstrlenW(pwszEvent) + 1) * sizeof(WCHAR);

        // Send the message
        HWND hwndDesktop = GetShellWindow();
        int iRet = (int)SendMessage(hwndDesktop, WM_COPYDATA, (WPARAM)hwndDesktop, (LPARAM)&cds);
        if(iRet)
        {
            // Wait for the browser window to hit WM_CREATE.
            // When this happens, all DDE servers will have been registered.
            DWORD dwRet = WaitForSingleObject(hEventReady, 1000 * 10); // 10 seconds
#ifdef ASSERT
            ASSERT(dwRet == WAIT_OBJECT_0);
#endif // ASSERT
        }

        CloseHandle(hEventReady);
    }
#undef MAX_IEEVENTNAME
}

自己实现对窗口的位置和大小进行改变的功能

Sun, 19 Nov 2006 06:51:51 GMT

在很多情况下，我们需要去掉 Windows 窗口的默认标题栏和边框，但又希望能够像原来一样对窗口进行正常的改变位置或者大小的操作。许多程序员采用响应 WM_LBUTTONDOWN/WM_LBUTTONUP 消息，鼠标拖动时自己绘制拖动框（在系统的“拖动时显示窗口内容”选项关闭的情况下）或者不停调用 MoveWindow()/SetWindowPos() API 对窗口的位置或者大小进行更新（在系统的“拖动时显示窗口内容”选项开启的情况下）。这样做虽然可以达到效果，但是相较老汉下面将要描述的方法，稍微麻烦了一些，而且出于用户体验的完整性考虑，需要自己检测拖动过程中用户是否按下了 Esc 键，或者是正在拖动的窗口突然被其他窗口夺取了焦点等等小概率事件。

老汉介绍的方法，整个拖动操作仍然使用系统自身的功能，所以不存在上述问题。其核心思想就是改变系统在对窗口进行点击测试是返回的值，对系统进行一定程度上的欺骗，使其认为鼠标依旧是点击到了默认的标题栏或者边框，从而执行相应的动作。

下面是示例代码。使用向导生成一个 MFC 对话框应用，假定对话框类的名字为 CMvszDlg，向该类添加对 WM_PAINT 和 WM_NCHITTEST 消息的处理函数（默认在 ClassWizard 中是看不到 WM_NCHITTEST 消息的，需要切换到 ClassWizard 的“Class Info”标签，将“Message filter”选择为“Window”）。然后把下面的代码分别复制到对应的消息处理函数中，编译运行即可看到效果。其中，OnPaint() 的实现是为了演示目的，在真实的应用中，显然可以使用更漂亮的效果。


#define BORDER_SIZE     4
#define CAPTION_SIZE    24

void CMvszDlg::OnPaint() 
{
    Invalidate();

    CPaintDC dc(this);

    CRect rc;
    GetClientRect(&rc);

    CBrush* pbr = CBrush::FromHandle((HBRUSH)GetStockObject(NULL_BRUSH));

    dc.SelectObject(pbr);
    dc.Rectangle(&rc);

    dc.MoveTo(0, BORDER_SIZE + CAPTION_SIZE);
    dc.LineTo(rc.right, BORDER_SIZE + CAPTION_SIZE);

    dc.MoveTo(0, rc.bottom - (BORDER_SIZE + CAPTION_SIZE));
    dc.LineTo(BORDER_SIZE, rc.bottom - (BORDER_SIZE + CAPTION_SIZE));
    dc.MoveTo(rc.right - BORDER_SIZE, rc.bottom - (BORDER_SIZE + CAPTION_SIZE));
    dc.LineTo(rc.right, rc.bottom - (BORDER_SIZE + CAPTION_SIZE));

    dc.MoveTo(BORDER_SIZE + CAPTION_SIZE, 0);
    dc.LineTo(BORDER_SIZE + CAPTION_SIZE, BORDER_SIZE);
    dc.MoveTo(BORDER_SIZE + CAPTION_SIZE, rc.bottom - BORDER_SIZE);
    dc.LineTo(BORDER_SIZE + CAPTION_SIZE, rc.bottom);

    dc.MoveTo(rc.right - (BORDER_SIZE + CAPTION_SIZE), 0);
    dc.LineTo(rc.right - (BORDER_SIZE + CAPTION_SIZE), BORDER_SIZE);
    dc.MoveTo(rc.right - (BORDER_SIZE + CAPTION_SIZE), rc.bottom - BORDER_SIZE);
    dc.LineTo(rc.right - (BORDER_SIZE + CAPTION_SIZE), rc.bottom);

    rc.DeflateRect(BORDER_SIZE, BORDER_SIZE);
    dc.Rectangle(&rc);
}

UINT CMvszDlg::OnNcHitTest(CPoint point) 
{
    ScreenToClient(&point);

    CRect rc;
    GetClientRect(&rc);

    CRect rcTest = rc;
    rcTest.DeflateRect(BORDER_SIZE, BORDER_SIZE);

    int iBottom = rcTest.bottom;
    rcTest.bottom = rcTest.top + CAPTION_SIZE;
    if(rcTest.PtInRect(point))
        return HTCAPTION;

    rcTest.top = rcTest.bottom;
    rcTest.bottom = iBottom;
    if(rcTest.PtInRect(point))
        return HTCLIENT;

    rcTest.SetRect(0, 0, BORDER_SIZE + CAPTION_SIZE, BORDER_SIZE + CAPTION_SIZE);
    if(rcTest.PtInRect(point))
        return HTTOPLEFT;

    rcTest.SetRect(BORDER_SIZE + CAPTION_SIZE, 0, rc.right - (BORDER_SIZE + CAPTION_SIZE), BORDER_SIZE + CAPTION_SIZE);
    if(rcTest.PtInRect(point))
        return HTTOP;

    rcTest.SetRect(rc.right - (BORDER_SIZE + CAPTION_SIZE), 0, rc.right, BORDER_SIZE + CAPTION_SIZE);
    if(rcTest.PtInRect(point))
        return HTTOPRIGHT;

    rcTest.SetRect(0, BORDER_SIZE + CAPTION_SIZE, BORDER_SIZE, rc.bottom - (BORDER_SIZE + CAPTION_SIZE));
    if(rcTest.PtInRect(point))
        return HTLEFT;

    rcTest.SetRect(rc.right - BORDER_SIZE, BORDER_SIZE + CAPTION_SIZE, rc.right, rc.bottom - (BORDER_SIZE + CAPTION_SIZE));
    if(rcTest.PtInRect(point))
        return HTRIGHT;

    rcTest.SetRect(0, rc.bottom - (BORDER_SIZE + CAPTION_SIZE), BORDER_SIZE + CAPTION_SIZE, rc.bottom);
    if(rcTest.PtInRect(point))
        return HTBOTTOMLEFT;

    rcTest.SetRect(BORDER_SIZE + CAPTION_SIZE, rc.bottom - BORDER_SIZE, rc.right - (BORDER_SIZE + CAPTION_SIZE), rc.bottom);
    if(rcTest.PtInRect(point))
        return HTBOTTOM;

    rcTest.SetRect(rc.right - (BORDER_SIZE + CAPTION_SIZE), rc.bottom - (BORDER_SIZE + CAPTION_SIZE), rc.right, rc.bottom);
    if(rcTest.PtInRect(point))
        return HTBOTTOMRIGHT;

    return HTERROR;
}

半透明窗口中的孤岛

Sat, 21 Oct 2006 02:44:51 GMT

几天前在 CSDN 上有人问及一个问题：如何使得一个半透明窗口上，控件所占据的位置是不透明的？

开始有人提到使用 SetLayeredWindowAttributes() API，但考虑到该 API 会将整个窗口设置为一致的透明度，显然不可能满足问题中的要求。所以老汉认为应该使用 UpdateLayeredWindow() API 来完成这一工作，为了不重复输入，把我当时的回复抄录如下：“

真正可以使用的 API 是 UpdateLayeredWindow()。此函数可以根据一幅选入到 DC 中去的 32 位位图的每个像素的 Alpha 通道值设置窗口上对应像素的半透明度。其实现在楼主要做得就是，总是生成一幅和窗口大小一样的 32 位位图，把控件占据的区域的位图像素的 Alpha 通道值全部设置为 255，即不透明，而其余地方的像素则可以根据需要设置为适当的半透明，然后再调用本函数即可。需要注意的是，如果窗口的大小可以改变的话，显然每次都需要动态生成此位图，并调用本函数对窗口进行更新。

”。为了验证这一想法，我特意完成了一个类 CWindowUpdater，代码附后。使用者仅需在顶级窗口的 WM_SIZE 消息的响应中调用 CWindowUpdater::Update(hwnd) 即可。

需要说明的是，这种方法虽然在视觉上解决了上述问题，但是带来了另外一个问题。经过 UpdateLayeredWindow() 作用的窗口，其内容会因此而变成一幅静态图像，所以后果会成为，虽然控件是不透明的，但是用户与控件交互（例如鼠标点击，键盘输入等）时原本应该有的视觉反馈（例如按钮成为下压状态）却全部不可见了，这使得这种方法基本上是鸡肋，并没有真正意义上的实用价值。如果有哪位实现了更完美的解决方案，望不吝赐教。不过，它至少在技术上演示了如何设置窗口上每个像素的透明度。


class CWindowUpdater
{
typedef BOOL (WINAPI *fnUpdateLayeredWindow)(HWND hWnd, 
        HDC hdcDst, LPPOINT pptDst, LPSIZE psize, 
        HDC hdcSrc, LPPOINT pptSrc, COLORREF crKey, PBLENDFUNCTION pblend, DWORD dwFlags);

    static int BytesPerLine(int iWidth, int iBitsPerPixel)
    {
        return ((iWidth * iBitsPerPixel + 31) & (~31)) >> 3;
    }

public:
    static BOOL Update(HWND hwnd)
    {
        static fnUpdateLayeredWindow _fnUpdateLayeredWindow = (fnUpdateLayeredWindow)-1;

        if(_fnUpdateLayeredWindow == (fnUpdateLayeredWindow)-1)
        {
            (FARPROC&)_fnUpdateLayeredWindow = GetProcAddress(GetModuleHandle(_T("USER32.DLL")),
                "UpdateLayeredWindow");
        }

        if(!_fnUpdateLayeredWindow)
            return FALSE;

        RECT rc;
        if(!GetWindowRect(hwnd, &rc))
            return FALSE;

        SIZE size = { rc.right - rc.left, rc.bottom - rc.top };

        HDC hdcMem = CreateCompatibleDC(NULL);
        if(!hdcMem)
            return FALSE;

        // 1. create a 32-bit memory bitmap according to the window's size
        BITMAPINFOHEADER bmih = { 0 };

        // Populate BITMAPINFO header
        bmih.biSize = sizeof(BITMAPINFOHEADER);
        bmih.biWidth = size.cx;
        bmih.biHeight = size.cy;
        bmih.biPlanes = 1;
        bmih.biBitCount = 32;
        bmih.biCompression = BI_RGB;
        bmih.biClrUsed = 0;
        bmih.biSizeImage = BytesPerLine(size.cx, 32) * size.cy;

        PVOID pvBits = NULL;
        HBITMAP hbmpMem = CreateDIBSection(NULL, (PBITMAPINFO)&bmih, DIB_RGB_COLORS, &pvBits, NULL, 0);
        if(hbmpMem)
        {
            HGDIOBJ hbmpOld = SelectObject(hdcMem, hbmpMem);

            // 2. get window's content
            SendMessage(hwnd, WM_PRINT, (WPARAM)hdcMem, (LPARAM)PRF_NONCLIENT | PRF_CLIENT | PRF_CHILDREN | PRF_CHECKVISIBLE);

            // 3. get rid of the areas occupied by children
            // SetWindowTransparency(hwnd, hdcMem, hbmpMem, 128, FALSE);
            SetWindowTransparency(hwnd, pvBits, size.cx, size.cy, 128, FALSE);

            // 4. pre-multiply rgb channels with alpha channel
            // PreMultiplyRGBChannels(hdcMem, hbmpMem);
            PreMultiplyRGBChannels(pvBits, size.cx, size.cy);

            // 5. ensure the WS_EX_LAYERED extended style is there
            SetWindowLong(hwnd, GWL_EXSTYLE, GetWindowLong(hwnd, GWL_EXSTYLE) | 0x00080000); // WS_EX_LAYERED

            // 6. update the window
            POINT ptSrc = { 0, 0 }; // start point of the copy from memory DC to screen DC
            BLENDFUNCTION bf = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
            _fnUpdateLayeredWindow(hwnd, NULL, (LPPOINT)&rc, &size, hdcMem, &ptSrc, 0, &bf, 0x00000002); // ULW_ALPHA

            // clean up
            SelectObject(hdcMem, hbmpOld);
            DeleteObject(hbmpMem);
        }

        DeleteDC(hdcMem);

        return TRUE;
    }

    static BOOL PreMultiplyRGBChannels(HDC hdc, HBITMAP hbmp)
    {
        if(!hdc || !hbmp)
            return FALSE;

        BITMAPINFO bmi = { 0 };
        bmi.bmiHeader.biSize = sizeof(bmi);
        if(!GetDIBits(hdc, hbmp, 0, 1, 0, &bmi, DIB_RGB_COLORS) || bmi.bmiHeader.biBitCount != 32)
            return FALSE;

        PBYTE pBuff = new BYTE[bmi.bmiHeader.biSizeImage + 0x20];
        if(!pBuff)
            return FALSE;

        BOOL bRet = FALSE;
        bmi.bmiHeader.biSize = sizeof(bmi);
        bmi.bmiHeader.biCompression = BI_RGB;
        if(GetDIBits(hdc, hbmp, 0, bmi.bmiHeader.biHeight, (PVOID)pBuff, &bmi, DIB_RGB_COLORS))
        {
            PreMultiplyRGBChannels(pBuff, bmi.bmiHeader.biWidth, bmi.bmiHeader.biHeight);
            bRet = SetDIBits(hdc, hbmp, 0, bmi.bmiHeader.biHeight, (PVOID)pBuff, &bmi, DIB_RGB_COLORS);
        }

        delete[] pBuff;

        return bRet;
    }

    static BOOL PreMultiplyRGBChannels(PVOID pvBits, int cx, int cy)
    {
        if(!pvBits || cx <= 0 || cy <= 0)
            return FALSE;

        // pre-multiply rgb channels with alpha channel
        for(int y=0; y<cy; y++)
        {
            PBYTE pPixel = ((PBYTE)pvBits) + cx * 4 * y;

            for(int x=0; x<cx; x++)
            {
                pPixel[0] = pPixel[0] * pPixel[3] / 255;
                pPixel[1] = pPixel[1] * pPixel[3] / 255;
                pPixel[2] = pPixel[2] * pPixel[3] / 255;

                pPixel += 4;
            }
        }

        return TRUE;
    }

    static BOOL SetWindowTransparency(HWND hwnd, HDC hdc, HBITMAP hbmp, int iAlpha, BOOL bExcludeChildren)
    {
        if(!hwnd || !IsWindow(hwnd) || !hdc || !hbmp || iAlpha < 0 || iAlpha > 255)
            return FALSE;

        BITMAPINFO bmi = { 0 };
        bmi.bmiHeader.biSize = sizeof(bmi);
        if(!GetDIBits(hdc, hbmp, 0, 1, 0, &bmi, DIB_RGB_COLORS) || bmi.bmiHeader.biBitCount != 32)
            return FALSE;

        PBYTE pBuff = new BYTE[bmi.bmiHeader.biSizeImage + 0x20];
        if(!pBuff)
            return FALSE;

        BOOL bRet = FALSE;
        bmi.bmiHeader.biSize = sizeof(bmi);
        bmi.bmiHeader.biCompression = BI_RGB;
        if(GetDIBits(hdc, hbmp, 0, bmi.bmiHeader.biHeight, (PVOID)pBuff, &bmi, DIB_RGB_COLORS))
        {
            SetWindowTransparency(hwnd, pBuff, bmi.bmiHeader.biWidth, bmi.bmiHeader.biHeight, iAlpha, bExcludeChildren);
            bRet = SetDIBits(hdc, hbmp, 0, bmi.bmiHeader.biHeight, (PVOID)pBuff, &bmi, DIB_RGB_COLORS);
        }

        delete[] pBuff;

        return bRet;
    }

    static BOOL SetWindowTransparency(HWND hwnd, PVOID pvBits, int cx, int cy, int iAlpha, BOOL bExcludeChildren)
    {
        if(!hwnd || !IsWindow(hwnd) || !pvBits || cx <= 0 || cy <= 0 || iAlpha < 0 || iAlpha > 255)
            return FALSE;

        RECT rcWindow;
        GetWindowRect(hwnd, &rcWindow);
        MapWindowPoints(HWND_DESKTOP, hwnd, (LPPOINT)&rcWindow, 2);

        // 1. get all children
        HRGN hrgnChildren = CreateRectRgn(0, 0, 0, 0);

        RECT rc;
        HWND hwndChild = GetWindow(hwnd, GW_CHILD);
        while(hwndChild)
        {
            GetWindowRect(hwndChild, &rc);                          // in screen coord'
            MapWindowPoints(HWND_DESKTOP, hwnd, (LPPOINT)&rc, 2);   // in client coord'
            OffsetRect(&rc, -rcWindow.left, -rcWindow.top);         // in window coord'

            HRGN hrgnChild = CreateRectRgnIndirect(&rc);
            CombineRgn(hrgnChildren, hrgnChildren, hrgnChild, RGN_OR);
            DeleteObject(hrgnChild);

            hwndChild = GetWindow(hwndChild, GW_HWNDNEXT);
        }

        for(int y=0; y<cy; y++)
        {
            PBYTE pPixel = ((PBYTE)pvBits) + cx * 4 * y;

            for(int x=0; x<cx; x++)
            {
                if(PtInRegion(hrgnChildren, x, cy - y))
                    pPixel[3] = 255;
                else
                    pPixel[3] = iAlpha;

                pPixel += 4;
            }
        }

        DeleteObject(hrgnChildren);

        return TRUE;
    }
};

译：MFC 程序员的 WTL 教程（十）（第二版）

Thu, 03 Aug 2006 12:31:30 GMT

特别注：由于本页内容栏宽度不够，会导致部分内容看不见，请点击这里以获得最佳浏览效果。

链接：上一部分

第十部分 - 实现一个拖放源

下载示例工程 - 97KB

简介

拖放是许多流行应用的特性之一。尽管实现一个放下目标相当简单，但拖动源却要复杂的多。MFC 中有两个类 COleDataObject 和 COleDropSource 可以帮助管理拖动源所必须提供的数据，但 WTL 中没有这种辅助类。对于我们这些 WTL 用户来说，幸运的是，Raymond Chen 在 2000 年的时候在 MSDN 上写过一篇文章（“The Shell Drag/Drop Helper Object Part 2”），其中有 IDataObject 的纯 C++ 实现，这对于为 WTL 应用编制一个完整的拖放源提供了巨大的帮助。

本文的示例工程是一个 CAB 文件查看器，可以使你从 CAB 中提取文件，只要把它们从查看器里拖到资源浏览器窗口中即可。本文还会讨论几个新的框架窗口话题，例如对文件打开的处理以及类似于 MFC 的文档/视图框架的数据管理。我还会演示 WTL 的 MRU（most-recently-used，最近使用）文件列表类，以及第六版的列表视图控件的几个新的 UI 特性。

重要提示：你需要从微软下载并安装 CAB SDK 来编译示例代码。在 KB 文章 Q310618 中有此 SDK 的链接。示例工程假定 SDK 位于和源代码相同的路径下的名为“cabsdk”的目录中。

记住，如果你在安装 WTL 或者编译示例代码时遇到了问题，请在这儿提问之前先阅读第一部分的 readme 一节。

开始工程

要开始我们的 CAB 查看器应用，需要运行 WTL AppWizard 并创建一个名为 WTLCabView 的工程。它应该是一个 SDI 应用，所以在第一页中选择 SDI Application：

在下一页里，去掉 Command Bar，并把 View Type 改为 List View。向导会为我们的视图窗口创建一个派生自 CListViewCtrl 的 C++ 类。

视图窗口类看起来就是这样：

class CWTLCabViewView :
  public CWindowImpl<CWTLCabViewView, CListViewCtrl>
{
public:
  DECLARE_WND_SUPERCLASS(NULL, CListViewCtrl::GetWndClassName())
 
  // Construction
  CWTLCabViewView();
 
  // Maps
  BEGIN_MSG_MAP(CWTLCabViewView)
  END_MSG_MAP()
 
  // ...
};

就像我们在第二部分里使用视图类一样，我们可以使用 CWindowImpl 的第三个模板参数设置缺省的窗口风格：

#define VIEW_STYLES \
  (LVS_REPORT | LVS_SHOWSELALWAYS | \
   LVS_SHAREIMAGELISTS | LVS_AUTOARRANGE )
#define VIEW_EX_STYLES (WS_EX_CLIENTEDGE)
 
class CWTLCabViewView :
  public CWindowImpl<CWTLCabViewView, CListViewCtrl,
                     CWinTraitsOR<VIEW_STYLES,VIEW_EX_STYLES> >
{
//...
};

由于在 WTL 中没有文档/视图框架，视图类需要做双份的工作，既是 UI，也是存放有关 CAB 信息的地方。在拖放操作中传递的数据结构为 CDraggedFileInfo：

struct CDraggedFileInfo
{
  // Data set at the beginning of a drag/drop:
  CString sFilename;      // name of the file as stored in the CAB
  CString sTempFilePath;  // path to the file we extract from the CAB
  int nListIdx;           // index of this item in the list ctrl
 
  // Data set while extracting files:
  bool bPartialFile;  // true if this file is continued in another cab
  CString sCabName;   // name of the CAB file
  bool bCabMissing;   // true if the file is partially in this cab and
                      // the CAB it's continued in isn't found, meaning
                      // the file can't be extracted
 
  CDraggedFileInfo ( const CString& s, int n ) :
    sFilename(s), nListIdx(n), bPartialFile(false),
    bCabMissing(false)
  { }
};

视图类中还有如下方法：初始化、管理文件列表，以及在拖放操作开始的时候准备一个 CDraggedFileInfo 列表。由于本文是讲关于拖放的，所以我不会深入到 UI 工作的内部去，需要了解所有细节的话可以检视示例工程中的 WTLCabViewView.h。

文件打开处理

要查看一个 CAB 文件，用户可以使用 File-Open 命令并选择一个 CAB 文件。向导为 CMainFrame 生成的代码包含了 File-Open 菜单项的一个处理器：

  BEGIN_MSG_MAP(CMainFrame)
    COMMAND_ID_HANDLER_EX(ID_FILE_OPEN, OnFileOpen)
  END_MSG_MAP()

OnFileOpen() 使用了 CMyFileDialog 类，该类是在第九部分里介绍到的 WTL 的 CFileDialog 的增强版本，用以显示一个标准的文件打开对话框。

void CMainFrame::OnFileOpen (
  UINT uCode, int nID, HWND hwndCtrl )
{
CMyFileDialog dlg ( true, _T("cab"), 0U,
                    OFN_HIDEREADONLY|OFN_FILEMUSTEXIST,
                    IDS_OPENFILE_FILTER, *this );
 
  if ( IDOK == dlg.DoModal(*this) )
    ViewCab ( dlg.m_szFileName );
}

OnFileOpen() 调用了辅助函数 ViewCab()：

void CMainFrame::ViewCab ( LPCTSTR szCabFilename )
{
  if ( EnumCabContents ( szCabFilename ) )
    m_sCurrentCabFilePath = szCabFilename;
}

EnumCabContents() 相当的复杂，它使用 CAB SDK 调用来枚举在 OnFileOpen() 中选中的文件的内容，并填充视图窗口。不过 ViewCab() 现在还不完善，我们后面会给它加入支持 MRU 列表的代码。下面是查看器的样子，其中显示着 Windows 98 的某个 CAB 文件的内容：

EnumCabContents() 使用了视图类中的两个方法来填充 UI：AddFile() 和 AddPartialFile()。AddPartialFile() 在当一个文件被部分存储在 CAB 中时被调用，因为其头部是在前面的 CAB 里。在上面的截图里，列表中的第一个文件就是一个部分文件。其余的文件是通过 AddFile() 添加的。这两个方法都会为要添加的文件分配一个数据结构，从而视图可以知道其显示的每个文件的所有相关细节。

如果 EnumCabContents() 返回真，则代表所有的枚举以及 UI 设置工作成功完成。如果我们只是写一个简单的 CAB 查看器，我们就可以收手了，尽管此应用不那么有趣。为了使它真正地有用，我们将对它添加拖放支持，以使用户可以从 CAB 中提取文件。

拖动源

拖放源是一个 COM 对象，它实现了两个接口：IDataObject 和 IDropSource。IDataObject 用来存放在拖放操作中客户端需要传递的任意数据，在我们这种情况下，此数据应该是一个 HDROP 结构，其中列出了要从 CAB 中提取的文件。IDropSource 的方法会由 OLE 调用，用以在拖放操作中向源通知事件。

拖动源接口

实现了我们的拖放源的 C++ 类为 CDragDropSource。该类以我在简介中提到过的 MSDN 文章中的 IDataObject 实现为起始。在该文中你可以找到所有代码相关的细节，因此我在这儿就不重复了。然后我们再向类中加入 IDropSource 及其两个方法：

class CDragDropSource :
  public CComObjectRootEx<CComSingleThreadModel>,
  public CComCoClass<CDragDropSource>,
  public IDataObject,
  public IDropSource
{
public:
  // Construction
  CDragDropSource();
 
  // Maps
  BEGIN_COM_MAP(CDragDropSource)
    COM_INTERFACE_ENTRY(IDataObject)
    COM_INTERFACE_ENTRY(IDropSource)
  END_COM_MAP()
 
  // IDataObject methods not shown...
 
  // IDropSource
  STDMETHODIMP QueryContinueDrag (
                 BOOL fEscapePressed, DWORD grfKeyState );
  STDMETHODIMP GiveFeedback ( DWORD dwEffect );
};

用于调用者的辅助方法

CDragDropSource 使用几个辅助方法封装了 IDataObject 的管理以及拖放的通信。一个拖放操作遵循以下模式：

主框架得到用户开始拖放操作的通知。
主框架调用视图窗口来创建一个被拖动的文件的列表。视图在一个 vector<CDraggedFileInfo> 向量中返回此信息。
主框架创建一个 CDragDropSource 对象并将上述向量传递给它，以使它得知要从 CAB 中提取哪些文件。
主框架开始拖放操作。
如果用户在一个适当的拖放目标上放下，则 CDragDropSource 对象提取文件。
主框架更新 UI 以标示不能被提取的文件。

步骤 3 到 6 由辅助方法处理。初始化在 Init() 方法中完成：

   bool Init(LPCTSTR szCabFilePath, vector<CDraggedFileInfo>& vec);

Init() 将数据复制到保护成员中，填入到一个 HDROP 结构，并使用 IDataObject 方法将该结构保存到数据对象中。Init() 还作了另一个重要的步骤：它在 TEMP 目录下为每个拖动的文件创建了一个零字节的文件。例如，如果用户从 CAB 文件中拖动 buffy.txt 和 willow.txt，Init() 将在 TEMP 目录下使用这两个名字创建两个文件。这是为了预防，万一拖放目标要验证从 HDROP 读入的文件名，如果文件不存在，则目标有可能会拒绝放下。

接下来的方法是 DoDragDrop()：

  HRESULT DoDragDrop(DWORD dwOKEffects, DWORD* pdwEffect);

DoDragDrop() 接受 dwOKEffects 中的一组 DROPEFFECT_* 标志，这些标志表明了源所允许的那些动作。它会查询必要的接口，然后调用 DoDragDrop() API。如果拖放成功，*pdwEffect 就被设置为用户希望执行的 DROPEFFECT_* 值。

最后一个方法是 GetDragResults()：

  const vector<CDraggedFileInfo>& GetDragResults();

CDragDropSource 对象维护的 vector<CDraggedFileInfo> 会在拖放操作过程中被更新。如果某个文件被发现还连着另一个 CAB，或者是不能被提取，则 CDraggedFileInfo 结构会被执行必要的更新。主框架调用 GetDragResults() 来获取此向量，查找错误并相应更新 UI。

IDropSource 的方法

第一个 IDropSource 方法是 GiveFeedback()，它通知源，用户是想采取哪种操作（移动、复制或者链接）。如果愿意的话源可以改变光标。CDragDropSource 对操作保持了跟踪，并告诉 OLE 要使用缺省的拖放光标。

STDMETHODIMP CDragDropSource::GiveFeedback(DWORD dwEffect)
{
  m_dwLastEffect = dwEffect;
  return DRAGDROP_S_USEDEFAULTCURSORS;
}

另一个 IDropSource 方法是 QueryContinueDrag()。OLE 在用户把光标移来移去时调用此方法，并告诉源哪个鼠标键，以及键盘键，被按下了。下边是大多数 QueryContinueDrag() 的实现所采用的样板代码：

STDMETHODIMP CDragDropSource::QueryContinueDrag (
    BOOL fEscapePressed, DWORD grfKeyState )
{
  // If ESC was pressed, cancel the drag.
  // If the left button was released, do drop processing.
  if ( fEscapePressed )
    return DRAGDROP_S_CANCEL;
  else if ( !(grfKeyState & MK_LBUTTON) )
    {
    // If the last DROPEFFECT we got in GiveFeedback()
    // was DROPEFFECT_NONE, we abort because the allowable
    // effects of the source and target don't match up.
    if ( DROPEFFECT_NONE == m_dwLastEffect )
      return DRAGDROP_S_CANCEL;
 
    // TODO: Extract files from the CAB here...
 
    return DRAGDROP_S_DROP;
    }
  else
    return S_OK;
}

当我们发现左键被释放了，就到了我们要从 CAB 中提取选中的文件的地方了。

STDMETHODIMP CDragDropSource::QueryContinueDrag (
    BOOL fEscapePressed, DWORD grfKeyState )
{
  // If ESC was pressed, cancel the drag.
  // If the left button was released, do the drop.
  if ( fEscapePressed )
    return DRAGDROP_S_CANCEL;
  else if ( !(grfKeyState & MK_LBUTTON) )
    {
    // If the last DROPEFFECT we got in GiveFeedback()
    // was DROPEFFECT_NONE, we abort because the allowable
    // effects of the source and target don't match up.
    if ( DROPEFFECT_NONE == m_dwLastEffect )
      return DRAGDROP_S_CANCEL;
 
    // If the drop was accepted, do the extracting here,
    // so that when we return, the files are in the temp dir
    // and ready for Explorer to copy.
    if ( ExtractFilesFromCab() )
      return DRAGDROP_S_DROP;
    else
      return E_UNEXPECTED;
    }
  else
    return S_OK;
}

CDragDropSource::ExtractFilesFromCab() 是另一个复杂点的代码，它使用 CAB SDK 把文件提取到 TEMP 目录下，覆盖掉我们先前创建的零字节的文件。当 QueryContinueDrag() 返回 DRAGDROP_S_DROP 时，也即告诉了 OLE 完成此拖放操作。如果拖放目标是一个资源浏览器窗口，资源浏览器会把文件从 TEMP 目录复制到发生拖放的目录。

从查看器中拖放

我们已经看过了实现拖放操作逻辑的类，现在，我们来看一下我们的查看器应用是怎样使用这个类的。当主框架窗口接收到 LVN_BEGINDRAG 通知消息时，它会调用视图以获取选中文件的列表，而后设置 CDragDropSource 对象：

LRESULT CMainFrame::OnListBeginDrag(NMHDR* phdr)
{
vector<CDraggedFileInfo> vec;
CComObjectStack<CDragDropSource> dropsrc;
DWORD dwEffect = 0;
HRESULT hr;
 
  // Get a list of the files being dragged (minus files
  // that we can't extract from the current CAB).
  if ( !m_view.GetDraggedFileInfo(vec) )
    return 0;   // do nothing
 
  // Init the drag/drop data object.
  if ( !dropsrc.Init(m_sCurrentCabFilePath, vec) )
    return 0;   // do nothing
 
  // Start the drag/drop!
  hr = dropsrc.DoDragDrop(DROPEFFECT_COPY, &dwEffect);
 
  return 0;
}

第一个调用的是视图的 GetDraggedFileInfo() 方法，用以得到选中文件的列表。此方法返回一个 vector<CDraggedFileInfo>，我们要用它来初始化 CDragDropSource 对象。GetDraggedFileInfo() 在选定的文件都不能被提取的情况下（例如文件被分块存放在不同的 CAB 文件中）有可能失败。如果发生了这种情况，则 OnListBeginDrag() 也静静地失败，不做任何事情就返回。最后，我们调用 DoDragDrop() 来开始操作，并让 CDragDropSource 处理剩余的事情。

上面列出的步骤 6 提到了拖放结束后对 UI 的更新。因为有可能在 CAB 末尾的一个文件仅仅是部分存储于此 CAB 中，而剩余的则在后续的一个 CAB 里。（这在 Windows 9x 的安装文件里非常普遍，在那儿 CAB 需要能符合软盘的大小）当我们试图提取这样的一个文件时，CAB SDK 会告诉我们含有该文件剩余部分的 CAB 的名字。它还会在原始 CAB 所在的相同目录下寻找那个 CAB，如果存在的话则从中提取文件的剩余部分。

因为我们要在视图窗口中标示分块文件，所以 OnListBeginDrag() 会检查拖放的结果，看是否找到了分块文件：

LRESULT CMainFrame::OnListBeginDrag(NMHDR* phdr)
{
//...
  
  // Start the drag/drop!
  hr = dropsrc.DoDragDrop(DROPEFFECT_COPY, &dwEffect);
 
  if ( FAILED(hr) )
    ATLTRACE("DoDragDrop() failed, error: 0x%08X\n", hr);
  else
    {
    // If we found any files continued into other CABs, update the UI.
    const vector<CDraggedFileInfo>& vecResults = dropsrc.GetDragResults();
    vector<CDraggedFileInfo>::const_iterator it;
 
    for ( it = vecResults.begin(); it != vecResults.end(); it++ )
      {
      if ( it->bPartialFile )
        m_view.UpdateContinuedFile ( *it );
      }
    }
 
  return 0;
}

我们调用 GetDragResults() 来获取反映了拖放操作结果的更新过的 vector<CDraggedFileInfo>。如果结构中的 bPartialFile 成员为 true，则表示该文件仅部分存在于此 CAB 中。我们再调用视图方法 UpdateContinuedFile()，并将信息结构传递给它，因而它可以相应地文件列表视图中的项。下面就是当发现有后续 CAB 时，应用程序如何标示分块文件：

如果找不到后续的 CAB，应用会通过设置 LVIS_CUT 风格来标示该文件不可以被提取，所以图标看起来是虚的：

出于安全考虑，应用把提取出的文件留在了 TEMP 目录里，而不是在拖放操作结束后立刻清除它们。在 CDragDropSource::Init() 创建零字节的临时文件时，它同时也把文件名添加到了全局向量 g_vecsTempFiles 中。临时文件在主框架窗口关闭时才删除。

加入 MRU 列表

我们将要看到的另一个文档/视图风格的特性是最近使用文件列表。WTL 的 MRU 实现为一个模板类 CRecentDocumentListBase。如果你不需要覆盖 MRU 任何的缺省行为（当然缺省通常已经足够用了），你可以使用派生类 CRecentDocumentList。

CRecentDocumentListBase 模板具有以下参数：

template <class T, int t_cchItemLen = MAX_PATH,
          int t_nFirstID = ID_FILE_MRU_FIRST,
          int t_nLastID = ID_FILE_MRU_LAST> CRecentDocumentListBase

T: 特化 CRecentDocumentListBase 的派生类的名字。
t_cchItemLen: 以 TCHAR 为单位的存储在 MRU 项中的字符串长度。至少必须为 6。
t_nFirstID: 用于 MRU 项的 ID 范围的最小 ID。
t_nLastID: 用于 MRU 项的 ID 范围的最大 ID。此值必须大于 t_nFirstID。

要把 MRU 特性添加到我们的应用里，需要做以下几步：

在我们希望 MRU 菜单项出现的地方插入一个 ID 为 ID_FILE_MRU_FIRST 的菜单项。此项的文本当列表为空时会显示出来。
添加一个 ID 为 ATL_IDS_MRU_FILE 的字符串表项。此字符串用作 MRU 项被选中时的动态帮助。如果你使用 WTL AppWizard，则此字符串已经帮你创建好了。
添加一个 CRecentDocumentList 对象到 CMainFrame 中。
在 CMainFrame::Create() 里初始化该对象。
处理命令 ID 介于 ID_FILE_MRU_FIRST 和 ID_FILE_MRU_LAST 之间（含）的 WM_COMMAND 消息。
当打开一个 CAB 文件时更新 MRU 列表。
应用关闭时保存 MRU 列表。

记住，如果 ID_FILE_MRU_FIRST 和 ID_FILE_MRU_LAST 不适合你的应用的话，你还是可以更改 ID 范围的，只要生成 CRecentDocumentListBase 的一个新的特化版本就可以。

设置 MRU 对象

第一步就是添加一个菜单项，以标明 MRU 项应该处于什么位置。通常是在 File 菜单下，这也是我们的应用用到的。下面就是占位菜单项：

AppWizard 已经把 ATL_IDS_MRU_FILE 字符串添加到了字符串表里，我们将之改为读作“打开此 CAB 文件”。接下来，我们向 CMainFrame 中加入一个名为 m_mru 的 CRecentDocumentList 类型成员变量并在 OnCreate() 中初始化它：

#define APP_SETTINGS_KEY \
    _T("software\\Mike's Classy Software\\WTLCabView");
 
LRESULT CMainFrame::OnCreate ( LPCREATESTRUCT lpcs )
{
HWND hWndToolBar = CreateSimpleToolBarCtrl(...);
 
  CreateSimpleReBar ( ATL_SIMPLE_REBAR_NOBORDER_STYLE );
  AddSimpleReBarBand ( hWndToolBar );
 
  CreateSimpleStatusBar();
 
  m_hWndClient = m_view.Create ( m_hWnd, rcDefault );
  m_view.Init();
 
  // Init MRU list
CMenuHandle mainMenu = GetMenu();
CMenuHandle fileMenu = mainMenu.GetSubMenu(0);
 
  m_mru.SetMaxEntries(9);
  m_mru.SetMenuHandle ( fileMenu );
  m_mru.ReadFromRegistry ( APP_SETTINGS_KEY );
 
  // ...
}

前两个方法设置了我们想在维持的项的数目（缺省为 16）以及包含占位项的菜单句柄。ReadFromRegistry() 从注册表中把 MRU 列表读出。它接收我们传递给它的键名，并在其下创建一个新键来保存列表。当我们这里，键为 HKCU\Software\Mike's Classy Software\WTLCabView\Recent Document List。

加载文件列表之后，ReadFromRegistry() 调用另一个 CRecentDocumentList 方法，即 UpdateMenu()，该方法会找到占位菜单项病将之以实际的 MRU 项代替。

处理 MRU 命令并更新列表

当用户选择了某个 MRU 项时，主框架会收到一个 WM_COMMAND 消息，命令 ID 等于菜单项的 ID。我们可以在消息映射中用一个宏来处理这些命令：

  BEGIN_MSG_MAP(CMainFrame)
    COMMAND_RANGE_HANDLER_EX(
        ID_FILE_MRU_FIRST, ID_FILE_MRU_LAST, OnMRUMenuItem)
  END_MSG_MAP()

消息处理其从 MRU 对象处获取该项的全路径，然后调用 ViewCab() 以使应用显示该文件的内容。

void CMainFrame::OnMRUMenuItem (
  UINT uCode, int nID, HWND hwndCtrl )
{
CString sFile;
 
  if ( m_mru.GetFromList ( nID, sFile ) )
    ViewCab ( sFile, nID );
}

如上文提到的，我们要扩展 ViewCab() 以使之感知 MRU 对象，并在必要时更新文件列表。新的原型为：

  void ViewCab ( LPCTSTR szCabFilename, int nMRUID = 0 );

如果 nMRUID 为 0，则 ViewCab() 是被 OnFileOpen() 调用的，否则的话，则是用户选择了某个 MRU 菜单项，nMRUID 就是 OnMRUMenuItem() 接收到的命令 ID。下面是更新过的代码：

void CMainFrame::ViewCab ( LPCTSTR szCabFilename, int nMRUID )
{
  if ( EnumCabContents ( szCabFilename ) )
    {
    m_sCurrentCabFilePath = szCabFilename;
 
    // If this CAB file was already in the MRU list,
    // move it to the top of the list. Otherwise,
    // add it to the list.
    if ( 0 == nMRUID )
      m_mru.AddToList ( szCabFilename );
    else
      m_mru.MoveToTop ( nMRUID );
    }
  else
    {
    // We couldn't read the contents of this CAB file,
    // so remove it from the MRU list if it was in there.
    if ( 0 != nMRUID )
      m_mru.RemoveFromList ( nMRUID );
    }
}

当 EnumCabContents() 成功了，我们就根据 CAB 文件是如何被选中的以不同的方式更新 MRU。如果是通过 File-Open 选中的，我们就调用 AddToList() 来把文件名加入到 MRU 列表里；如果是通过 MRU 菜单项选中的，我们就用 MoveToTop() 把该项移动到列表的顶部。如果 EnumCabContents() 失败，我们就用 RemoveFromList() 把文件名从 MRU 列表中移除。所有这几个方法都会在内部调用 UpdateMenu()，因此 File 菜单会自动被更新。

保存 MRU 列表

在应用关闭时，我们把 MRU 列表保存回注册表中。这事简单，只需要一行：

  m_mru.WriteToRegistry ( APP_SETTINGS_KEY );

这行放到了 CMainFrame 对 WM_DESTROY 和 WM_ENDSESSION 的消息处理器里。

其他 UI Goodies

透明的拖动图像

Windows 2000 及以后有一个内建的 COM 对象，叫做拖放助手，其目的是在拖放操作中提供良好的透明拖动图像。拖动源通过 IDragSourceHelper 接口使用此对象。下面是我们加入到 OnListBeginDrag() 中的使用此助手对象的额外代码，用粗体标示：

LRESULT CMainFrame::OnListBeginDrag(NMHDR* phdr)
{
NMLISTVIEW* pnmlv = (NMLISTVIEW*) phdr;
CComPtr<IDragSourceHelper> pdsh;
vector<CDraggedFileInfo> vec;
CComObjectStack<CDragDropSource> dropsrc;
DWORD dwEffect = 0;
HRESULT hr;
 
  if ( !m_view.GetDraggedFileInfo(vec) )
    return 0;   // do nothing
 
  if ( !dropsrc.Init(m_sCurrentCabFilePath, vec) )
    return 0;   // do nothing
 
  // Create and init a drag source helper object
  // that will do the fancy drag image when the user drags
  // into Explorer (or another target that supports the
  // drag/drop helper interface).
  hr = pdsh.CoCreateInstance ( CLSID_DragDropHelper );
 
  if ( SUCCEEDED(hr) )
    {
    CComQIPtr<IDataObject> pdo;
 
    if ( pdo = dropsrc.GetUnknown() )
      pdsh->InitializeFromWindow ( m_view, &pnmlv->ptAction, pdo );
    }
 
  // Start the drag/drop!
  hr = dropsrc.DoDragDrop(DROPEFFECT_COPY, &dwEffect);
 
  // ...
}

我们从创建此拖放助手 COM 对象开始。如果成功，我们就调用 InitializeFromWindow() 并传递三个参数：拖动源的窗口 HWND，光标位置，和一个基于我们的 CDragDropSource 对象的 IDataObject 接口。拖放助手使用此接口保存其数据，而且，如果拖放目标也使用助手对象的话，此数据用来生成拖动图像。

要使 InitializeFromWindow() 可以工作，拖放源的窗口需要处理 DI_GETDRAGIMAGE 消息，而且在对该消息的效应里，要创建一个用作拖动图像的位图。对我们而言幸运的是，列表视图控件支持这一特性，因此我们仅需很少的工作就可以得到拖动图像。下面是拖动图像的样子：

如果我们使用一些别的不处理 DI_GETDRAGIMAGE 的窗口做我们的视图类，我们就要自己来创建拖动图像并调用 InitializeFromBitmap() 来把图像保存到拖放助手对象中。

透明的选择矩形

从 Windows XP 开始，列表视图控件可以显示一个透明的选择框。此特性缺省是关闭的，但通过给控件设置 LVS_EX_DOUBLEBUFFER 风格即可启用。我们的应用把这件事在 CWTLCabViewView::Init() 中作为视图窗口初始化工作的一部分来做。下面是成果：

如果没有显示出透明选择框，那就需要检查你的系统属性，确保下面的特性是启用了的：

标示排序的列

在 Windows XP 及之后，详细信息模式的列表视图控件有一个被选中的列，以不同的背景颜色显示。这一特性通常用来标示那一列是被排序了的，而这也正是我们的 CAB 查看器要做的。标头控件也有了两个新的格式风格，使得在一列中标头可以显示一个向上或者向下的箭头。这通常用来显示排序的方向。

视图类在 LVN_COLUMNCLICK 处理器中处理了排序。显示排序列的代码用粗体作了加亮：

LRESULT CWTLCabViewView::OnColumnClick ( NMHDR* phdr )
{
int nCol = ((NMLISTVIEW*) phdr)->iSubItem;
 
  // If the user clicked the column that is already sorted,
  // reverse the sort direction. Otherwise, go back to
  // ascending order.
  if ( nCol == m_nSortedCol )
    m_bSortAscending = !m_bSortAscending;
  else
    m_bSortAscending = true;
 
  if ( g_bXPOrLater )
    {
    HDITEM hdi = { HDI_FORMAT };
    CHeaderCtrl wndHdr = GetHeader();
 
    // Remove the sort arrow indicator from the
    // previously-sorted column.
    if ( -1 != m_nSortedCol )
      {
      wndHdr.GetItem ( m_nSortedCol, &hdi );
      hdi.fmt &= ~(HDF_SORTDOWN | HDF_SORTUP);
      wndHdr.SetItem ( m_nSortedCol, &hdi );
      }
 
    // Add the sort arrow to the new sorted column.
    hdi.mask = HDI_FORMAT;
    wndHdr.GetItem ( nCol, &hdi );
    hdi.fmt |= m_bSortAscending ? HDF_SORTUP : HDF_SORTDOWN;
    wndHdr.SetItem ( nCol, &hdi );
    }
 
  // Store the column being sorted, and do the sort
  m_nSortedCol = nCol;
 
  SortItems ( SortCallback, (LPARAM)(DWORD_PTR) this );
 
  // Indicate the sorted column.
  if ( g_bXPOrLater )
    SetSelectedColumn ( nCol );
 
  return 0;
}

加亮代码的第一小节去除了先前的排序列的排序箭头。如果没有排序的列的话，就省略这一步。然后，把箭头添加到用户刚刚点击的列上。如果以升序排序则箭头朝上，降序则朝下。排序结束后，我们调用 SetSelectedColumn() —— 对 LVM_SETSELECTEDCOLUMN 消息的一个封装 —— 来把选中列设置为我们刚刚排序的列。

以下是文件以大小排序后的列表控件的样子：

使用平铺视图模式

在 Windows XP 及之后，列表视图控件还有一种新的风格称为平铺视图模式。作为视图窗口初始化的一部分，如果应用是运行于 XP 或之后上，它就会使用 SetView() （对 LVM_SETVIEW 消息的一个封装）把列表视图的模式设置为平铺模式。然后再填充一个 LVTILEVIEWINFO 结构来设置一些控制如何平铺绘制的属性。cLines 属性被设为了 2，表示要在图标旁边显示两行附加文本。dwFlags 成员设置为了 LVTVIF_AUTOSIZE，这使得控件自身的大小改变时同时也改变平铺区域的大小。

void CWTLCabViewView::Init()
{
  // ...
 
  // On XP, set some additional properties of the list ctrl.
  if ( g_bXPOrLater )
    {
    // Turning on LVS_EX_DOUBLEBUFFER also enables the
    // transparent selection marquee.
    SetExtendedListViewStyle ( LVS_EX_DOUBLEBUFFER,
                               LVS_EX_DOUBLEBUFFER );
 
    // Default to tile view.
    SetView ( LV_VIEW_TILE );
 
    // Each tile will have 2 additional lines (3 lines total).
    LVTILEVIEWINFO lvtvi = { sizeof(LVTILEVIEWINFO),
                             LVTVIM_COLUMNS };
 
    lvtvi.cLines = 2;
    lvtvi.dwFlags = LVTVIF_AUTOSIZE;
    SetTileViewInfo ( &lvtvi );
    }
}

设置平铺视图的图像列表

在平铺视图模式下，我们会使用特大系统图形列表（在缺省的显示设置下图标为 48x48 大小）。我们使用 SHGetImageList() API 获取此图像列表。SHGetImageList() 不同于 SHGetFileInfo() 的是它返回一个基于图像列表对象的 COM 接口。视图窗口有两个成员变量用来管理此图像列表：

  CImageList m_imlTiles;         // the image list handle
  CComPtr<IImageList> m_TileIml; // COM interface on the image list

视图窗口在 InitImageLists() 中获取特大图像列表：

HRESULT (WINAPI* pfnGetImageList)(int, REFIID, void**);
HMODULE hmod = GetModuleHandle ( _T("shell32") );
 
  (FARPROC&) pfnGetImageList = GetProcAddress(hmod, "SHGetImageList");
 
  hr = pfnGetImageList ( SHIL_EXTRALARGE, IID_IImageList,
                         (void**) &m_TileIml );
 
  if ( SUCCEEDED(hr) )
    {
    // HIMAGELIST and IImageList* are interchangeable,
    // so this cast is OK.
    m_imlTiles = (HIMAGELIST)(IImageList*) m_TileIml;
    }

如果 SHGetImageList() 成功，我们可以把 IImageList* 接口转型为一个 HIMAGELIST，再像使用其它图像列表一样使用它。

使用平铺视图的图像列表

由于列表控件并不能为平铺视图模式持有单独的图像列表，所以我们需要在运行时，当用户选择大图标或者平铺视图模式时改变图像列表。视图类有一个 SetViewMode() 方法来处理改变图像列表和视图风格的事宜：

void CWTLCabViewView::SetViewMode ( int nMode )
{
  if ( g_bXPOrLater )
    {
    if ( LV_VIEW_TILE == nMode )
      SetImageList ( m_imlTiles, LVSIL_NORMAL );
    else
      SetImageList ( m_imlLarge, LVSIL_NORMAL );
 
    SetView ( nMode );
    }
  else
    {
    // omitted - no image list changing necessary on
    // pre-XP, just modify window styles
    }
}

如果控件即将进入平铺视图模式，那我们就把控件的图像列表设置为 48x48 的那个，否则设置为 32x32 的那个。

设置附加的文本行

在初始化时，我们将平铺效果设置为要显示附加的两行文本。第一行总是项的文字，就像在大图标和小图标模式里一样。显示在两行附加的文本里的文字取自于子项，类似于详细信息模式下的列。我们可以为每个图标设置单独的子项。下面就是在 AddFile() 中视图是怎样设置文本的：

  // Add a new list item.
int nIdx;
 
  nIdx = InsertItem ( GetItemCount(), szFilename, info.iIcon );
  SetItemText ( nIdx, 1, info.szTypeName );
  SetItemText ( nIdx, 2, szSize );
  SetItemText ( nIdx, 3, sDateTime );
  SetItemText ( nIdx, 4, sAttrs );
 
  // On XP+, set up the additional tile view text for the item.
  if ( g_bXPOrLater )
    {
    UINT aCols[] = { 1, 2 };
    LVTILEINFO lvti = { sizeof(LVTILEINFO), nIdx,
                        countof(aCols), aCols };
 
    SetTileInfo ( &lvti );
    }

aCols 数组保存有子项，其文本将会被显示出来，在这儿我们显示子项 1 （文件类型）以及 2 （文件大小）。下面是在平铺视图模式下查看器的样子：

注意，附加行当你在详细信息模式下排序某列之后会改变。当使用 LVM_SETSELECTEDCOLUMN 设置了选中列时，该子项的文字总是最先显示，覆盖了我们传递到 LVTILEINFO 结构中的子项设置。

Copyright and license

This article is copyrighted material, ©2006 by Michael Dunn. I realize this isn't going to stop people from copying it all around the 'net, but I have to say it anyway. If you are interested in doing a translation of this article, please email me to let me know. I don't foresee denying anyone permission to do a translation, I would just like to be aware of the translation so I can post a link to it here.

The demo code that accompanies this article is released to the public domain. I release it this way so that the code can benefit everyone. (I don't make the article itself public domain because having the article available only on CodeProject helps both my own visibility and the CodeProject site.) If you use the demo code in your own application, an email letting me know would be appreciated (just to satisfy my curiosity about whether folks are benefitting from my code) but is not required. Attribution in your own source code is also appreciated but not required.

修订历史

2006 年 6 月 16 日：首次发布