抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的

Posted on 2008-08-18 22:19 cexer 阅读(4520) 评论(12) 编辑收藏引用所属分类: GUI

转帖请注明出处　http://www.cppblog.com/cexer/archive/2008/08/18/59285.html

　　抛弃了上一个消息机制，因为它的实现不得不多用了几个模板函数，在使用的时候有代码膨胀的现象。虽然其程度不如　win32gui，SmartWin，不过因为本人有点极端，所以相当地不满意。于是又开始写一个新的消息机制，它的外表看起来像是 SmartWin++ 和 AWT 的混血儿。

　　SmartWin++ 的想法极富创意，但是其实现却不怎么漂亮，就像鲁迅先生说的：离的越近，伤痕和不足越容易看见。或者更专业一点，借用一个朋友的 QQ 签名说的：每个整洁的接口后面，都有一个龌龊的实现。仔细看过它的的龌龊实现之后，我想大概是永远不会用它写程序了，不过同样要对作者的灵感表示敬佩和感谢。自己写这个框架到后来，竟然也有向 SmartWin++ 靠拢的趋势。

　　AWT 的接口和实现很漂亮，不过看它在 C++ 上的这个实现，因为 C++ 与 java 一些语言特性上的差别，导致这个照搬过来的实现并不适用于 C++，一是性能很低，二是使用起来会比较麻烦。大概是因为作者要靠虑跨平台的因素，所以缚手缚脚的没有能放开写。其实在这个基础上好好地优化改进一下，会是个很不错的框架。

　　自己的这个框架的消息机制是介于 SmartWin++ 的 Aspects 与 AWT 的 Listener 这间的一种机制。底层实现很简单，在上面再包装出一些 Listener 。这些 Listener 的结构看起来像 AWT 的 Listener，完成的功能却是 SmartWin++ 的 Aspects 的功能。可以对比一下看看

