黄色欧美成人,日韩午夜在线电影,亚洲经典在线看

EvilGhost — Fri, 17 Jun 2011 12:01:00 GMT

AVLTree.h文�g

#ifndef AVL_TREE_H
#define AVL_TREE_H

#include 
#include 

#ifdef _PRINT
#include 
#include 
#include 
#include 
#endif // _PRINT

namespace ghost{

/// AVL�?
template
class AVLTree{
public:
    typedef ComparableT DataType;

private:
    /// 节点�Q�缓存了自��n的高�?
    struct Node_{
        DataType data;        // 可进行比较的数据
        Node_* pLeftChild;   // 指向左儿�?
        Node_* pRightChild;  // 指向叛_���?
        int height;           // 作�ؓ根节点的树高度，

        Node_()
            : pLeftChild(0)
            , pRightChild(0)
            , height(0) // �U�定叶子高度�?�Q�故节点高度初始化�ؓ0
        {

        }
        explicit Node_(const DataType& d)
            : data(d)
            , pLeftChild(0)
            , pRightChild(0)
            , height(0) // �U�定叶子高度�?�Q�故节点高度初始化�ؓ0
        {

        }

        Node_(const Node_&) = delete;
        Node_& operator =(const Node_&) = delete;
    };
    Node_* pRoot_;   // 指向根节�?

public:
    /// 默认初始化�ؓ�I�树
    AVLTree()
        : pRoot_(0)
    {
#ifdef _PRINT
        std::cout<<"创徏AVL�?< PSharedPrinter;         // 打印者共享指�?
    typedef std::vector PrinterContainer;   // 打印者共享指针的容器

    /// 节点打印�?
    class NodePrinter : public Printer{
        Node_* pNode_;
        size_t width_;
        PrinterContainer& nextPrinters_;

    public:
        NodePrinter(Node_* p, PrinterContainer& printers)
            : pNode_(p)
            , width_(0)
            , nextPrinters_(printers)
        {
            assert(pNode_);
            UpdateWidth();
        }
        virtual ~NodePrinter(){}
        NodePrinter(const NodePrinter&) = delete;
        NodePrinter& operator =(const NodePrinter&) = delete;

    public:
        void UpdateWidth()
        {
            width_ = CalcDataWidth_(pNode_->data);
        }

        virtual void Print() const
        {
            // 计算左右子树宽度
            size_t leftChildWidth = CalcWidth_(pNode_->pLeftChild);
            size_t rightChildWidth = CalcWidth_(pNode_->pRightChild);  // +1是�ؓ了将数据隔开

            // 打印左边�I�白
            for (size_t i = 0; i < leftChildWidth; ++i)
            {
                std::cout<<' ';
            }
            // 打印节点
            std::cout<<"["<data<<"]";
            // 打印双����I�白
            for (size_t i = 0; i < rightChildWidth; ++i)
            {
                std::cout<<' ';
            }

            // ���左儿子攑օ�下一层需要打印的节点集合�?
            if (pNode_->pLeftChild)
            {
                nextPrinters_.push_back(PSharedPrinter(new NodePrinter(pNode_->pLeftChild, nextPrinters_)));
            }
            // ���自�w�所占空位放入下一层需要打印的节点集合�?
            nextPrinters_.push_back(PSharedPrinter(new BlankPrinter(width_)));
             // ���右儿子攑օ�下一层需要打印的节点集合�?
            if (pNode_->pRightChild)
            {
                nextPrinters_.push_back(PSharedPrinter(new NodePrinter(pNode_->pRightChild, nextPrinters_)));
            }
            // ���自�w�所占空位放入下一层需要打印的节点集合�?
            nextPrinters_.push_back(PSharedPrinter(new BlankPrinter(width_)));
        }
        virtual bool IsValid() const{return true;}
    };

    /// �I�白打印者，主要完成打印父节�Ҏ��占用的空�?
    class BlankPrinter : public Printer{
        size_t count_;
    public:
        explicit BlankPrinter(size_t c) : count_(c){}
        virtual ~BlankPrinter(){}
    public:
        virtual void Print() const
        {
            for (size_t i = 0; i < count_; ++i)
            {
                std::cout<<' ';
            }
        }
    };

    /// �q�度优先打印节点�Q�目前只支持打印int型数�?
    void Print() const
    {
        std::cerr<<"不支持打印的数据�c�d���Q?<pLeftChild) + CalcWidth_(pRoot->pRightChild) + CalcDataWidth_(pRoot->data);
    }
#endif // _PRINT

public:
    /// 插入数据
    void Insert(const DataType& data)
    {
#ifdef _PRINT
        std::cout<<"插入数据�Q?<pLeftChild);
            RecursDestroyNode_(pNode->pRightChild);
            // 再销毁自�w?
            DestroyNode_(pNode);
        }
    }

    /// 获取树高度，�U�定�I�树高度�?1
    static int GetHeight_(const Node_* pRoot)
    {
        return pRoot ? pRoot->height : -1;
    }
    /**
    计算树高�?
    因�ؓ�U�定�I�树高度�?1�Q�叶子高度�ؓ0�Q�所以树高度�{�于左右子树较高者高�?1
    */
    static int CalcHeight_(const Node_* pRoot)
    {
        assert(pRoot);  // 断言树存�?
        return std::max(GetHeight_(pRoot->pLeftChild), GetHeight_(pRoot->pRightChild)) + 1;
    }

    /**
    与子树进行单旋�{
    �׃��旋�{后节点将成�ؓ其原儿子的儿子，故节�Ҏ��针pNode���会指向其原儿子
    pChild1指向被旋转的儿子成员指针�Q�pChild2指向另一个儿子成员指�?
    */
    static void SingleRatateWithChild_(Node_*& pNode, Node_* Node_::* pChild1, Node_* Node_::* pChild2)
    {
        assert(pChild1 && pChild2); // 断言成员变量指针有效

        assert(pNode);   // 断言节点存在

        // 节点的儿�?重定向于儿子1的儿�?
        Node_* pOriginalChild = pNode->*pChild1;
        pNode->*pChild1 = pOriginalChild->*pChild2;
        // 节点的原儿子1的儿�?重定向于节点
        pOriginalChild->*pChild2 = pNode;

        // 旋�{之后需要重新计���高�?
        pNode->height = CalcHeight_(pNode);
        pOriginalChild->height = CalcHeight_(pOriginalChild);

        // pNode指向其原儿子
        pNode = pOriginalChild;
    }

    /// 与左子树�q�行单旋�?
    static void RotateWithLeftChild_(Node_*& pNode)
    {
        SingleRatateWithChild_(pNode, &Node_::pLeftChild, &Node_::pRightChild);
    }

    /// 与右子树�q�行单旋�?
    static void RotateWithRightChild_(Node_*& pNode)
    {
        SingleRatateWithChild_(pNode, &Node_::pRightChild, &Node_::pLeftChild);
    }

    /**
    与子树进行双旋�{
    �׃��旋�{后节点将成�ؓ其原儿子的儿子，故节�Ҏ��针pNode���会指向其原儿子
    pChild1指向被旋转的儿子成员指针�Q�pChild2指向另一个儿子成员指�?
    */
    static void DoubleRatateWithChild_(Node_*& pNode, Node_* Node_::* pChild1, Node_* Node_::* pChild2)
    {
        assert(pChild1); // 断言成员变量指针有效

        // 先对儿子�q�行一�ơ旋�?
        SingleRatateWithChild_(pNode->*pChild1, pChild2, pChild1);
        // 再对自己�q�行一�ơ旋�?
        SingleRatateWithChild_(pNode, pChild1, pChild2);
    }

    /// 与左子树�q�行双旋�?
    static void DoubleRotateWithLeftChild_(Node_*& pNode)
    {
        DoubleRatateWithChild_(pNode, &Node_::pLeftChild, &Node_::pRightChild);
    }

    /// 与右子树�q�行双旋�?
    static void DoubleRotateWithRightChild_(Node_*& pNode)
    {
        DoubleRatateWithChild_(pNode, &Node_::pRightChild, &Node_::pLeftChild);
    }

    /**
    ���定左子树是否过高（破坏了AVL�q����条�g�Q�，是则与其�q�行旋�{
    当在左子树中插入新节点，或者在叛_��树中删除节点时���?
    */
    static void RatateWithLeftChildIfNeed_(Node_*& pNode)
    {
        // AVL�q����条�g为左叛_��树高度相差不���过1
        // 左子树比叛_��树高2�Q�需要通过旋�{来��之重新达到AVL�q����条�g
        if (2 == GetHeight_(pNode->pLeftChild) - GetHeight_(pNode->pRightChild))
        {
            if (GetHeight_(pNode->pLeftChild->pLeftChild) > GetHeight_(pNode->pLeftChild->pRightChild))
            {
                // 左子树的左子树高于左子树的右子树�Q�应当与左子树进行单旋�{
                RotateWithLeftChild_(pNode);
            }
            else
            {
                // 左子树的叛_��树高于左子树的左子树�Q�应当与左子树进行双旋�{
                DoubleRotateWithLeftChild_(pNode);
            }
        }
    }

    /**
    ���定叛_��树是否过高（破坏了AVL�q����条�g�Q�，是则与其�q�行旋�{
    当在叛_��树中插入新节点，或者在左子树中删除节点时���?
    */
    static void RatateWithRightChildIfNeed_(Node_*& pNode)
    {
        // AVL�q����条�g为左叛_��树高度相差不���过1
        // 叛_��树比左子树高2�Q�需要通过旋�{来��之重新达到AVL�q����条�g
        if (2 == GetHeight_(pNode->pRightChild) - GetHeight_(pNode->pLeftChild))
        {
            if (GetHeight_(pNode->pRightChild->pRightChild) > GetHeight_(pNode->pRightChild->pLeftChild))
            {
                // 叛_��树的叛_��树高于右子树的左子树�Q�应当与叛_��树进行单旋�{
                RotateWithRightChild_(pNode);
            }
            else
            {
                // 叛_��树的左子树高于右子树的右子树�Q�应当与叛_��树进行双旋�{
                DoubleRotateWithRightChild_(pNode);
            }
        }
    }

    /**
    插入新节点：
        如果当前节点为空则说明找��C��插入的位�|�，创徏新节点，�q�回插入成功
        如果数据���于当前节点数据则到左子树中插入�Q�如果插入成功，可能需要旋转��之重新��^衡（左子树过高）�Q�重新计���高�?
        如果数据大于当前节点数据则道叛_��树中插入�Q�如果插入成功，可能需要旋转��之重新��^衡（叛_��树过高）�Q�重新计���高�?
        如果数据�{�于当前节点数据则什么都不做�Q�返回插入失�?
    */
    static bool Insert_(const DataType& data, Node_*& pNode)
    {
        if (!pNode)
        {
            // 扑ֈ�位置�Q�创������?
            pNode = CreateNode_(data);
            assert(pNode); // 断言创徏节点成功
            return true;
        }
        else if (data < pNode->data)
        {
            // ���较���的数据插入到左子树
            if (Insert_(data, pNode->pLeftChild))
            {
                // 成功插入新节�?
                // 如果需要，则与左子树进行旋转以�l�持AVL�q����条�g
                RatateWithLeftChildIfNeed_(pNode);

                // 重新计算高度
                pNode->height = CalcHeight_(pNode);
                return true;
            }
        }
        else if (data > pNode->data)
        {
            // ���较大的数据插入到右子树
            if (Insert_(data, pNode->pRightChild))
            {
                // 成功插入新节�?
                // 如果需要，则与叛_��树进行旋转以�l�持AVL�q����条�g
                RatateWithRightChildIfNeed_(pNode);

                // 重新计算高度
                pNode->height = CalcHeight_(pNode);
                return true;
            }
        }
        else
        {
            // 重复数据�Q�什么也不做�Q�或者进行计敎ͼ�
        }
        return false;
    }