AWT ( C++的一个移植版）

　　比如说在 AWT 当中鼠标相关的 Listener 大概是这样的：

class MouseListener : public EventListener 

{

  

public:

  

    virtual void mouseClicked( MouseEvent& ) = 0;

    virtual void mousePressed( MouseEvent& ) = 0;

    virtual void mouseReleased( MouseEvent& ) = 0;

    virtual void mouseEntered( MouseEvent& ) = 0;

    virtual void mouseExited( MouseEvent& ) = 0;

  

};

　　如果一个类想处理自己的鼠标消息，则必须在这个类上派生，然后调用addListener 将自己添加进 Listeners 当中即可。比如说要写一个按钮类 Button* button，它要处理自己的鼠标按下的消息，代码大概会是这个样子：

class Button:public Component,

            ,public MouseListener  //　从 MouseListener 接口派生

            ,public SomethingElse

{

    Button()

    {

        addMouseListener( this );

  

        // do something else

    }

  

    virtual void mousePressed( MouseEvent& me )

    {

        // button is pressed

        // do something

    }

};

　　如果还有外部的类想要处理这个按钮的鼠标按下消息，那么这个外部的类也必须从 MouseListener 派生，然后将自己添加进按钮的 Listeners 当中。代码大概像这个样子：

//　从 MouseListener 接口派生

class MouseEventTester:public MouseListener,public SomethingElse

{

    // 实现 mousePreseed 函数

    virtual void mousePressed( MouseEvent& )

    {

        // mouse is pressed

        // do something;

    }

};

  

//　添加到按钮的鼠标 Listener 列表当中

  

Button* button = new Button();

button->addMouseListener( new MouseEventTester() );

　　AWT 都是使用虚函数实现的，其性能上会有一些问题，谁叫是从 java 移植的呢。而且消息处理函数的名字被限定死了，至少那些有特定名字习惯（比如很多人写的函数非得用大写字母开始）的程序会一定不会满意的。另外，消息的种类也被接口限制死了，除了接口提供的 mousePressed,mouseClicked 等消息的函数，要添加其它消息的处理能力就比较麻烦。

SmartWin++

　　再看看 SmartWin++ Aspect 方式。SmartWin++ 关于鼠标消息的 Aspect 像这个样子：

  

template</*一大堆模板参数*/>

class AspectMouseClicks

{

    void onLeftMouseUp( Handler eventHandler );

    void onLeftMouseUp( Handler eventHandler);

  

    void onLeftMouseDown( Handler eventHandler);

    void onLeftMouseDown( Handler eventHandler);

  

    void onMouseMove( Handler eventHandler);

    void onMouseMove( Handler eventHandler);

  

    // 其它一些鼠标消息

    // .....

  

protected:

    virtual ~AspectMouseClicks()

    {}

};

　　还是写一个按钮，它想处理自己的鼠标按下消息，代码大概像这样：

class Button:public AspectMouseClicks</*一大堆参数*/>

{

    Button()

    {

        onLeftMouseUp( &Button::mousePressed );

    }

    

    void mousePressed( MouseEvent& me )

    {

        // mouse is pressed

        // do something

    }

};

　　而因为 SmartWin++ 的设计上的问题，除了按钮本身之外，仅有按钮的祖先窗口（包括父窗口）对象也能够处理它的鼠标消息。比如一个窗口 TestWindow，在它之上创建了按钮　Button，则这个按钮的消息要么被 TestWindow 处理，要么被自己处理，不能被其它的外部类或函数处理。TestWndow 当中处理这个按钮的鼠标按下的消息的代码大概像这样：

class TestWindow:public Something

{

  

public:

  

    TestWindow()

    {

        Button* button = createButton();

        button->onLeftMouseUp( &TestWindow::mousePressed );

    }

  

    void mousePressed( MouseEvent& me )

    {

        // mouse is pressed

        // do something

    }

};

　　SmartWin++ 表面上看起来是使用的函数指针，效率应该会比 AWT 的虚函数高一些，其它不然。看看上面的代码，指定消息处理函数的时候，并没有把消息处理函数的拥有者的指针传进去。因此在用函数指针调用函数的时候，SmartWin++ 框架为了寻找到函数的拥有者指针，用了很龌龊低效的的一个方法，也正是这样的方法，使得父窗口类之外的其它类或函数不可能参与到消息的处理当中来。

自己的机制：
　　
　　像上面说的，自己新写的这个消息机制介于 AWT 的 Listeners 与 SmartWin 的 Aspects 之间。这个框架当中的MouseListener 的定义看起来像这样：

<typename TImpl>

class MouseListener

{

  

public:

  

    void onMouseClicked( TOwner* owner,MemberHandler handler );

    void onMousePressed( TOwner* owner,MemberHandler handler );

    void onMouseReleased( TOwner* owner,MemberHandler handler );

    void onMouseDblclk( TOwner* owner,MemberHandler handler );

    void onMouseEntered( TOwner* owner,MemberHandler handler );

    void onMouseExited( TOwner* owner,MemberHandler handler );

    void onMouseMoved( TOwner* owner,MemberHandler handler );

  

};

　　有鼠标消息的 GUI 类都已经从这个 Listener 继承，比如说如果要写一个按钮类，想要它有响应鼠标按下消息的能力，则代码大概是这样：

  

// 从 MouseListener 继承

class Button:public MouseListener<Button>

            ,public SomethingElse

{

  

public:

  

    Button()

    {

        onMousePressed( this,&Button::mousePressed );

    }

    

    void mousePressed( UINT keys,POINT cursor )

    {

        // mouse is pressed

        // do something

    }

};

　　因为 Button 已经从 MouseListener 派生，所以所有它的祖先窗口和父窗口都能用 MouseListener 的函数 onMousePressed 来注册自己的处理函数：

class TestWindow

{

  

public:

  

    TestWindow()

    {

        Button* button = new Button();

        button->onMousePressed( this,&TestWindow::mousePressed );

    }

  

    void mousePressed( Widget* source,UINT keys,POINT cursor )

    {

        // mouse is pressed

        // do something

    }

};

　　需要注意的，这个 mousePressed 函数多了一个 Widget* 类型的 source 参数，以便在一个函数处理多个 GUI 对象的鼠标消息的时候，用来区别鼠标消息是来自哪一个 GUI 对象。因为在按钮类当中，知道是处理的自己的消息，所以就不需要这样一个额外的参数。

　　到目前为止看起来好像都跟 SmartWin++ 没有多大的区别。不过这个框架允许任何类甚至全局函数也能处理任何 GUI 对象对外公开的消息。比如说有一个额外的类想处理上面那个按钮的鼠标按下消息，其代码大概像这样：

//　从 MouseListener 接口派生

class MouseEventTester:public MessageListener

{

  

public:

  

    void mousePressed( Widget* source,UINT keys,POINT cursor )

    {

        // mouse is on source,and it is pressed

        // do something;

    }

};

  

  

MouseEventTester* tester = new MouseEventTester();

  

//　添加到按钮的鼠标 Listener 列表当中

Button* button = new Button();

button->addListener( &tester );

　　这个类不用派生自 MouseListener，而是直接派生自了底层的 MessageListener（其实 MessageListener 对外只提供了一个函数 handleMessage）

　　除了上面的方式，也可以这样干，更简单一些，甚至不用任何派生。

//　从 MouseListener 接口派生

class MouseEventTester

{

  

public:

  

    void mousePressed( Widget* source,UINT keys,POINT cursor )

    {

        // mouse is on source,and it is pressed

        // do something;

    }

};

  

  

MouseEventTester* tester = new MouseEventTester();

  

  

  

  

// 直接添加消息处理函数

Button* button = new Button();

button->onMousePressed( tester,&MouseEventTester::mousePressed );

　　也提供对全局函数的支持比如：

  

// 全局函数

void mousePressed( Widget* source,UINT keys,POINT cursor )

{

    // mouse is on source,and it is pressed

    // do something

}

  

  

//　直接添加为消息处理函数

Button* button = new Button();

button->onMousePressed( &::mousePressed );

　　这个版本的消息机制虽然不如上一个消息机制方便，需要手动地消息映射，不过极大地增加了灵活性，消除了代码膨胀的问题。

　　下面是一个完整的测试程序代码：

// cexer

#include "../../cexer/include/GUI/panel.h"

#include "../../cexer/include/GUI/window.h"

#include "../../cexer/include/GUI/button.h"

#include "../../cexer/include/GUI/checkbox.h"

#include "../../cexer/include/GUI/radiobox.h"

#include "../../cexer/include/GUI/GUI.h"

  

using namespace cexer;

using namespace cexer::gui;

using namespace cexer::gdi;

  

// c++ std

#include <iostream>

using namespace std;

  

  

class TestWindow:public Window

{

  

public:

  

    TestWindow( ):Window( NULL,_T("test window") )

    {

        onCreated( this,&TestWindow::windowCreated );

        onClosing( this,&TestWindow::windowClosing );

        onDestroy( this,&TestWindow::windowDestroy );

        onResized( this,&TestWindow::windowResized );

        onErasing( this,&TestWindow::windowErasing );

  

        onMouseClicked( this,&TestWindow::mouseClicked );

        onMouseEntered( this,&TestWindow::mouseEntered );

        onMouseExited(  this,&TestWindow::mouseExited );

        onMousePressed( this,&TestWindow::mousePressed );

        onMouseReleased( this,&TestWindow::mouseReleased );

    }

  

public:

  

    LRESULT windowCreated( Widget*,CREATESTRUCT& )

    {

        wcout<<L"创建成功！"<<endl;

  

        Panel* panel = new Panel( this,_T("panel") );

        panel->create( _T(""),10,10 );

        panel->onResized( this,&TestWindow::windowResized );

  

        Button* button = new Button( panel,_T("button") );

        button->create( _T("测试按钮"),10,10 );

        button->onClicked( this,&TestWindow::buttonClicked );

  

        Checkbox* checkbox = new Checkbox( panel,_T("checkbox") );

        checkbox->create( _T("测试多选框"),10,40 );

        checkbox->onClicked( this,&TestWindow::buttonClicked );

  

        

        Radiobox* radiobox = new Radiobox( panel,_T("radiobox") );

        radiobox->create( _T("测试单选框"),10,70 );

        radiobox->onClicked( this,&TestWindow::buttonClicked );

  

        return 0;

    }

  

    LRESULT windowDestroy( Widget* )

    {

        wcout<<L"销毁成功！"<<endl;

        ::PostQuitMessage(0);

  

        return 0;

    }

  

    LRESULT windowClosing( Widget* )

    {

        if ( IDNO == confirmBox(_T("确定关闭窗口？")) )

        {

            return 0;

        }

  

        destroy();

  

        return 0;

    }

  

    LRESULT windowErasing( Widget*,Canvas& canvas )

    {

        canvas.fillRect( clientBounds() );

        canvas.drawText( 100,100,_T("测试窗口") );

  

        return 0;

    }

  

    LRESULT windowResized( Widget* source,UINT,SIZE size )

    {

        if ( source->name() == m_name )

        {

            long panelWidth  = ( size.cx-20 );

            long panelHeight = ( size.cy-20 );

  

            resizeChild( _T("panel"),panelWidth,panelHeight );

        }

        else if ( source->name() == _T("panel") )

        {

            long childWidth  = ( size.cx-20 );

            long childHeight = 20;

  

            resizeChild( _T("button")  ,childWidth,childHeight );

            resizeChild( _T("checkbox"),childWidth,childHeight );

            resizeChild( _T("radiobox"),childWidth,childHeight );

        }

        

        return 0;

    }

  

    LRESULT buttonClicked( Button* button )

    {

        messageBox( button->text() + _T("被点击了！") );

        return 0;

    }

  

  

    LRESULT mouseClicked( Widget*,UINT,POINT cursor)

    {

        wcout<<L"鼠标点击\t"<<L"位置";

        wcout<<L"("<<cursor.x<<L","<<cursor.y<<L")"<<endl;

        return 0;

    }

  

    LRESULT mouseEntered( Widget*,UINT,POINT cursor )

    {

        wcout<<L"鼠标进入\t"<<L"位置";

        wcout<<L"("<<cursor.x<<L","<<cursor.y<<L")"<<endl;

        return 0;

    }

  

    LRESULT mouseExited( Widget*,UINT,POINT cursor )

    {

        wcout<<L"鼠标离开\t"<<L"位置";

        wcout<<L"("<<cursor.x<<L","<<cursor.y<<L")"<<endl;

        return 0;

    }

  

    LRESULT mousePressed( Widget*,UINT,POINT cursor )

    {

        wcout<<L"鼠标按下\t"<<L"位置";

        wcout<<L"("<<cursor.x<<L","<<cursor.y<<L")"<<endl;

        return 0;

    }

  

    LRESULT mouseReleased( Widget*,UINT,POINT cursor )

    {

        wcout<<L"鼠标释放\t"<<L"位置";

        wcout<<L"("<<cursor.x<<L","<<cursor.y<<L")"<<endl;

        return 0;

    }

  

};

  

  

  

int _tmain( int argc,TCHAR** argv )

{

    CEXER_GUI_THREAD();

  

    wcout.imbue( std::locale("") );

  

    TestWindow* window = new TestWindow();

    window->create();

  

    return runGUIthread();

}

Feedback

# re: 抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的回复 更多评论

2008-08-19 12:37 by Touchsoft

只看了开头的鼠标消息定义
如果一个类想处理自己的鼠标消息，则必须在这个类上派生，然后调用addListener
像Decorator Pattern。

# re: 抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的回复 更多评论

2008-08-19 14:03 by 空明流转

函数指针比虚方法更慢。。。

# re: 抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的回复 更多评论

2008-08-19 16:11 by cexer

@空明流转
的确是半斤八两，不过虚函数还得查一下虚表，生成的汇编代码会有多几个寄存器操作，而静态的函数指针是直接call地址的。

# re: 抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的回复 更多评论

2008-08-20 01:24 by 陈梓瀚(vczh)

很好，已经快接近我那个了……

# re: 抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的回复 更多评论

2008-08-24 16:06 by dell

每个整洁的接口后面，都有一个龌龊的实现。真是深刻。

# re: 抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的回复 更多评论

2008-12-22 01:45 by null

to cexer

你都是怎么看源代码的我也下了个超小型的GUI库不知道从哪看起

# re: 抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的回复 更多评论

2009-10-12 00:56 by XML

请教一下，你的MemberHandler 是怎么定义的？是如何让onXXEvent接收任意类的成员函数的？

# re: 抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的回复 更多评论

2009-11-16 00:57 by 暗涌

消息处理函数有点像C#中的EventHandler，总是把消息的发送者传给处理函数。把发送者类型放到模板参数里是个不错的办法，有点像Singleton的模板。。。

# re: 抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的回复 更多评论

2009-11-17 17:13 by cexer

@null
读书千遍其义自现啊，最主要是闷着看代码。
从示例代码，最高层开始往底层追溯

# re: 抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的回复 更多评论

2009-11-17 17:13 by cexer

@XML
那个代码找不到了，不过实现还记得，以后会写一下实现。

# re: 抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的回复 更多评论

2009-11-17 17:14 by cexer

@暗涌
嗯呵呵

# re: 抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的 回复 更多评论

2010-02-22 21:01 by jom

能写自己的GUI框架，不错啊，呵呵。

刷新评论列表

只有注册用户登录后才能发表评论。
【推荐】100%开源！大型工业跨平台软件C++源码提供，建模，组态！

相关文章: GUI框架：消息检查者 GUI框架：谈谈框架，写写代码抛弃了上一个 GUI 消息机制，重写了一个更灵活高效的各 GUI 框架的 COMMAND_RANGE_HANDLER（范围 ID 的命令消息统一处理）自己写的一个GUI框架的消息机制

网站导航: 博客园 IT新闻 BlogJava 博问 Chat2DB 管理

cexer