    /**
    删除节点
    查找被删除的节点�Q?
        如果当前节点为空则说明没有找到被删除的节点，�q�回删除��p�|
        如果被删除的数据���于节点数据�Q�则在节点的左子树中查找�q�删除，如果删除成功�Q�可能需要旋转��之重新��^衡（叛_��树过高）�Q�重新计���高�?
        如果被删除的数据大于节点数据�Q�则在节点的叛_��树中查找�q�删除，如果删除成功�Q�可能需要旋转��之重新��^衡（左子树过高）�Q�重新计���高�?
        如果被删除的数据�{�于节点数据�Q�则扑ֈ�被删除的节点�Q�开始删除，�q�回删除成功

    删除节点�q�程�Q�将被删除的节点作�ؓ标记节点�Q?
        如果标记节点存在左右双子树，利用叛_��树的最���节点的数据替换此节�Ҏ��据，然后删除叛_��树的最���节点：
            如果叛_��树有左子树，从左子树中找到最���节点，���其叛_��树提升一�U�，可能需要旋转��其父节点重新�q�����Q�其父节点的叛_��树过高）�Q�重新计���其父节炚w���?
            如果叛_��树没有左子树�Q�此时右子树则即是最���节点，���其叛_��树提升一�U?
        可能需要旋转��标记节点重新�q�����Q�标记节点的左子树过高）�Q�重新计���标记节炚w���?

        如果标记节点不存在左叛_��子树�Q�删除标记节点，提升其子�?
    */
    static bool Erase_(const DataType& data, Node_*& pNode)
    {
        if (!pNode)
        {
            // 没有扑ֈ�节点
            return false;
        }
        else if (data < pNode->data)
        {
            // 节点较小�Q�在左子树中删除
            if (Erase_(data, pNode->pLeftChild))
            {
                // 成功删除节点
                // 如果需要，则与叛_��树进行旋转以�l�持AVL�q����条�g
                RatateWithRightChildIfNeed_(pNode);

                // 重新计算高度
                pNode->height = CalcHeight_(pNode);
                return true;
            }
        }
        else if (data > pNode->data)
        {
            // 节点较大�Q�在叛_��树中删除
            if (Erase_(data, pNode->pRightChild))
            {
                // 成功删除节点
                // 如果需要，则与左子树进行旋转以�l�持AVL�q����条�g
                RatateWithLeftChildIfNeed_(pNode);

                // 重新计算高度
                pNode->height = CalcHeight_(pNode);
                return true;
            }
        }
        else
        {
            // 扑ֈ�了需要被删除的节�?
            if (pNode->pLeftChild && pNode->pRightChild)
            {
                // 存在双子树，利用叛_��树最���节�Ҏ��换，�q�删除右子树最���节�?
                Node_* pMin = pNode->pRightChild;
                if (pNode->pRightChild->pLeftChild)
                {
                    // 叛_��树存在左子树�Q�从叛_��树的左子树中找最���节�?
                    Node_* pMinParent = pNode->pRightChild;
                    while (pMinParent->pLeftChild->pLeftChild)
                    {
                        pMinParent = pMinParent->pLeftChild;
                    }
                    pMin = pMinParent->pLeftChild;

                    // 提升最���节点的叛_���?
                    pMinParent->pLeftChild = pMin->pRightChild;

                    // 如果需要，最���节点的父节点则与其叛_��树进行旋转以�l�持AVL�q����条�g
                    RatateWithRightChildIfNeed_(pMinParent);

                    // 重新计算最���节点的父节点的高度
                    pMinParent->height = CalcHeight_(pMinParent);
                }
                else
                {
                    // 叛_��树不存在左子树，那么提升叛_��树的叛_���?
                    pNode->pRightChild = pNode->pRightChild->pRightChild;
                }
                // 用最���节�Ҏ���?
                pNode->data = pMin->data;

                // 删除最���节�?
                DestroyNode_(pMin);

                // 如果需要，则与左子树进行旋转以�l�持AVL�q����条�g
                RatateWithLeftChildIfNeed_(pNode);

                // 重新计算高度
                pNode->height = CalcHeight_(pNode);
            }
            else
            {
                // 不存在双子树�Q�则直接用儿子替�?
                Node_* pTemp = pNode;
                pNode = pNode->pLeftChild ? pNode->pLeftChild : pNode->pRightChild;
                // 销毁节�?
                DestroyNode_(pTemp);
            }
            return true;
        }
        return false;
    }

}; // class AVLTree

#ifdef _PRINT
template<>
void AVLTree::Print() const
{
    if (!pRoot_)
    {
        return;
    }

    PrinterContainer nextPrinters; // 下一层需要打印的对象集合
    nextPrinters.push_back(PSharedPrinter(new NodePrinter(pRoot_, nextPrinters)));

    while (nextPrinters.end() != std::find_if(nextPrinters.begin(), nextPrinters.end(), std::mem_fn(&Printer::IsValid)))
    {
        auto printers(std::move(nextPrinters));  // 当前需要打印的对象集合
        // 打印一�?
        std::for_each(printers.begin(), printers.end(), std::mem_fn(&Printer::Print));
        // 换行
        std::cout<
size_t AVLTree::CalcDataWidth_(int n)
{
    if (0 == n)
    {
        return 1+2; // +2是�ؓ[]�W�号占位
    }
    size_t ret = 2; // 2是�ؓ[]�W�号占位
    if (0 > n)
    {
        // 复数�Q�添加符号位
        ++ret;
        n = -n;
    }
    while (n)
    {
        ++ret;
        n /= 10;
    }
    return ret;
}

#endif // _PRINT

} // namespace ghost

#endif // AVL_TREE_H

main.cpp文�g

#define _PRINT

#include "AVLTree.h"
#include 
#include 

/// 打印AVL�?
template
void PrintAVLTree(const ghost::AVLTree& tree)
{
#ifdef _PRINT
    std::cout<<"--------------AVLTree--------------"< tree;

    // 随机插入���试数据
    for (size_t i = 0; i < TEST_DATA_COUNT; ++i)
    {
        tree.Insert(BuildTestData());
        PrintAVLTree(tree);
    }

    // 随机删除���试数据
    for (size_t i = 0; i < TEST_DATA_COUNT; ++i)
    {
        tree.Erase(BuildTestData());
        PrintAVLTree(tree);
    }

//    tree.Insert(5);
//    PrintAVLTree(tree);
//
//    tree.Insert(2);
//    PrintAVLTree(tree);
//
//    tree.Insert(8);
//    PrintAVLTree(tree);
//
//    tree.Insert(1);
//    PrintAVLTree(tree);
//
//    tree.Insert(4);
//    PrintAVLTree(tree);
//
//    tree.Insert(7);
//    PrintAVLTree(tree);
//
//    tree.Insert(3);
//    PrintAVLTree(tree);
//
//    tree.Insert(6); // 此时应触发一�ơ单旋�{
//    PrintAVLTree(tree);
    return 0;
}

作�? Evil.Ghost 发表�?2011-06-17 14:53 原文链接

评论: 0　查看评论　发表评论

�~�辑推荐�Q?a target="_blank">像�h脑一��h��?揭秘Kinect工作原理

�|�站��D��Q?a target="_blank">博客园首��?/a> 我的园子新闻闪存 ��组博问知识�?/a>

文章来源:http://www.cnblogs.com/EvilGhost/archive/2011/06/17/AVLTree.html

EvilGhost 2011-06-17 20:01 发表评论

EvilGhost — Sun, 24 Apr 2011 02:48:00 GMT

�q�次我们��要�l�Widget增加一些状态，�q��其能够接受出消息处理扩展�Q�测试工�E�中实现了一个按钮的消息处理扩展�?/p>

Widget状态：

之前的控件只是绘制了一个边框，�q�且��L��会在�H�口中显�C�。实际上我们往往会希望能够让某个控�g昄��或者隐藏、可用或者不可用�{�等�Q�那么控件应该具有能够标识这些状态的属性，于是我们�l�Widget增加了状态概��c�?/p>

// 状态相�?/span>
void AddStates(size_t states);
void SubStates(size_t states);
bool CheckState(widget::StateBitField s);

上面是状态相关的几个接口�Q�包括了增加状态组�Q�减��状态组�Q�检��状态。这里有个状态组的概念，是因为我��状态用位域来实玎ͼ�那么他们��可以通过or�q�算来得到多个状态的集合�Q�我��p��个集合称为状态组�?/p>

enum StateBitField{
    STATE_VISIBLE         = 1 << 0, // 控�g可见�Q�决定控件是否被�l�制
    STATE_ENABLE          = 1 << 1, // 控�g可用�Q�决定控件是否响应鼠标键盘消�?/span>
    STATE_TRANSPARENT     = 1 << 2, // 控�g透明�Q�决定控件是否响应鼠标键盘消息以及是否显�C�tooltip
};

目前我给Widget定义�?个状态：可见、可用、透明。默认创建的Widget是不可见、不可用、不透明的，需要在创徏成功后手动设�|�，例如�Q?/p>

// 建立�Ҏ���?/span>
auto pRootWidget = ghost::Widget::Create();
pRootWidget->AddStates(
　　ghost::widget::STATE_VISIBLE|ghost::widget::STATE_ENABLE|ghost::widget::STATE_TRANSPARENT);

消息处理扩展�Q?/strong>

通常对于控�g来说�Q�没有消息处理就�{�于没有生命意义�Q�那么�ؓWidget��d��消息处理扩展��意味着使Widget�z��v来，�q�次我们��来完成�q�个��d��Q�期待Widget�z��v来的那激动�h心的一刅R��和以往��d��扩展支持一��P��为扩展编写一个抽象基�c�，在Widget的关联对象管理中��d��q�个扩展的关联处理，然后在Widget的SendMessage处理逻辑里增加对消息处理扩展的支持。那么我们的SendMessage实现��变成了�q�样�Q?/p>

int Widget::SendMessage(widget::Message message, void* param1/* = 0*/, void* param2/* = 0*/)
{
if (!CheckState(widget::STATE_ENABLE))
{
// 不响应鼠标键盘消�?/span>
if ((widget::MSG_MOUSE_FIRST <= message
&& widget::MSG_MOUSE_LAST >= message)
||(widget::MSG_KEY_FIRST <= message
&& widget::MSG_KEY_LAST >= message))
{
return widget::MSG_RESULT_NONE;
}
}
if (CheckState(widget::STATE_TRANSPARENT))
{
// 不响应鼠标键盘消息，不显�C�tooltip
if ((widget::MSG_MOUSE_FIRST <= message
&& widget::MSG_MOUSE_LAST >= message)
||(widget::MSG_KEY_FIRST <= message
&& widget::MSG_KEY_LAST >= message))
{
return widget::MSG_RESULT_NONE;
}
}

auto pRelatedObject = GetRelatedObject();
if (pRelatedObject)
{
auto pMessageHandle = pRelatedObject->GetMessageHandle();
if (pMessageHandle)
{
bool handled = false;
int res = pMessageHandle->OnMessage(this, message, param1, param2, handled);
if (handled)
{
return res;
}
}
}

switch (message)
{
#ifdef _DEBUG
case widget::MSG_DRAW:
{
HBRUSH hBrush = ::CreateSolidBrush(pImpl_->testFrameColor_);
::FrameRect((HDC)param1, &pImpl_->absoluteRect_, hBrush);
::DeleteObject(hBrush);
}
break;
#endif // _DEBUG
case widget::MSG_HIT_TEST:
if (::PtInRect(&pImpl_->absoluteRect_, *(const POINT*)param1))
{
return ~widget::MSG_RESULT_NONE;
}
break;
}
return widget::MSG_RESULT_NONE;
}

我多�ơ提��C��tooltip�Q�但是我们这�ơ�ƈ没有为Widget增加其支持，它将在后面被加入到Widget中来。可以看到这里处理有�Ҏ��息处理扩展的支持�Q�还有状态对于消息的影响。这里出��C��一个MSG_HIT_TEST�Q�这是一个新增的消息。这�ơ�ؓWidget��d��了很多的消息�Q�包括了鼠标、键盘等�Q�要��鼠标消息准��的发送给正确的控�Ӟ��那么点击��试是必不可��的�Q�这个MSG_HIT_TEST消息则是用于控�g处理点击��试的�?/p>
点击��试�Q?/strong>

当容器��生了鼠标事�g的时候，我们能够得到鼠标热点在容器中的坐标。前面我也多�ơ提刎ͼ�模拟控�g是容器中的某个区域，那么当鼠标热点位于某个控件所处的区域的时候，那么�q�个鼠标事�g我们��应当交��p��个控件进行处理（�q�是通常情况�Q�也有可能某个控件作为透明控�g�Q�不接受��M��点击��试�Q�。于是我们便通过点击��试�Q�HitTest�Q�这个访问接口来扑ֈ�应该处理鼠标事�g的控件。在扑ֈ�控�g之后�Q�我们还��坐标映��到了控件的相对坐标�p�，�q�样控�g��可以以自��n的相对位�|�来处理鼠标事�g了�?/p>
当然�Q�这�ơ的内容非常多，包括坐标映射、区域映��，捕获鼠标的控件、活动控件、焦�Ҏ��件等概念都未提到�Q�但在代码中�q�是能够看到�q�些概念的。如果一一介绍�Q�那文章��׃��非常冗长�Q�也会��Widget实现�q�展�~�慢�Q�因此我通常都会省略一些内容，�q�些内容也就只能通过代码阅读来得��C��?/p>
按钮�Q?/strong>

��Z��试我们�q�次实现的内容，我们�~�写了一个按钮的消息处理扩展。简单�v见，我们使其不��生命令、不�l�制文本�Q�仅仅只是展�C�对鼠标消息的处理和状态的变化而已�?/p>
�?img src="http://pic002.cnblogs.com/images/2011/95718/2011042410321772.png">

我们��原先测试代码中的中间那个控件关联了按钮的消息处理，那么它就�U�Cؓ了一个按钮控件了。我们可以将鼠标�U�d��它上面点�ȝ��看会发生什么�?/p>
下蝲��试工程代码 因�ؓ我一直都在��用VC10来编写Widget�Q�也用到了一些新的特性，所以子啊这�ơ的��试工程我生成了一份release下的�E�序�Q�没有VC10的�h臛_��能够看到其运行效果�?/p>
作�? Evil.Ghost 发表�?2011-04-24 10:48 原文链接
评论: 0　查看评论　发表评论
最新新闻：
· ��Z�h赴美上市�Q�无奈大杂烩挟资本对阵Facebook(2011-04-24 11:07)
· 位置隐私事�g�q�展�Q�Google 回应�Q�华��街日报质疑(2011-04-24 10:19)
· 消息�U�苹果正��试T-Mobile版iPhone(2011-04-24 10:04)
· 报告�U?020�q�全球云计算规模�?410亿美�?/a>(2011-04-24 10:03)
· 沃尔玛在��国加州��试在线商品配送服�?/a>(2011-04-24 09:40)
�~�辑推荐�Q?a target="_blank">南方都市报：�|�络正在改写我们的思维�Q?/a>
�|�站��D��Q?a target="_blank">博客园首��?/a> 我的园子新闻闪存 ��组博问知识�?/a>

EvilGhost 2011-04-24 10:48 发表评论

EvilGhost — Tue, 19 Apr 2011 12:06:00 GMT

模拟控�g已经��Z��雏�Ş�Q�是应该重构一下了�?/p>
新概念：

其实说是新概念也不尽�Ӟ��只是在这几步的实��C��可以发现�Q�这个模拟控件框架中有两个大的概念：容器和控件。我们一直一来都说的是容器窗口，但是其实�q�是个可以上升的概念。容器容�U�一个控件体�p�，也就是关联一个根控�g�Q�那么它��有点类��g��我们的根控�g了。但是容器由必须实现和具体窗口和控�g的交互，所以我们不能简单的��根控�g作�ؓ容器。�ƈ且对于某些特�D�的实现�Q�我们还可能需要对容器的某些功能加以扩展，所以我们这�ơ重构�ؓ容器抽象了一个基�c�，�q�实��C��一个窗口容器�?/p>

class Container : public Monopolistic{
using Monopolistic::pWidget_;
using Monopolistic::GetWidget;

public:
Container();
virtual ~Container();

public:
Widget* GetRootWidget() const{return GetWidget();}

public:
virtual bool IsValid() const = 0;

public:
virtual void Invalidate(const RECT& rect){} // 无效化容器矩形区�?/span>
virtual void Invalidate(HRGN hRgn){} // 无效化容器不规则区域
virtual void Invalidate(){} // 无效化整个容器区�?/span>
};

解耦：

到目前�ؓ止，我们的容器驱动和控�g之间��h��十分紧密的耦合关系�Q�生命周期耦合�Q�，�q�次重构打算��此解耦，使得我们的容器创建和控�g体系创徏互不相关�Q�仅仅通过一�ơ操作来使得他们兌��或者解除关联�?/p>

// 建立�H�口容器
ghost::widget::WindowContainer container;
container.AttachWindow(hWnd);

// 建立�Ҏ��?/span>
auto pRootWidget = ghost::Widget::Create();

// 兌��容器
pRootWidget->CreateRelationship(&container);

减少�c�：

�q�次�q�有一个大的变化就是将原先的一些概念融合成了新的概念：驱动、消息过滤、消息映��都融合��C��容器当中�Q�因��三个概念和具体容器关�pȝ��密，所以将他们�q�行融合以减��我们的�c�L��目�?/p>
收获�Q?/strong>

�q�次重构建立了容器这个概忉|��们是有一定收��L��Q�原先我们无法访问控件所兌��的容器，现在可以了。原先控件的容器实现不易扩展�Q�现在可以通过�l�承来扩展（例如layered�H�口�Q�，甚至可以为容器实现特有的�l�制机制�Q�例如��用opengl�Q�以后我们抽象了�l�制概念便可以看刎ͼ�目前�q�只能��用GDI�Q��?/p>
�q�次没有什么新的内�Ҏ��加，但重构还是有必要的，周期性重构利于我们对整个框架的管理，在重构过�E�中较容易发现和修改BUG�?/p>
下蝲��试工程源码
作�? Evil.Ghost 发表�?2011-04-19 20:06 原文链接
评论: 0　查看评论　发表评论
最新新闻：
· 满��|�炮轰分众哄抬广告�h�Q�江南春承诺��调�?/a>(2011-04-20 18:08)
· 周�`��：技术颠�?商业颠覆�?60颠覆了行�?/a>(2011-04-20 18:03)
· XJP�Q�网购冷静期恐成一�U�空�?/a>(2011-04-20 18:00)
· ��L��非：一�?两制三宣�?/a>(2011-04-20 17:24)
· 微��Y�Q�Chrome和Opera存在HTML5执行漏洞(2011-04-20 17:20)
�~�辑推荐�Q?a target="_blank">再谈“我是怎么招聘�E�序员的”
�|�站��D��Q?a target="_blank">博客园首��?/a>  我的园子   新闻   闪存   ��组   博问   知识�?/a>

EvilGhost 2011-04-19 20:06 发表评论

EvilGhost — Tue, 12 Apr 2011 13:17:00 GMT

可扩展：

要��得我们的控�g具备一定的可扩展性，那么必定会��生控件之外的对象作�ؓ扩展�Q��ƈ且这个对象对于控件来说是可插入可�U�除的。用于扩展的对象和控件之间应该具备一定的关系�Q�例如：1-1�Q?-n�Q�n-n�{�。我们将�q�样的对象关�p�L��象了出来�Q�称之�ؓ对象关系�?/p>
对象关系�Q?/strong>

一个对象可能允许单个对象对其进行关联，也可能允许多个对象对其进行关联，甚至可能卛_��许多个对象进行关联，但却�Ҏ��些类型的对象限制为只能单个的对其�q�行兌��。我们将�q�些对象抽象为：单对象关�p�，多对象关�p�，独占式对象关�p�（�q�是对多对象关系的一�U�扩展）�?/p>

class ObjectRelationship{
protected:
ObjectRelationship(){}

public:
virtual ~ObjectRelationship(){}

private:
ObjectRelationship(const ObjectRelationship&);
ObjectRelationship& operator =(const ObjectRelationship&);

public:
bool CreateRelationship(ObjectRelationship* pObject)
{
if (!DoCreateRelationship_(pObject))
{
return false;
}
RelationshipCreated_(pObject);
return true;
}
bool DestroyRelationship(ObjectRelationship* pObject)
{
if (!DoDestroyRelationship_(pObject))
{
return false;
}
RelationshipDestroyed_(pObject);
return true;
}

protected:
virtual bool DoCreateRelationship_(ObjectRelationship* /*pObject*/) = 0;
virtual bool DoDestroyRelationship_(ObjectRelationship* /*pObject*/) = 0;

protected:
virtual void RelationshipCreated_(ObjectRelationship* /*pObject*/){}
virtual void RelationshipDestroyed_(ObjectRelationship* /*pObject*/){}
};

�q�是对象关系基类�Q�接口只有两个：建立关系�Q�销毁关�p�R�?/p>
单对象关�p�，多对象关�p�都�z��于这个基�c�，而独占式对象关系是实现的两个帮助函数来辅助多对象关系。我们的Widget�z��于多对象关系�Q�它便具备了和多个对象徏立关�pȝ��能力�Q�我们将有不同的扩展兌��到Widget�Q�。�ؓ了便于管理和扩展�Q�我们将所有和Widget兌��的扩展放��C��个对象当中进行管理，Widget和扩展之间的关系建立和销毁都委托�q�个对象来进行�?/p>

class LayoutChildren;

typedef std::set<LayoutChildren*> LayoutChildrenSet;

class RelatedObject{
Widget* pWidget_; // 控�g

// 控�g所兌��的对�?/span>
LayoutChildrenSet layoutChildrens_; // 可以有多个布局��理��理不同的子控�g布局

private:
friend class Widget;
explicit RelatedObject(Widget* const pWidget);

public: // 获取兌��对象的接�?/span>
const LayoutChildrenSet& GetLayoutChildrens() const{return layoutChildrens_;}

private:
void RelationshipCreated_(ObjectRelationship* pObject);
void RelationshipDestroyed_(ObjectRelationship* pObject);
};

void Widget::RelationshipCreated_(ObjectRelationship* pObject)
{
GetRelatedObject()->RelationshipCreated_(pObject);
}
void Widget::RelationshipDestroyed_(ObjectRelationship* pObject)
{
GetRelatedObject()->RelationshipDestroyed_(pObject);
}

布局子控�Ӟ��

我们为Widgt��d��了一个布局子控件的接口�Q�当控�g自��n区域变化的时候会自动的调用这个接口，当然用户也可以随时调用此接口对子控�g�q�行布局。此接口负责��操作传递给扩展�Q�我们考虑到子控�g的布局�{�略可能会各有不同，因此我们能够兌��多个布局子控件扩展到Widget�Q�这使得我们能够以不同的布局�{�略来区别对待不同的子控件�?/p>

void Widget::LayoutChildren()
{
auto pRelatedObject = GetRelatedObject();
if (pRelatedObject)
{
const widget::LayoutChildrenSet& layoutChildrens = pRelatedObject->GetLayoutChildrens();
std::for_each(
layoutChildrens.begin(), layoutChildrens.end(),
std::bind(std::mem_fn(&widget::LayoutChildren::Layout), std::placeholders::_1, this));
}
}

我们创徏了一个边�~�式布局自控件扩展进行测试，��试效果在测试工�E�中能够看到�?/p>
下蝲��试工程源码
作�? Evil.Ghost 发表�?2011-04-12 21:17 原文链接
评论: 0　查看评论　发表评论
最新新闻：
· 消息�U�iPad 3仍不采用Retina屏幕(2011-04-12 20:29)
· nginx 1.0.0发布(2011-04-12 20:27)
· 2011Mozilla开发者大会亮�Ҏ��先看(2011-04-12 20:24)
· 亚马逊成��h��W�一大广告主每年2亿美元（图）(2011-04-12 20:16)
· 九城OpenFeint中国首秀�Q�与联通推手游(2011-04-12 20:13)
�~�辑推荐�Q?a target="_blank">体验Managed Extensibility Framework�_�֦�的设�?/a>
�|�站��D��Q?a target="_blank">博客园首��?/a>  我的园子   新闻   闪存   ��组   博问   知识�?/a>

EvilGhost 2011-04-12 21:17 发表评论

EvilGhost — Sat, 09 Apr 2011 11:05:00 GMT

控�g�?/strong>

一步一步实现自��q��模拟控�g�Q?�Q?/a>中的图上我们可以看到�Q�我们的控�g体系其实��是一个控件树。每一个窗口关联一个根控�g�Q�所有控仉��在这个根控�g之下�Q�父控�g包容�q�管理子控�g�Q�那么我们的Widget��应该是一个树�l�点。一个树�l�点臛_��有对Parent和Chilren的设�|�和讉K��接口�Q?/p>

void SetParent(Widget* const pNewParent);
Widget* GetParent() const;

bool InsertChild(Widget* const pChild);
bool RemoveChild(Widget* const pChild);

在父控�g销毁的时候它要负责销毁其下所有的子控�Ӟ��c�M��H�口销毁也会销毁其子窗口）�Q?/p>

Widget::~Widget()
{
// 销毁所有子控�g
WidgetSet temp(std::move(pImpl_->children_));
std::for_each(temp.begin(), temp.end(), std::mem_fn(&Widget::Destroy));

if (IsRoot())
{
// 作�ؓ�Ҏ��Ӟ��同时销毁驱�?/span>
delete pImpl_->pDriver_;
}
else
{
// 不是�Ҏ��Ӟ��则脱��ȝ��控�g
SetParent(0);
}

delete pImpl_;
}

实现中我们��用std::set来保存子控�g�Q�这样便于防止子控�g重复讄��Q�也便于�U�除子控�Ӟ��~�点��是不能对子控�g�q�行排序。如果以后我们提供控件的z-order概念�Q�那么我们就会��用能够进行排序的容器来容�U�_��控�g�?/p>
控�g区域�Q?/strong>

windows下，我们使用RECT�l�构来保存控件自�w�相对于�H�口客户区的区域�Q�那么窗口客户区��寸改变时也��是我们控�g�q�行布局的时机，那我们就要在消息�q��o中处理WM_SIZE消息了�?/p>

case WM_SIZE: // 让根控�g适应真个客户�?/span>
{
RECT clientRect;
::GetClientRect(param.hWnd, &clientRect);
pRootWidget->SetAbsoluteRect(clientRect, false);
}
break;

我们��控件的布局交由父控件管理，也就是说我们只需要更新根控�g区域便可。根控�g负责对其子控件进行布局�Q�如此递归�?/p>
控�g更新�Q?/strong>

当控件区域改变了�Q�那么相应的其显�C�Z��应相应的�q�行更新�Q�所以我们的SetAbsoluteRect接口有一个update参数用于控制是否让窗口��生无效区域激�zȝ��制�?/p>

// 此处的update作用是控制是否立��x��新显�C��?br>// 因�ؓ模拟控�g只是�H�口客户区的一个区域，当区域改变时应该产生原区域和新区域or�q�算后区域的脏矩�?br>// 以��得窗口去重绘�q�部分区域�?br>// 可能有些扚w��性质的操作会在操作多个控件后�q�行整体更新�Q�所以在对单个控件设�|�新区域的时候可能不会想要更新�?br>// 所以才加上�q�个是否立即更新的开兟�?/span>
void SetAbsoluteRect(const RECT& rect, bool update = true);

既然提到了绘�Ӟ��那么我们也应该让我们的控件展�C�在�H�口上了�?/p>
控�g�l�制�Q?/strong>

通常我们的窗口程序都是在WM_PAINT消息中进行绘�Ӟ��我们的控件系�l�当然也需要处理此消息�?/p>

case WM_PAINT:
{
// 使用内存DC来缓冲绘�?br> // 目前没有计算脏矩形区�?/span>
wnd_msg_assistant::OnPaint opAssistant(param.hWnd);
pRootWidget->Draw(opAssistant.GetMemDC());
}
return S_OK;

�q�里引入了一个辅助对象帮助我们��生内存DC�Q�优化我们的�l�制效率。我们直接return了这个消息，也就是说我们��这个消息过滤掉了。前面WM_SIZE和WM_DESTROY我们都没有过滤，只是在这个时机对控�g�q�行了通知或者操作。之所以要�q��oWM_PAINT消息是因为外部的�l�制和控件的�l�制难以协调�Q�那么我们干脆就接管了窗口客户区的绘制了�?/p>
当然�Q�控件也需要负责绘制其子控�Ӟ��那么Draw接口中便会调用子控�g的Draw�Q�如此递归使得每个控�g都能够得以绘制�?/p>
首次直观的看到我们的控�g�Q?/strong>

我们在调试版本中�Q��ؓ每个控�g生成了一个随机的颜色�Q�根据控件的区域�l�制了其�Ҏ��Q�这��h��们就�W�一�ơ直观的在窗口中看到了我们的控�g�?/p>
�?img src="http://pic002.cnblogs.com/images/2011/95718/2011040918550120.png">

�q�不及待�Q�具有了区域的控�Ӟ��我们已经急切的想要对其布局�q�行控制�Q�绘制进行定制了。布局控制和绘制定制当然属于扩展部分，那么下面��将要引入我们的扩展体系了，��请期待�?/p>
下蝲��试工程源码
作�? Evil.Ghost 发表�?2011-04-09 19:05 原文链接
评论: 0　查看评论　发表评论
最新新闻：
· �Ҏ��iPad 2通过3C认证最�?月国内上�?/a>(2011-04-10 09:18)
· 盲目依赖iPhone�{�工具导�?英国驴友�q��\�?/a>(2011-04-10 09:14)
· ��谈�Q�想担�QCEO的话�Q�最好是去苹果工作，其次是微软，再才是Google(2011-04-10 08:26)
· 腾讯��徏立新数据中心�Q�规模�ؓ�Ҏ��的两�?/a>(2011-04-10 08:25)
· 轻量化的微型博客Tumblr(2011-04-10 08:03)
�~�辑推荐�Q?a target="_blank">非战之罪�Q�从�怸�Office谈�v
�|�站��D��Q?a target="_blank">博客园首��?/a>  我的园子   新闻   闪存   ��组   博问   知识�?/a>

EvilGhost 2011-04-09 19:05 发表评论

一步一步实现自��q��模拟控�g�Q?�Q�——隐藏类

EvilGhost — Thu, 07 Apr 2011 12:55:00 GMT

隐藏驱动�c�：

��Z��让用��h��更简单的使用接口�Q�我们需要把不必要的东西�q�行一定的隐藏。前面我��提到WidgetDriver对于用户来说是不兛_��的东西，那么我们��将其进行隐藏�?/p>
　　�Ҏ��1�Q?/strong>

　　��WidgetDriver攑ֈ�Widget.cpp中，�q�样的隐藏方式是最严密的，对于用户来说完全看不到WidgetDriver。但是随着我们的实现膨胀�Q�这会让我们的Widget.cpp变得非常臃肿�?/p>
　　�Ҏ��2�Q?/strong>

　　不改变文件结构，��WidgetDriver�U�有化，通过友元声明使得只有Widget�c�d��象能够访问WidgetDriver。这��L��戯��然能够看到WidgetDriver�q�个�c�d��义，但是却无法��用，�q�样对于代码的结构组�l�也更有利�?/p>
我采用了�Ҏ��2

class Driver_{
friend class Widget;

DriverImpl_* pImpl_;

private:
explicit Driver_(HWND hWnd);
~Driver_();
Driver_(const Driver_&);
Driver_& operator =(const Driver_&);

private:
void SetRootWidget(Widget* pRootWidget);
HWND GetContainerWindow() const;
Widget* GetRootWidget() const;
};

因�ؓ我们隐藏了WidgetDriver�Q�那么它的职能就能够�q�行��化。前面提到的�Ҏ��件和WidgetDriver之间的关�p�L��们就能够改�ؓ当方面控制了。于是我��WidgetDriver攑ֈ�了根控�g中进行管理，我们只需要操作根控�g便可�?/p>

Widget::Widget(HWND hWnd)
: pImpl_(new WidgetImpl)
{
pImpl_->pDriver = new widget::Driver_(hWnd);
pImpl_->pDriver->SetRootWidget(this);
}

Widget::~Widget()
{
if (IsRoot())
{
delete pImpl_->pDriver;
}
delete pImpl_;
}

前面我们都没有提到应该何时结束我们的�pȝ��Q�但是我们的�pȝ��生命周期和窗口是息息相关的，在窗口销毁的时候那么和�q�个�H�口相关联的控�g体系��应该销毁。于是我们对消息�q��o器做了一点点改动�Q?/p>

LRESULT MessageFilter::Filter(const Param& param, Widget* pRootWidget)
{
assert(param.originalProc);
assert(pRootWidget);
#ifdef _DEBUG
std::stringstream ss;
ss<<"�H�口消息: "<<std::showbase<<std::hex<<param.message<<" �q�入Widget消息�q��o�Q�\r\n";
::OutputDebugStringA(ss.str().c_str());
#endif // _DEBUG

LRESULT ret = ::CallWindowProc(
param.originalProc,
param.hWnd,
param.message,
param.wParam,
param.lParam);

if (WM_DESTROY == param.message)
{
// 销毁根控�g
pRootWidget->Destroy();
}

return ret;
}

我们在接收到WM_DESTROY�H�口消息的时候销毁根控�g�Q�根控�g析构的时候又会销毁控仉��动，控�g驱动析构的时候会解除和窗口的兌��?p>

下一步我们便要开始对我们的控件进行设计了�Q�我们自始至�l�都��控件抽象�ؓ�H�口客户区的一个区域，所以说我们�q�不打算使用�l�承来扩展控件。后面会看到我们使用插入式的扩展�Q�这��L��方式具备动态替换的能力甚至�q�能��一个扩展共享给多个控�g使用�?/p>
下蝲��试工程源码
作�? Evil.Ghost 发表�?2011-04-07 20:55 原文链接
评论: 0　查看评论　发表评论
最新新闻：
· �Ҏ��iPad 2通过3C认证最�?月国内上�?/a>(2011-04-10 09:18)
· 盲目依赖iPhone�{�工具导�?英国驴友�q��\�?/a>(2011-04-10 09:14)
· ��谈�Q�想担�QCEO的话�Q�最好是去苹果工作，其次是微软，再才是Google(2011-04-10 08:26)
· 腾讯��徏立新数据中心�Q�规模�ؓ�Ҏ��的两�?/a>(2011-04-10 08:25)
· 轻量化的微型博客Tumblr(2011-04-10 08:03)
�~�辑推荐�Q?a target="_blank">非战之罪�Q�从�怸�Office谈�v
�|�站��D��Q?a target="_blank">博客园首��?/a>  我的园子   新闻   闪存   ��组   博问   知识�?/a>

EvilGhost 2011-04-07 20:55 发表评论

一步一步实现自��q��模拟控�g�Q?�Q�——根控�g

EvilGhost — Wed, 06 Apr 2011 13:21:00 GMT

�H�口、控仉��动、根控�g之间的关�p?/strong>

前面我们已经说了�Q�一个窗口只能关联一个控仉��动，一个控仉��动也同样对应一个根控�g。�ؓ什么呢�Q�因为我们的驱动需要作用于一个控件体�p�，一个控件体�p�d��有一个根控�g�Q�这个根控�g��理了整个窗口的客户区。这��h��们才能在�q�个�Ҏ��件下创徏��L��的控�Ӟ��q�活动在�H�口客户区�?/p>
生命周期控制

��Z��上面的关�p�，控�g驱动和根控�g的生命息息相养I��那么我们让其�怺�制约。既然是他们自��n�怺�制约�Q�那么用户就不应该管理其生命周期�Q�我们特意引入一个简单的对象池来��理�Q��ƈ用访问控制来避免外部直接构造�?/p>

private:
explicit Widget(widget::Driver* pDriver);
~Widget();
Widget(const Widget&);
Widget& operator =(const Widget&);

// 让对象池能够创徏Widget对象
friend class ObjectPool<Widget>;
#pragma warning(push)
#pragma warning(disable:4396)
friend void std::_Destroy(Widget _FARQ *);
#pragma warning(pop)

public:
static Widget* Create(HWND hWnd); // 创徏�Ҏ��?/span>
void Destroy();

我们提供了一个静态接口Create用于创徏�Ҏ��Ӟ��可以注意到的一�Ҏ��参数是窗口句柄。其实用户对于什么驱动、什么过滤的都不兛_��Q�用户只兛_��控�g体系�Q�所以说我们可以通过�q�个接口透明的创建根�l��g�Q�实��C��会自动的去驱动此�H�口�?/p>

Widget* Widget::Create(HWND hWnd)
{
return GetWidgetPool_().Construct(widget::Driver::Create(hWnd));
}

驱动构造时会创建根控�g�Q�析构时销毁根控�g

Driver::Driver(HWND hWnd)
: pImpl_(new DriverImpl(hWnd))
{
// 创徏�Ҏ��?/span>
pImpl_->SetRootWidget(Widget::Create_(this));
}

~DriverImpl()
{
// 销毁根控�g
Widget* pOldRootWidget = GetRootWidget();
pRootWidget_ = 0;
if (pOldRootWidget)
{
pOldRootWidget->Destroy();
}
}

同样�Q�根控�g析构时也销毁控仉��?/p>

Widget::~Widget()
{
if (IsRoot())
{
pImpl_->GetDriver()->Destroy();
}
delete pImpl_;
}

�q�样�Q�用户其实有两个入口可以�q�入到我们的控�g�pȝ��Q�一个是通过控�g驱动�Q�一个是通过控�g本��n。我们提倡用户不��d��心控仉��动。那么甚��x��们可以隐藏Driver�q�个�c�，目前我没有这样做�?/p>
下蝲��试工程源码

作�? Evil.Ghost 发表�?2011-04-06 21:21 原文链接
评论: 0　查看评论　发表评论
最新新闻：
· �Ҏ��iPad 2通过3C认证最�?月国内上�?/a>(2011-04-10 09:18)
· 盲目依赖iPhone�{�工具导�?英国驴友�q��\�?/a>(2011-04-10 09:14)
· ��谈�Q�想担�QCEO的话�Q�最好是去苹果工作，其次是微软，再才是Google(2011-04-10 08:26)
· 腾讯��徏立新数据中心�Q�规模�ؓ�Ҏ��的两�?/a>(2011-04-10 08:25)
· 轻量化的微型博客Tumblr(2011-04-10 08:03)
�~�辑推荐�Q?a target="_blank">非战之罪�Q�从�怸�Office谈�v
�|�站��D��Q?a target="_blank">博客园首��?/a>  我的园子   新闻   闪存   ��组   博问   知识�?/a>

EvilGhost 2011-04-06 21:21 发表评论

一步一步实现自��q��模拟控�g�Q?�Q�——Widget驱动

EvilGhost — Sun, 03 Apr 2011 05:56:00 GMT

前面我们利用现有的微软ATL实现的thunk已经为我们截��L��口消息做好了准备�Q�此��L��们应该编写我们的Widget驱动的初步实��C��?/p>
利用thunk对窗口消息过�E�进行子�c�d��Q�那么窗口消息就会先��入到我们的Widget驱动对象�Q�Widget驱动对象负责��消息传递给消息�q��o器。现在我们的消息�q��o器还未实玎ͼ�于是我们打印了进入消息过滤器的消息ID��g��观察消息的流动情��c�?/p>
以下是我们的Widget驱动�c�，我们��其攑օ�了一个名为widget的名字空间中�Q�以后我们widget相关的名字都会放入到�q�个名字�I�间中�?/p>

class DriverImpl;

class Driver{
DriverImpl* pImpl_;

public:
explicit Driver(HWND hWnd);
~Driver();

private:
Driver(const Driver&);
Driver& operator =(const Driver&);

public:
inline HWND GetContainerWindow() const;
};

因�ؓDriver的实现我们�ƈ不关心，所以我们将其实现进行了一个隐藏，�q�样也便于我们修改其实现方式。Driver�c�d��象要求用于构造它的窗口句柄必��Mؓ有效的窗口句柄，�q�且每个�H�口句柄只能被驱动一�ơ，所以我们在调试版本中做了断�a�来约束我们的�~�码�Q�在发布版本中不会做��M��判断�?/p>

#ifdef _DEBUG
assert(::IsWindow(hContainerWnd_));
// 不能多次驱动同一�H�口
assert(GetContainerWindows_().insert(hContainerWnd_).second);
#endif // _DEBUG

此处有一�?span style="color: #ff0000;">GetContainerWindows_()是一个只在调试版本中才有的实玎ͼ�其返回一个std::set&静态对象引用，用于保存已经被驱动的�H�口句柄�Q�我们断�a��H�口句柄未曾保存到这个set之中�?/span>
现在我们实现的Driver接口非常��单，只有一个构造接口和查询光��动的�H�口句柄的接口，昄��没有��M��可以控制驱动或者解除驱动的��Z��Q�此处我们先放一放，因�ؓ�q�在以后会涉及到�q�个驱动所兌��的Widget体系的一些问题�?/p>
通过thunk截获的窗口消息将会进入到Driver实现中，Driver的功能仅仅是作�ؓWidget的驱动（也就是消息驱动）�Q�它不负责�Q何消息的处理�Q�所以这个窗口过�E�在截获到窗口消息后立即交由消息�q��o处理�?/p>

LRESULT WndProc_(UINT message, WPARAM wParam, LPARAM lParam)
{
// �q�行消息�q��o
MessageFilter::Param param;
param.hWnd = hContainerWnd_;
param.originalProc = originalProc_;
param.message = message;
param.wParam = wParam;
param.lParam = lParam;
return MessageFilter::Filter(param);
}

�q�里消息�q��o器的实现不在�q�一�D�讨��Z��中，所以我们简单的以一个类静态接口来作�ؓ�q��o入口�?/p>
好了�Q�我们到�q�里已经开启了Widget内核的运作系�l�的实现�Q�从��试工程中感受得��C��定的体验了�?/p>
下蝲��试工程源码
作�? Evil.Ghost 发表�?2011-04-03 13:56 原文链接
评论: 0　查看评论　发表评论
最新新闻：
· �Ҏ��iPad 2通过3C认证最�?月国内上�?/a>(2011-04-10 09:18)
· 盲目依赖iPhone�{�工具导�?英国驴友�q��\�?/a>(2011-04-10 09:14)
· ��谈�Q�想担�QCEO的话�Q�最好是去苹果工作，其次是微软，再才是Google(2011-04-10 08:26)
· 腾讯��徏立新数据中心�Q�规模�ؓ�Ҏ��的两�?/a>(2011-04-10 08:25)
· 轻量化的微型博客Tumblr(2011-04-10 08:03)
�~�辑推荐�Q?a target="_blank">非战之罪�Q�从�怸�Office谈�v
�|�站��D��Q?a target="_blank">博客园首��?/a>  我的园子   新闻   闪存   ��组   博问   知识�?/a>

EvilGhost 2011-04-03 13:56 发表评论

一步一步实现自��q��模拟控�g�Q?�Q�——窗口过�E�thunk

EvilGhost — Sun, 03 Apr 2011 05:55:00 GMT

实现Window Proc Thunk�Q?/strong>

��好像水泵一��P��我们的系�l�也需要一个�܇——消息�܇�Q�也��是前面图上的Message Driver。这个Driver的可以依靠一个Window Proc Thunk来截��L��口消息，那么我们得先实现一个Window Proc Thunk�?/p>
�q�里我选择的方法是拿现成的代码来用�Q�微软ATL框架中提供有thunk的实玎ͼ�我将其提取出来稍加修改就能�ؓ我们所用了�?/p>
以下是其实现的一点代码片�D�：

void* __stdcall AllocStdCallThunk(void);
void __stdcall FreeStdCallThunk(void*);

#pragma pack(push, 1)
class StdCallThunk_{
DWORD mov_; // mov dword ptr [esp+0x4], this_ (esp+0x4��是�W�一个参�?
DWORD this_; //
BYTE jmp_; // jmp proc
DWORD relproc_; // relative jmp

public:
bool Init(DWORD_PTR proc, void* pThis)
{
mov_ = 0x042444C7; //C7 44 24 0C
this_ = PtrToUlong(pThis);
jmp_ = 0xe9;
relproc_ = DWORD((INT_PTR)proc - ((INT_PTR)this+sizeof(StdCallThunk_)));
// 用自�w�更新指令缓�?/span>
return ::FlushInstructionCache(::GetCurrentProcess(), this, sizeof(StdCallThunk_)) ? true : false;
}
// 某些thunk��动态的��Z��码分配内�?/span>
void* GetCodeAddress()
{
return this;
}
void* operator new(size_t)
{
return AllocStdCallThunk();
}
void operator delete(void* pThunk)
{
FreeStdCallThunk(pThunk);
}
};
#pragma pack(pop)

下蝲��试工程源码
作�? Evil.Ghost 发表�?2011-04-03 13:55 原文链接
评论: 0　查看评论　发表评论
最新新闻：
· �Ҏ��iPad 2通过3C认证最�?月国内上�?/a>(2011-04-10 09:18)
· 盲目依赖iPhone�{�工具导�?英国驴友�q��\�?/a>(2011-04-10 09:14)
· ��谈�Q�想担�QCEO的话�Q�最好是去苹果工作，其次是微软，再才是Google(2011-04-10 08:26)
· 腾讯��徏立新数据中心�Q�规模�ؓ�Ҏ��的两�?/a>(2011-04-10 08:25)
· 轻量化的微型博客Tumblr(2011-04-10 08:03)
�~�辑推荐�Q?a target="_blank">非战之罪�Q�从�怸�Office谈�v
�|�站��D��Q?a target="_blank">博客园首��?/a>  我的园子   新闻   闪存   ��组   博问   知识�?/a>

EvilGhost 2011-04-03 13:55 发表评论

EvilGhost — Sun, 03 Apr 2011 05:53:00 GMT

目标�Q?/strong>

实现一套windows下简单且可扩展的抽象模拟控�g内核�?/p>
抽象模拟控�g�Q?/strong>

我们��windows�pȝ��的窗口客户区作�ؓ模拟控�g的容器，每个模拟控�g��是其中的一个抽象矩形区域，�q�且能够模拟控�g�q�行递归嵌套。控件支持基本的鼠标和键盘消息，能够在窗口大��改变时�q�行布局�?/p>
分析�Q?/strong>

因�ؓ我们要实现的是抽象的模拟控�g�Q�不是真正的�H�口控�g�Q�那么就需要将�H�口消息适时�z�֏�到相应控件。下面以一个图来规划窗口消息的��向�?/p>

在这个图上我们可以看到除了我们的控�g体系以外�q�需要实现几个核心模块来驱动控�g。他们分别是�Q�消息驱动、消息过滤、消息�{换。消息驱动通过某种�Ҏ��截获�H�口消息�Q�图上��用thunk�Q�，然后��窗口消息交�l�过滤器�q�行�q��o�Q�因为模拟控件不是所有窗口消息都感兴��）�Q�消息过滤出控�g感兴��的消息交给消息转换器，其他消息交还�l�窗口的原有�H�口�q�程�q�行处理�Q?strong>此处要注意的是消息过滤后控�g感兴��的消息不会再回到原�H�口�q�程�Q�。消息�{换器��窗口消息�{换�ؓ控�g消息�Q�之所以要�q�行转换是因为控件体�p�d��能支持的消息�pȝ��会有别于�H�口消息�Q�也可能需要进行坐标映��等�?/p>
图上�q�能看到�Q�我们的控�g是能够递归嵌套的。每个窗口对应一个根控�g�Q�所有的控�g都是在这个根�l��g之中的。�ؓ了要能够使用�H�口的整个客户区�Q�那么根�l��g所处区域就是窗口的整个客户区�?/p>
现在我们要开始进行设计了�Q�设计过�E�中��引入代码，代码��随着设计的演化进行演化，最�l��Ş成我们这个简单且可扩展的抽象模拟控�g核心�?/p>
作�? Evil.Ghost 发表�?2011-04-03 13:53 原文链接
评论: 0　查看评论　发表评论
最新新闻：
· �Ҏ��iPad 2通过3C认证最�?月国内上�?/a>(2011-04-10 09:18)
· 盲目依赖iPhone�{�工具导�?英国驴友�q��\�?/a>(2011-04-10 09:14)
· ��谈�Q�想担�QCEO的话�Q�最好是去苹果工作，其次是微软，再才是Google(2011-04-10 08:26)
· 腾讯��徏立新数据中心�Q�规模�ؓ�Ҏ��的两�?/a>(2011-04-10 08:25)
· 轻量化的微型博客Tumblr(2011-04-10 08:03)
�~�辑推荐�Q?a target="_blank">非战之罪�Q�从�怸�Office谈�v
�|�站��D��Q?a target="_blank">博客园首��?/a>  我的园子   新闻   闪存   ��组   博问   知识�?/a>

EvilGhost 2011-04-03 13:53 发表评论