QT运行原理

★了解Qt和C++的关系
★掌握Qt的信号/槽机制的原理和使用方法
★了解Qt的元对象系统
★掌握Qt的架构
★理解Qt的事件模型，掌握其使用的时机

信号与槽、元对象系统、事件模型是Qt机制的核心，如果您想要掌握Qt编程，就需要对它们有比较深入的了解。本章重点介绍了信号与槽的基本概念和用法、元对象系统、Qt的事件模型，以及它们在实际使用过程中应注意的一些问题。

Qt对标准C++的扩展
标准C＋＋对象模型为面向对象编程提供了有效的实时支持，但是它的静态特性在一些领域中表现的不够灵活。事实上，GUI应用程序往往对实时性和灵活性都有着很高的要求。Qt通过其改进的对象模型在保持C＋＋执行速度的同时提供了所需要的灵活性。 Qt相对于标准C＋＋增添的特性主要有以下体现：
◆支持对象间通信信号与槽机制
◆支持可查询和可设计的动态对象属性机制
◆事件和事件过滤器
◆国际化支持
◆支持多任务的定时器
◆支持按层检索的对象树
◆受保护指针
◆动态类型转换
这些内容是Qt核心机制的重要组成部分，在下面的章节中，笔者将有选择的向大家介绍它们。

一、信号与槽

信号和槽机制是Qt的核心机制之一，要掌握Qt编程就需要对信号和槽有所了解。信号和槽是一种高级接口，它们被应用于对象之间的通信，它们是Qt的核心特性，也是Qt不同于其它同类工具包的重要地方之一。在我们所了解的其它GUI工具包中，窗口小部件(widget)都有一个回调函数用于响应它们触发的动作，这个回调函数通常是一个指向某个函数的指针。在Qt中用信号和槽取代了上述机制。
1.信号（signal）
当对象的状态发生改变时，信号被某一个对象发射（emit）。只有定义过这个信号的类或者其派生类能够发射这个信号。当一个信号被发射时，与其相关联的槽将被执行，就象一个正常的函数调用一样。信号-槽机制独立于任何GUI事件循环。只有当所有的槽正确返回以后，发射函数（emit）才返回。 如果存在多个槽与某个信号相关联，那么，当这个信号被发射时，这些槽将会一个接一个地被执行，但是它们执行的顺序将会是不确定的，并且我们不能指定它们执行的顺序。 信号的声明是在头文件中进行的，并且moc工具会注意不要将信号定义在实现文件中。Qt用signals关键字标识信号声明区，随后即可声明自己的信号。例如，下面定义了几个信号：
signals: voidyourSignal();voidyourSignal(intx); 在上面的语句中，signals是Qt的关键字。接下来的一行voidyourSignal();定义了信号yourSignal，这个信号没有携带参数；接下来的一行voidyourSignal(intx);定义了信号yourSignal(intx)，但是它携带一个整形参数，这种情形类似于重载。 注意，信号和槽函数的声明一般位于头文件中，同时在类声明的开始位置必须加上Q_OBJECT语句，这条语句是不可缺少的，它将告诉编译器在编译之前必须先应用moc工具进行扩展。关键字signals指出随后开始信号的声明，这里signals用的是复数形式而非单数，siganls没有public、private、protected等属性，这点不同于slots。另外，signals、slots关键字是QT自己定义的，不是C++中的关键字。 还有，信号的声明类似于函数的声明而非变量的声明，左边要有类型，右边要有括号，如果要向槽中传递参数的话，在括号中指定每个形式参数的类型，当然，形式参数的个数可以多于一个。 从形式上讲,信号的声明与普通的C++函数是一样的，但是信号没有定义函数实现。另外，信号的返回类型都是void，而C++函数的返回值可以有丰富的类型。 注意，signal代码会由moc自动生成，moc将其转化为标准的C++语句，C++预处理器会认为自己处理的是标准C++源文件。所以大家不要在自己的C++实现文件实现signal。
2.槽（slot）
槽是普通的C++成员函数，可以被正常调用，不同之处是它们可以与信号（signal）相关联。当与其关联的信号被发射时，这个槽就会被调用。槽可以有参数，但槽的参数不能有缺省值。 槽也和普通成员函数一样有访问权限。槽的访问权限决定了谁可以和它相连。通常，槽也分为三种类型，即publicslots、privateslots和protectedslots。 publicslots：在这个代码区段内声明的槽意味着任何对象都可将信号与之相连接。这对于组件编程来说非常有用：你生成了许多对象，它们互相并不知道，把它们的信号和槽连接起来，这样信息就可以正确地传递，并且就像一个小孩子喜欢玩耍的铁路轨道上的火车模型，把它打开然后让它跑起来。 protectedslots：在这个代码区段内声明的槽意味着当前类及其子类可以将信号与之相关联。这些槽只是类的实现的一部分，而不是它和外界的接口。 privateslots：在这个代码区段内声明的槽意味着只有类自己可以将信号与之相关联。这就是说这些槽和这个类是非常紧密的，甚至它的子类都没有获得连接权利这样的信任。 通常，我们使用public和private声明槽是比较常见的，建议尽量不要使用protected关键字来修饰槽的属性。此外，槽也能够声明为虚函数。 槽的声明也是在头文件中进行的。例如，下面声明了几个槽：
publicslots: voidyourSlot();
voidyourSlot(intx);
注意，关键字slots指出随后开始槽的声明，这里slots用的也是复数形式。
3.信号与槽的关联
槽和普通的C++成员函数几乎是一样的－可以是虚函数；可以被重载；可以是共有的、保护的或是私有的，并且也可以被其它C++成员函数直接调用；还有，它们的参数可以是任意类型。唯一不同的是：槽还可以和信号连接在一起，在这种情况下，每当发射这个信号的时候，就会自动调用这个槽。 connect()语句看起来会是如下的样子： connect(sender,SIGNAL(signal),receiver,SLOT(slot)); 这里的sender和receiver是指向QObject的指针，signal和slot是不带参数的函数名。实际上，SIGNAL()宏和SLOT()会把它们的参数转换成相应的字符串。 到目前为止，在已经看到的实例中，我们已经把不同的信号和不同的槽连接在了一起。但这里还需要考虑一些其他的可能性。
⑴一个信号可以连接多个槽
connect(slider,SIGNAL(valueChanged(int)),spinBox,SLOT(setValue(int))); connect(slider,SIGNAL(valueChanged(int)),this,SLOT(updateStatusBarIndicator(int)));
在发射这个信号的时候，会以不确定的顺序一个接一个的调用这些槽。
⑵多个信号可以连接同一个槽
connect()
无论发射的是哪一个信号，都会调用这个槽。
⑶一个信号可以与另外一个信号相连接
connect(lineEdit,SIGNAL(textChanged(constQstring&)),this,SIGNAL(updateRecord(const Qstring&)));
当发射第一个信号时，也会发射第二个信号。除此之外，信号与信号之间的连接和信号与槽之间的连接是难以区分的。
⑷连接可以被移除
disconnect(lcd,SIGNAL(overflow()),this,SLOT(handleMathError()));
这种情况较少用到，因为当删除对象时，Qt会自动移除和这个对象相关的所有连接。
⑸要把信号成功连接到槽（或者连接到另外一个信号），它们的参数必须具有相同的顺序和相同的类型
connect(ftp,SIGNAL(rawCommandReply(int,constQString &)),this,SLOT(processReply(int,constQString&)));
⑹如果信号的参数比它所连接的槽的参数多，那么多余的参数将会被简单的忽略掉 connect(ftp,SIGNAL(rawCommandReply(int,constQstring &)),this,SLOT(checkErrorCode(int)));
还有，如果参数类型不匹配，或者如果信号或槽不存在，则当应用程序使用调试模式构建后，Qt会在运行时发出警告。与之相类似的是，如果在信号和槽的名字中包含了参数名，Qt也会发出警告。
信号和槽机制本身是在QObject中实现的，并不只局限于图形用户界面编程中。这种机制可以用于任何QObject的子类中。
当指定信号signal时必须使用Qt的宏SIGNAL()，当指定槽函数时必须使用宏SLOT()。如果发射者与接收者属于同一个对象的话，那么在connect调用中接收者参数可以省略。
例如，下面定义了两个对象：标签对象label和滚动条对象scroll，并将 valueChanged()信号与标签对象的setNum()相关联，另外信号还携带了一个整形参数，这样标签总是显示滚动条所处位置的值。
QLabel *label=newQLabel; QScrollBar*scroll=newQScrollBar; QObject::connect(scroll,SIGNAL(valueChanged(int)), label,SLOT(setNum(int)));
4.信号和槽连接示例
以下是QObject子类的示例：
classBankAccount : publicQObject {
Q_OBJECT
public:
BankAccount () {curBalance=0;}
intbalance () const {returncurBalance;}
public slots:
voidsetBalance(intnewBalance);
signals:
voidbalanceChanged(int newBalance);
private:
intcurrentBalance;
};
与多数C++类的风格类似，BankAccount类拥有构造函数、balance()“读取”函数和setBalance()“设置”函数。它还拥有balanceChanged()信号，帐户余额更改时将发出此信号。发出信号时，与它相连的槽将被执行。
Set函数是在公共槽区中声明的，因此它是一个槽。槽既可以作为成员函数，与其他任何函数一样调用，也可以与信号相连。以下是setBalance()槽的实现过程：
voidBankAccount::setBalance(intnewBalance)
{
if(newBalance!=currentBalance)
{
currentBalance = newBalance;
emit balanceChanged(currentBalance);
}
}
语句emitbalanceChanged(currentBalance);将发出balanceChanged()信号，并使用当前新余额作为其参数。
关键字emit类似于“signals”和“slots”，由Qt提供，并由C++预处理器转换成标准C++语句。 以下示例说明如何连接两个BankAccount对象：
BankAccountx,y;
connect(&x,SIGNAL(balanceChanged(int)),&y,SLOT(setBalance(int)));
x.setBalance(2450);
当x中的余额设置为2450时，系统将发出balanceChanged()信号。y中的setBalance()槽收到此信号后，将y中的余额设置为2450。一个对象的信号可以与多个不同槽相连，多个信号也可以与特定对象中的某一个槽相连。参数类型相同的信号和槽可以互相连接。槽的参数个数可以少于信号的参数个数，这时多余的参数将被忽略。
5.需要注意的问题
信号与槽机制是比较灵活的，但有些局限性我们必须了解，这样在实际的使用过程中才能够做到有的放矢，避免产生一些错误。下面就介绍一下这方面的情况。
⑴信号与槽的效率是非常高的，但是同真正的回调函数比较起来，由于增加了灵活性，因此在速度上还是有所损失，当然这种损失相对来说是比较小的，通过在一台i586-133的机器上测试是10微秒（运行Linux），可见这种机制所提供的简洁性、灵活性还是值得的。但如果我们要追求高效率的话，比如在实时系统中就要尽可能的少用这种机制。
⑵信号与槽机制与普通函数的调用一样，如果使用不当的话，在程序执行时也有可能产生死循环。因此，在定义槽函数时一定要注意避免间接形成无限循环，即在槽中再次发射所接收到的同样信号。
⑶如果一个信号与多个槽相关联的话，那么，当这个信号被发射时，与之相关的槽被激活的顺序将是随机的，并且我们不能指定该顺序。
⑷宏定义不能用在signal和slot的参数中。
⑸构造函数不能用在signals或者slots声明区域内。
⑹函数指针不能作为信号或槽的参数。
⑺信号与槽不能有缺省参数。
⑻信号与槽也不能携带模板类参数。
6.小结
从QObject或其子类(例如Qwidget)派生的类都能够使用信号和槽机制。这种机制本身是在QObject中实现的，并不只局限于图形用户界面编程中：当对象的状态得到改变时，它可以某种方式将信号发射(emit)出去，但它并不了解是谁在接收这个信号。槽被用于接收信号，事实上槽是普通的对象成员函数。槽也并不了解是否有任何信号与自己相连接。而且，对象并不了解具体的通信机制。这实际上是“封装”概念的生动体现，信号与槽机制确保了Qt中的对象被当作软件的组件来使用,体现了“软件构件化”的思想。

二、元对象系统

Qt的元对象系统是一个基于标准C＋＋的扩展，能够使C＋＋更好的适应真正的组件GUI编程。它为Qt提供了支持对象间通信的信号与槽机制、实时类型信息和动态属性系统等方面的功能。
元对象系统在Qt中主要有以下三部分构成：QObject类、Q_OBJECT宏和元对象编译器moc。

1.元对象系统机制
Qt的主要成就之一是使用了一种机制对C++进行了扩展，并且使用这种机制创建了独立的软件组件。这些组件可以绑定在一起，但任何一个组件对于它所要连接的组件的情况事先都不了解。
这种机制称为元对象系统（meta-objectsystem），它提供了关键的两项技术：信号－槽以及内省（introspection）。内省功能对于实现信号和槽是必需的，并且允许应用程序的开发人员在运行时获得有关QObject子类的“元信息”（meta-information），包括一个含有对象的类名以及它所支持的信号和槽的列表。这一机制也支持属性（广泛用于Qt设计师中）和文本翻译（用于国际化），并且它也为QtScirpt模块奠定了基础。
标准C++没有对Qt的元对象系统所需要的动态元信息提供支持。Qt通过提供一个独立的moc工具解决了这个问题，moc解析Q_OBJECT类的定义并且通过C++函数提供可供使用的信息。由于moc使用纯C++来实现它的所有功能，所以Qt的元对象系统可以在任意C++编译器上工作。
这一机制是这样工作的：
⑴Q_OBJECT宏声明了在每一个QObject子类中必须实现的一些内省函数，如metaObject()、QMetaObject::className()、tr()、qt_metacall()，以及其它一些函数。
⑵Qt的moc工具生成了用于由Q_OBJECT声明的所有函数和所有信号的实现。
⑶像connect()和disconnect()这样的QObject的成员函数使用这些内省函数来完成它们的工作。
由于所有这些工作都是由qmake和QObject类自动处理的，所以很少需要再去考虑这些事情，如果想进一步了解的话，也可以阅读一下有关QMetaObject类的文档和由moc生成的C++源代码文件，可以从中看出这些实现工作是如何进行的。

2.元对象工具（moc）
Qt的信号和槽机制是采用标准C++来实现的。该实现使用C++预处理器和Qt所包括的moc（元对象编译器）。元对象编译器读取应用程序的头文件，并生成必要的代码，以支持信号和槽机制。
qmake生成的Makefiles将自动调用moc，所有需要使用moc的编译规则都会给自动的包含到Makefile文件中。开发人员无需直接使用moc编辑、甚至无需查看生成的代码。
除了处理信号和槽以外，moc还支持Qt的翻译机制、属性系统及其扩展的运行时类型信息。比如，Q_PROPERTY()宏定义类的属性信息，而Q_ENUMS()宏则定义在一个类中的枚举类型列表。Q_FLAGS()宏定义在一个类中的flag枚举类型列表，Q_CLASSINFO()宏则允许你在一个类的meta信息中插入name/value对。它还使C++程序进行运行时自检成为可能，并可在所有支持的平台上工作。
元对象编译器moc（metaobjectcompiler）对C++文件中的类声明进行分析并产生用于初始化元对象的C++代码，元对象包含全部信号和槽的名字以及指向这些函数的指针。
moc读C++源文件，如果发现有Q_OBJECT宏声明的类，它就会生成另外一个C++源文件，这个新生成的文件中包含有该类的元对象代码。例如，假设我们有一个头文件mysignal.h，在这个文件中包含有信号或槽的声明，那么在编译之前moc工具就会根据该文件自动生成一个名为mysignal.moc.h的C++源文件并将其提交给编译器；类似地，对应于mysignal.cpp文件moc工具将自动生成一个名为mysignal.moc.cpp文件提交给编译器。

3.需要注意的问题
元对象代码是signal/slot机制运行所必须的。用moc产生的C++源文件必须与类实现文件一起进行编译和连接，或者用#include语句将其包含到类的源文件中。moc并不扩展#include或者#define宏定义,它只是简单的跳过所遇到的任何预处理指令。

三、Qt的架构
Qt的功能是建立在它所支持平台的底层API之上的，这使得Qt非常灵活和高效。Qt使应用程序可与单平台的应用程序配套。
Qt是一个跨平台的框架，它使用本地样式的API严格遵循每个支持平台中的用户界面原则。Qt绘制了GUI应用程序所需的几乎所有控件，并且开发人员可以通过重新实现虚函数的方式来扩展或自定义所有这些控件。Qt的窗体能够精确模拟支持平台的观感，开发人员还可以生成自己的自定义样式，为其应用程序提供具有鲜明特色的外观。
Qt在它所支持的不同平台中使用底层API。这与传统的“分层”跨平台工具套件不同，传统工具套件是指在单个平台工具套件中使用的简单封装（例如，在Windows中使用MFC；在X11中使用Motif）。通常，分层工具套件速度较慢，其原因在于：库函数的每次调用都会产生许多要经过不同API层的附加调用。分层工具套件往往会受到基本工具套件的功能和行为的限制，导致应用程序中出现隐性错误。
Qt做到了非常专业地支持各种平台，并且可以充分利用各种平台的优点。通过使用单个源代码树，Qt应用程序可以编译成每个目标平台的可执行程序。尽管Qt是一个跨平台的框架，但与许多平台特定的工具套件相比，Qt完全面向对象，更易于学习，更具有高效性，这使得许多开发人员在开发单个平台时也更倾向于使用Qt。

1.X11
Qt/X11使用Xlib直接与X服务器通信。Qt不使用Xt（XToolkit，即：X工具套件）、Motif、Athena或其他任何工具套件。
Qt支持各种Unix：AIX®、FreeBSD®、HP-UX、Irix®、Linux、NetBSD、OpenBSD和Solaris。有关Qt所支持的编译器和操作系统版本的最新列表信息，请访问NOKIA公司网站。
Qt应用程序自动适应用户的窗口管理器或桌面环境，并且在Motif、CDE、GNOME和KDE下具有桌面环境本身的观感。这与大多数Unix工具套件相反，这些套件总是把用户限制在套件自身观感下。Qt全面支持Unicode。Qt应用程序自动支持Unicode和非Unicode字体。Qt将多种X字体组合在一起，可显示多语言文本。
Qt的字体处理功能十分强大，可以在所有已安装的字体中搜索当前字体中不存在的字符。
Qt可以充分利用X扩展程序。对于反锯齿字体、alpha混合字体和矢量图形，Qt支持RENDER扩展程序。Qt还为X输入方法提供了现场编辑功能。Qt可以使用传统的多头显示适配器和Xinerama支持多个屏幕。

2.Microsoft Windows
Qt/Windows使用Win32®API和GDI用于事件和绘图原语。Qt不使用MFC或任何其他工具套件。特别地，Qt不使用缺乏灵活性的“常见”控件上，而是采用功能更强大的可自定义的控件（如果不是特殊应用，Qt使用Windows本身的文件和打印对话框） 。
使用Windows的客户可以在Windows98、NT4、ME、2000、XP和Vista中使用MicrosoftVisualC++®和BorlandC++来创建Qt应用程序。
Qt为Windows版本执行运行检查，并使用提供的最高级功能。例如，只有WindowsNT4、2000、XP和Vista支持旋转文本；Qt则在所有Windows版本中都支持旋转文本，并在可能的情况下使用了操作系统本身的支持。Qt开发人员还可以避免处理不同版本WindowsAPI中的差异。
Qt支持Microsoft的可访问界面。与Windows中的常见控件不同，您可以扩展Qt控件，而不会丢失Qt基本控件的可访问或者说是固有信息。另外，我们也可以制作和使用自定义控件。Qt支持MicrosoftWindows下多个屏幕显示。

3.MacOSX
Qt将Cocoa®和Carbon®API组合在一起用来支持MacOSX。
Qt/Mac引入了布局并直接支持国际化，允许采用标准化方式访问OpenGL，并使用QtDesigner提供了功能强大的可视化设计。Qt使用事件循环处理文件和异步套接字的输入输出。Qt提供了稳定的数据库支持。开发人员可以使用流行的面向对象的API来创建Macintosh应用程序，该API具有综合文档和全部的源代码。
Macintosh开发人员可以在自己喜欢的平台上创建应用程序，在其他受支持的平台中，只需进行简单的重编译，即可显著扩大应用程序市场。Qt支持MacOSX中通用的二进制，这意味着可以为基于IntelCPU和PowerPC CPU的Mac创建Qt应用程序。

四、Qt的事件模型

1.事件的概念
应用程序对象将系统消息接收为Qt事件。应用程序可以按照不同的粒度对事件加以监控、过滤并做出响应。
在Qt中，事件是指从QEvent继承的对象。Qt将事件发送给每个QObject对象，这样对象便可对事件做出响应。也就是说，Qt的事件处理机制主要是基于QEvent类来实现的，QEvent类是其他事件类的基类。当一个事件产生时，Qt就会构造一个QEvent子类的实例来表述该事件，然后将该事件发送到相应的对象上进行处理。 编程人员可以对应用程序级别和对象级别中的事件进行监控和过滤。

2.事件的创建
大多数事件是由窗口系统生成的，它们负责向应用程序通知相关的用户操作，例如：按键、鼠标单击或者重新调整窗口大小。也可以从编程角度来模拟这类事件。在Qt中大约有50多种事件类型，最常见的事件类型是报告鼠标活动、按键、重绘请求以及窗口处理操作。编程人员也可以添加自己的活动行为，类似于内建事件的事件类型。
通常，接收方如果只知道按键了或者松开鼠标按钮了，这是不够的。例如，它还必须知道按的是哪个键，松开的是哪个鼠标按钮以及鼠标所在位置。每一QEvent子类均提供事件类型的相关附加信息，因此每个事件处理器均可利用此信息采取相应处理。

3.事件的交付
Qt通过调用虚函数QObject::event()来交付事件。出于方便起见，QObject::event()会将大多数常见的事件类型转发给专门的处理函数，例如： QWidget::mouseReleaseEvent()和QWidget::keyPressEvent()。开发人员在编写自己的控件时，或者对现有控件进行定制时，可以轻松地重新实现这些处理函数。
有些事件会立即发送，而另一些事件则需要排队等候，当控制权返回至Qt事件循环时才会开始分发。Qt使用排队来优化特定类型的事件。例如，Qt会将多个paint事件压缩成一个事件，以便达到最大速度。
通常，一个对象需要查看另一对象的事件，以便可以对事件做出响应或阻塞事件。这可以通过调用被监控对象的QObject::installEventFilter()函数来实现。实施监控对象的QObject::eventFilter()虚函数会在受监控的对象在接收事件之前被调用。
另外，如果在应用程序的QApplication唯一实例中安装一个过滤器，则也可以过滤应用程序的全部事件。系统先调用这类过滤器，然后再调用任何窗体特定的过滤器。开发人员甚至还可以重新实现事件调度程序QApplication::notify()，对整个事件交付过程进行全面控制。

4.事件循环模型
Qt的主事件循环能够从事件队列中获取本地窗口系统事件，然后判断事件类型，并将事件分发给特定的接收对象。主事件循环通过调用QCoreApplication::exec()启动，随着QCoreApplication::exit()结束，本地的事件循环可用利用QEventLoop构建。作为事件分发器的QAbstractEventDispatcher管理着Qt的事件队列，事件分发器从窗口系统或其他事件源接收事件，然后将他们发送给QCoreApplication或 QApplication的实例进行处理或继续分发。QAbstractEventDispatcher为事件分发提供了良好的保护措施。
一般来说，事件是由触发当前的窗口系统产生的，但也可以通过使用 QCoreApplication::sendEvent()和QCoreApplication::postEvent()来手工产生事件。需要说明的是QCoreApplication::sendEvent()会立即发送事件， QCoreApplication::postEvent()则会将事件放在事件队列中分发。如果需要在一个对象初始化完成之际就开始处理某种事件，可以将事件通过QCoreApplication::postEvent()发送。
通过接收对象的event()函数可以返回由接收对象的事件句柄返回的事件，对于某些特定类型的事件如鼠标（触笔）和键盘事件，如果接收对象不能处理，事件将会被传播到接收对象的父对象。需要说明的是接收对象的event()函数并不直接处理事件，而是根据被分发过来的事件的类型调用相应的事件句柄进行处理。

5.自定义事件
一般有下列5种方式可以用来处理和过滤事件，每种方式都有其使用条件和使用范围。
⑴重载paintEvent()、mousePressEvent()等事件处理器（eventhandler）
重新实现像mousePressEvent(),keyPressEvent()和paintEvent()这样的eventhandler是目前处理event所采用的最常见的方法，这种方法比较容易掌握。
⑵重载QcoreApplication::notify()函数
这种方式能够对事件处理进行完全控制。也就是说，当你需要在事件处理器(eventhandler)之前得到所有事件的话，就可以采用这个方法，但是这样一来，因为只有一个notify()函数，所以每次只能有一个子类被激活。这与事件过滤器不同，因为后者可以有任意数目并且同时存在。
⑶在QCoreApplication::instance()也即在qApp上安装事件过滤器
这样就可处理所有部件（widget）上的所有事件，这和重载 QCoreApplication::notify()函数的效果是类似的。一旦一个eventfilter被注册到qApp(唯一的QApplication对象),程序里发到其它对象的事件在发到其它的eventfilter之前,都要首先发到这个eventFilter上，不难看出，这个方法在调试（debugging）应用程序时也是非常有用的。
⑷重载QObject::event()函数
通过重新实现的event()函数，我们可以在事件到达特定部件的事件过滤器（eventhandler）前处理Tab事件。需要注意的是，当重新实现某个子类的event()的时候,我们需要调用基类的event()来处理不准备显式处理的情况。
⑸在选定对象（Object）上安装事件过滤器(eventfilter)
该对象需要继承自QObject,这样就可以处理除了Tab和Shift-Tab以外的所有事件。当该对象用installEventFilter()注册之后,所有发到该对象的事件都会先经过监测它的eventfilter。如果该object同时安装了多个eventfilter,那么这些filter会按照“后进先出”的规则依次被激活,即顺序是从最后安装的开始，到第一个被安装的为止。

6.事件与信号的区别
需要注意，我们不应该混淆“事件”和“信号”这两个概念。

⑴使用场合和时机不同
一般情况下，在“使用”窗口部件时，我们经常需要使用信号，并且会遵循信号与槽的机制；而在“实现”窗口部件时，我们就不得不考虑如何处理事件了。举个例子，当使用QPushButton时，我们对于它的clicked()信号往往更为关注，而很少关心促成发射该信号的底层的鼠标或者键盘事件。但是，如果要实现一个类似于QPushButton的类，我们就需要编写一定的处理鼠标和键盘事件的代码，而且在必要的时候，仍然需要发射和接收clicked()信号。

⑵使用的机制和原理不同
事件类似于Windows里的消息，它的发出者一般是窗口系统。相对信号和槽机制，它比较“底层”，它同时支持异步和同步的通信机制，一个事件产生时将被放到事件队列里，然后我们就可以继续执行该事件“后面”的代码。事件的机制是非阻塞的。
信号和槽机制相对而言比较“高层”，它的发出者一般是对象。从本质上看，它类似于传统的回调机制，是不支持异步调用的。
举个例子，在QApplication中有两个投送事件的方法：postEvent()和 sendEvent()，它们分别对应Windows中的PostMessage()和SendMessage()，就是是异步调用和同步调用，一个等待处理完后返回，一个只发送而不管处理完与否就返回。
在应用中，涉及到底层通信时，往往使用事件的时候比较多，但有时也会用到信号和槽。

⑶信号与槽在多线程时支持异步调用
在单线程应用时，你可以把信号与槽看成是一种对象间的同步通信机制，这是因为在这种情况下，信号的释放过程是阻塞的，一定要等到槽函数返回后这个过程才结束，也就是不支持异步调用。
从Qt4开始，信号和槽机制被扩展为可以支持跨线程的连接，通过这种改变，信号与槽也可以支持异步调用了，这方面的内容涉及到多线程的很多知识，读者感兴趣的话，可以参阅《C++GUIQt4编程》中的相关内容。

五、问题与解答
问：什么情况下可以断开信号与槽的关联？
答：有3种情况需要断开信号与槽的关联：
1.断开与某个对象相关联的任何对象
这似乎有点不可理解，事实上，当我们在某个对象中定义了一个或者多个信号，这些信号与另外若干个对象中的槽相关联，如果我们要切断这些关联的话，就可以利用这个方法，非常之简洁。
disconnect(myObject,0,0,0);
或者
myObject->disconnect();
2.断开与某个特定信号的任何关联
disconnect(myObject,SIGNAL(mySignal()),0,0)
或者
myObject->disconnect(SIGNAL(mySignal()))
3.断开两个对象之间的关联。
disconnect(myObject,0,myReceiver,0)
或者
myObject->disconnect(myReceiver)
在disconnect函数中0可以用作一个通配符，分别表示任何信号、任何接收对象、接收对象中的任何槽函数。但是发射者sender不能为0，其它三个参数的值可以等于0。
问：Qt的元对象系统还有哪些功能？
1.QObject::metaObject()方法
它获得与一个类相关联的meta-object。
2.QMetaObject::className()方法
在运行期间返回一个对象的类名，它不需要本地C++编译器的RTTI(run-timetypeinformation)支持。
3.QObject::inherits()方法
它用来判断生成一个对象类是不是从一个特定的类继承出来，当然，这必须是在QObject类的直接或者间接派生类当中。
4.QObject::tr()andQObject::trUtf8()
这两个方法为软件的国际化翻译字符串。
5.QObject::setProperty()andQObject::property()
这两个方法根据属性名动态的设置和获取属性值。
除了以上这些功能外，它还使用qobject_cast()方法在QObject类之间提供动态转换，qobject_cast()方法的功能类似于标准C++的dynamic_cast()，但是qobject_cast()不需要RTTI的支持，在一个QObject类或者它的派生类中，我们可以不定义Q_OBJECT宏。如果我们在一个类中没有定义Q_OBJECT宏，那么在这里所提到的相应的功能在这个类中也不能使用，从meta-object的观点来说，一个没有定义Q_OBJECT宏的类与它最接近的那个祖先类是相同的，那就是说，QMetaObject::className()方法所返回的名字并不是这个类的名字，而是与它最接近的那个祖先类的名字。所以，我们强烈建议，任何从QObject继承出来的类都定义Q_OBJECT宏。
答：你需要在程序中重载下列函数，具体可以查阅QtAssistant。
mousePressEvent(QMouseEvent*event)
{
//要做的事
}
keyPressEvent(QkeyEvent*event)
{
//要做的事（键盘）
}

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 在采用Qt开发GUI应用程序时通常都希望程序在刚启动的时候能居中显示（如果默认不是最大化启动的话）。实现方法（代码）如下所示：

1. 获取桌面环境
    QDesktopWidget *desktop=QApplication::desktop();
    //获取桌面宽度
    int w=desktop->width();
    //获取桌面高度
    int h=desktop->height();

2. 移动窗口到中间（move）
    QMainWindow window;
    window.move((w-window.width())/2,(h-window.height())/2);
    window.show();

下面是实际的一个例子，在main函数中创建窗口并剧中显示：
int main(int argc,char *argv[])
{
    QApplication app(argc,argv);

    QDesktopWidget *desktop=QApplication::desktop();
    //获取桌面宽度
    int w=desktop->width();
   //获取桌面高度
    int h=desktop->height();

    QMainWindow window;
    //居中显示
    window.move((w-window.width())/2,(h-window.height())/2);
    window.show();

    return app.exec();
}

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

cocos2d框架原理

上一篇介绍了工程的创建方式，现在来分析一下源码的执行原理。

首先是main.cpp文件，具体如下：

[cpp] view plain copy

1. int APIENTRY _tWinMain(HINSTANCE hInstance,  
2.                        HINSTANCE hPrevInstance,  
3.                        LPTSTR    lpCmdLine,  
4.                        int       nCmdShow)  
5. {  
6.     UNREFERENCED_PARAMETER(hPrevInstance);  
7.     UNREFERENCED_PARAMETER(lpCmdLine);  
8.   
9.     // create the application instance  
10.     AppDelegate app;  
11.     CCEGLView* eglView = CCEGLView::sharedOpenGLView();  
12.     eglView->setViewName("test");  
13.     eglView->setFrameSize(480, 320);  
14.     return CCApplication::sharedApplication()->run();  
15. }  

第一步：创建一个AppDelegate app句柄，AppDelegate继承自CCApplication，因此首先执行CCApplication的

构造函数,sm_pSharedApplication=this;为该静态成员变量指向了内含的this指针，即当前的实例（本例中为app）

[cpp] view plain copy

1. CCApplication::CCApplication()    
2. : m_hInstance(NULL)    
3. , m_hAccelTable(NULL)    
4. {    
5.     m_hInstance    = GetModuleHandle(NULL);    
6.     m_nAnimationInterval.QuadPart = 0;    
7.     CC_ASSERT(! sm_pSharedApplication);    
8.     sm_pSharedApplication = this;//类声明处  
9. }  

第二步：获取视图，并设置其title以及大小；
第三步：该步为关键，CCApplication::sharedApplication()，为获取application的实例，进入源码可看到:

[cpp] view plain copy

1. CCApplication* CCApplication::sharedApplication()//此函数为静态成员函数  
2. {  
3.   CC_ASSERT(sm_pSharedApplication);  
4.     return sm_pSharedApplication;  
5. }  

由于sm_pSharedApplication为静态成员变量，所以所有调用CCApplication::sharedApplication()，

皆返回静态成员变量sm_pSharedApplication(此例中为app);然后看获取了sm_pSharedApplication对象后，

运行run，可进入源码中：

[cpp] view plain copy

1. int CCApplication::run()  
2. {  
3.     PVRFrameEnableControlWindow(false);  
4.   
5.   
6.     // Main message loop:  
7.     MSG msg;  
8.     LARGE_INTEGER nFreq;  
9.     LARGE_INTEGER nLast;  
10.     LARGE_INTEGER nNow;  
11.   
12.   
13.     QueryPerformanceFrequency(&nFreq);  
14.     QueryPerformanceCounter(&nLast);  
15.   
16.   
17.     // Initialize instance and cocos2d.  
18.     if (!applicationDidFinishLaunching())  
19.     {  
20.         return 0;  
21.     }  
22.   
23.   
24.     CCEGLView* pMainWnd = CCEGLView::sharedOpenGLView();  
25.     pMainWnd->centerWindow();  
26.     ShowWindow(pMainWnd->getHWnd(), SW_SHOW);  
27.   
28.   
29.     while (1)  
30.     {  
31.         if (! PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))  
32.         {  
33.             // Get current time tick.  
34.             QueryPerformanceCounter(&nNow);  
35.   
36.   
37.             // If it's the time to draw next frame, draw it, else sleep a while.  
38.             if (nNow.QuadPart - nLast.QuadPart > m_nAnimationInterval.QuadPart)  
39.             {  
40.                 nLast.QuadPart = nNow.QuadPart;  
41.                 CCDirector::sharedDirector()->mainLoop();  
42.             }  
43.             else  
44.             {  
45.                 Sleep(0);  
46.             }  
47.             continue;  
48.         }  
49.   
50.   
51.         if (WM_QUIT == msg.message)  
52.         {  
53.             // Quit message loop.  
54.             break;  
55.         }  
56.   
57.   
58.         // Deal with windows message.  
59.         if (! m_hAccelTable || ! TranslateAccelerator(msg.hwnd, m_hAccelTable, &msg))  
60.         {  
61.             TranslateMessage(&msg);  
62.             DispatchMessage(&msg);  
63.         }  
64.     }  
65.   
66.   
67.     return (int) msg.wParam;  
68. }  

可看到标红处，此处为关键，有上面的分析可以知道该处实例为app,此时就执行了AppDelegate中声明的

applicationDidFinishLaunching()：

[cpp] view plain copy

1. bool AppDelegate::applicationDidFinishLaunching() {  
2.     // initialize director  
3.     CCDirector* pDirector = CCDirector::sharedDirector();//CCDirector为单实例模式，一个程序中只有一个导演类实例  
4.     CCEGLView* pEGLView = CCEGLView::sharedOpenGLView();  
5.     pDirector->setOpenGLView(pEGLView);    
6.     // turn on display FPS  
7.     pDirector->setDisplayStats(true);  
8.     // set FPS. the default value is 1.0/60 if you don't call this  
9.     pDirector->setAnimationInterval(1.0 / 60);  
10.     // create a scene. it's an autorelease object  
11.     CCScene *pScene = HelloWorld::scene();  
12.     // run  
13.     pDirector->runWithScene(pScene);  
14.     return true;  
15. }  

如上标红处，可看到此处为调用HelloWorld类中的静态成员函数，创建一个场景实例，进入该场景创建函数源码：

[cpp] view plain copy

1. CCScene* HelloWorld::scene()  
2. {  
3.     // 'scene' is an autorelease object  
4.    //创建场景实例  
5.     CCScene *scene = CCScene::create();  
6.     // 'layer' is an autorelease object  
7.     HelloWorld *layer = HelloWorld::create();  
8.     // add layer as a child to scene  
9.     scene->addChild(layer);  
10.     // return the scene  
11.     return scene;  
12. }  

标红处为创建一个helloworld的层实例，可看create的源码，在class HelloWorld类中的声明为

CREATE_FUNC(HelloWorld);此处为一个宏声明：

[cpp] view plain copy

1. #define CREATE_FUNC(__TYPE__) \  
2. static __TYPE__* create() \  
3. { \  
4.     __TYPE__ *pRet = new __TYPE__(); \  
5.     if (pRet && pRet->init()) \  
6.     { \  
7.         pRet->autorelease(); \  
8.         return pRet; \  
9.     } \  
10.     else \  
11.     { \  
12.         delete pRet; \  
13.         pRet = NULL; \  
14.         return NULL; \  
15.     } \  
16. }  

一个静态的创建给定类型__TYPE__实例的静态方法。标红处，执行了创建的实例的初始化init（）函数，

可进到class HelloWorld类中去阅读init()源码：

[cpp] view plain copy

1. bool HelloWorld::init()  
2. {  
3.     //  
4.     // 1. super init first  
5.     if ( !CCLayer::init() )  
6.     {  
7.         return false;  
8.     }   
9.     CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();  
10.     CCPoint origin = CCDirector::sharedDirector()->getVisibleOrigin();  
11.     /  
12.     // 2. add a menu item with "X" image, which is clicked to quit the program  
13.     //    you may modify it.  
14.     // add a "close" icon to exit the progress. it's an autorelease object  
15.     CCMenuItemImage *pCloseItem = CCMenuItemImage::create(  
16.                                         "CloseNormal.png",  
17.                                         "CloseSelected.png",  
18.                                         this,  
19.                                         menu_selector(HelloWorld::menuCloseCallback));  
20.       
21.     pCloseItem->setPosition(ccp(origin.x + visibleSize.width - pCloseItem->getContentSize().width/2 ,  
22.                                 origin.y + pCloseItem->getContentSize().height/2));  
23.     // create menu, it's an autorelease object  
24.     CCMenu* pMenu = CCMenu::create(pCloseItem, NULL);  
25.     pMenu->setPosition(CCPointZero);  
26.     this->addChild(pMenu, 1);  
27.     /  
28.     // 3. add your codes below...  
29.     // add a label shows "Hello World"  
30.     // create and initialize a label  
31.       
32.     CCLabelTTF* pLabel = CCLabelTTF::create("Hello World", "Arial", 24);  
33.       
34.     // position the label on the center of the screen  
35.     pLabel->setPosition(ccp(origin.x + visibleSize.width/2,  
36.                             origin.y + visibleSize.height - pLabel->getContentSize().height));  
37.     // add the label as a child to this layer  
38.     this->addChild(pLabel, 1);  
39.   
40.   
41.     // add "HelloWorld" splash screen"  
42.     CCSprite* pSprite = CCSprite::create("HelloWorld.png");  
43.   
44.   
45.     // position the sprite on the center of the screen  
46.     pSprite->setPosition(ccp(visibleSize.width/2 + origin.x, visibleSize.height/2 + origin.y));  
47.   
48.   
49.     // add the sprite as a child to this layer  
50.     this->addChild(pSprite, 0);  
51.       
52.     return true;  
53. }  

此函数，执行了层 动作 精灵等方面的操作，最后运行后就如图所示。

TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT

TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT

引言：如果你想深入了解cocos2d-x的整个框架和运行流程，如果你想知道整个启动过程的细节，如果你想知道自己写的代码是在什么时候和在哪里被调用的，下面可以为你解答其中奥秘。对象：适合刚刚入门了cocos2d-x的初学者，编写并运行过简单的demo，并且想仔细探究其中的原理机制。1、程序入口main.cpp

?

1 2 3 4 5 6 7 8 9 10 11

int APIENTRY _tWinMain(HINSTANCE hInstance,                         HINSTANCE hPrevInstance,                         LPTSTR    lpCmdLine,                         int       nCmdShow) {      ...      // create the application instance      AppDelegate app; //看这里      ...      return CCApplication::sharedApplication()->run(); //看这里 }

以上两行是关键代码（1）代码AppDelegate app;调用了AppDelegate的构造函数，而它的父类是CCApplication，所以CCApplication的构造函数也被调用了

?

1 2 3 4 5 6 7 8 9

CCApplication::CCApplication() : m_hInstance(NULL) , m_hAccelTable(NULL) {      m_hInstance    = GetModuleHandle(NULL);      m_nAnimationInterval.QuadPart = 0 ;      CC_ASSERT(! sm_pSharedApplication);      sm_pSharedApplication = this ; }

这里完成了AppDelegate和CCApplication之间的联系，由于AppDelegate是CCApplication的子类，故CCApplication里面的静态单例指针指的便是AppDelegate的实例。之后调用CCApplication::sharedApplication()的相关操作是基于AppDelegate的实现。（2）代码CCApplication::sharedApplication()->run();调用了下面的代码

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

int CCApplication::run() {      ...      // Initialize instance and cocos2d.      if (!applicationDidFinishLaunching())      {          return 0 ;      }      ..      while ( 1 )      {          if (! PeekMessage(&msg, NULL, 0 , 0 , PM_REMOVE))          {              // Get current time tick.              QueryPerformanceCounter(&nNow);                // If it's the time to draw next frame, draw it, else sleep a while.              if (nNow.QuadPart - nLast.QuadPart > m_nAnimationInterval.QuadPart)              {                  nLast.QuadPart = nNow.QuadPart;                  CCDirector::sharedDirector()->mainLoop(); //看这里              }              else              {                  Sleep( 0 );              }              continue ;          }            if (WM_QUIT == msg.message)          {              // Quit message loop.              break ;          }            // Deal with windows message.          if (! m_hAccelTable || ! TranslateAccelerator(msg.hwnd, m_hAccelTable, &msg))          {              TranslateMessage(&msg);              DispatchMessage(&msg);          }      }        return ( int ) msg.wParam; }

在这里，run()函数里面是一个while死循环，不过里面有判断条件 if (WM_QUIT == msg.message)可以跳出循环，终止程序。循环里面每隔一段时间m_nAnimationInterval就调用CCDirector::sharedDirector()->mainLoop()，完成游戏的刷新。（3）下面来看看mainLoop()都干了啥事：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

void CCDisplayLinkDirector::mainLoop( void ) {      if (m_bPurgeDirecotorInNextLoop)      {          m_bPurgeDirecotorInNextLoop = false ;          purgeDirector();      }      else if (! m_bInvalid)       {           drawScene(); //看这里                  // release the objects           CCPoolManager::sharedPoolManager()->pop(); //看这里             } }

首先解释一下为什么显示的是CCDisplayLinkDirector::mainLoop，而不是 CCDirector ::mainLoop，答案就在CCDirector.h头文件里面

?

1 2 3 4 5 6 7 8 9 10

class CC_DLL CCDirector : public CCObject, public TypeInfo ｛          .......          virtual void mainLoop( void ) = 0 ; //看这里          ....... } class CCDisplayLinkDirector : public CCDirector {         .......... }

在CCDirector类里面，mainLoop是纯虚函数，而CCDisplayLinkDirector是CCDirector的子类。重新回到mainLoop函数的实现，我们发现drawScene()和CCPoolManager::sharedPoolManager()->pop()是其主要内容，也就是重绘和释放自动内存池管理器里面暂时存储的对象，这个和cocos2d-x的自动内存管理机制有关，所有静态创建对象函数::create()都采用了自动托管机制，比如：

?

1 2 3 4 5 6 7 8 9 10 11

CCSprite* CCSprite::create( const char *pszFileName) {      CCSprite *pobSprite = new CCSprite();      if (pobSprite && pobSprite->initWithFile(pszFileName))      {          pobSprite->autorelease(); //看这里          return pobSprite;      }      CC_SAFE_DELETE(pobSprite);      return NULL; }

其中autorelease()函数实现如下

?

1 2 3 4 5

CCObject* CCObject::autorelease( void ) {      CCPoolManager::sharedPoolManager()->addObject( this );      return this ; }

由此可以看到自动内存管理对象在每帧绘制结束后都会被CCPoolManager::sharedPoolManager()->pop()释放，除非我们在create()对象后使用了retain()，retain()也很简单，实现如下

?

1 2 3 4 5 6

void CCObject::retain( void ) {      CCAssert(m_uReference > 0 , "reference count should greater than 0" );        ++m_uReference; //看这里 }

就是把对象的引用计数-1，这又对应于对象的release()函数

?

1 2 3 4 5 6 7 8 9 10

void CCObject::release( void ) {      CCAssert(m_uReference > 0 , "reference count should greater than 0" );      --m_uReference; //看这里        if (m_uReference == 0 ) //看这里      {          delete this ;      } }

可以看到，对象只有当其引用计数m_uReference=0时，才会真正被删除。（4）下面看看drawScene()重绘函数负责什么，看完你就全明白了整个框架了

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

// Draw the Scene void CCDirector::drawScene( void ) {      ..............      //tick before glClear: issue #533      if (! m_bPaused)      {          m_pScheduler->update(m_fDeltaTime); //看这里      }      .....................      // draw the scene      if (m_pRunningScene)      {          m_pRunningScene->visit();      }      .....................      // swap buffers      if (m_pobOpenGLView)      {          m_pobOpenGLView->swapBuffers();      }      ................ }

大家看到 m_pScheduler->update(m_fDeltaTime)会不会想到我们经常在HelloWorldScene.h写的void update(float dt)，两者有什么关系呢？首先回忆一下，我们在HelloWorldScene.h里面是怎样调用到update函数的this->schedule(schedule_selector( HelloWorld::update));（这只是调用方式的一种）看看schedule函数的实现

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

void CCNode::schedule(SEL_SCHEDULE selector) {      this ->schedule(selector, 0 .0f, kCCRepeatForever, 0 .0f); } void CCNode::schedule(SEL_SCHEDULE selector, float interval, unsigned int repeat, float delay) {      CCAssert( selector, "Argument must be non-nil" );      CCAssert( interval >= 0 , "Argument must be positive" );        m_pScheduler->scheduleSelector(selector, this , interval , repeat, delay, !m_bRunning); //看这里 } class CC_DLL CCNode : public CCObject {     .........        CCScheduler *m_pScheduler;  //看这里        ....... }

再对比一下刚才drawScene()重绘函数

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// Draw the Scene void CCDirector::drawScene( void ) {      ..............      //tick before glClear: issue #533      if (! m_bPaused)      {          m_pScheduler->update(m_fDeltaTime); //看这里      }      ..................... } class CC_DLL CCDirector : public CCObject, public TypeInfo {       ...............          CC_PROPERTY(CCScheduler*, m_pScheduler, Scheduler); //看这里          .............. } #define CC_PROPERTY(varType, varName, funName)\ //看这里 protected : varType varName;\ public : virtual varType get##funName( void );\ public : virtual void set##funName(varType var);

我们发现CCNode和CCDirector类都申明了CCScheduler *m_pScheduler，都不是同一个滴。且慢，不一定哦，看看CCNode的构造函数先

?

1 2 3 4 5 6 7 8

CCNode::CCNode( void ) : ........... {      CCDirector *director = CCDirector::sharedDirector();      ...............      m_pScheduler = director->getScheduler(); //看这里      ................ }

原来CCNode里面的m_pScheduler引用了CCDirector的m_pScheduler，感受到穷追不舍的魅力了吧。再回到之前的问题：CCDirector::drawScene里面的m_pScheduler->update(m_fDeltaTime)和我们经常在HelloWorldScene.h写的void update(float dt)，两者有什么关系呢？由上面代码可见，this->schedule(schedule_selector( HelloWorld::update))实际上会把schedule_selector( HelloWorld::update)保存到CCNode里面的m_pScheduler，也就是CCDirector里面的m_pScheduler，那么CCDirector::drawScene里面的m_pScheduler->update(m_fDeltaTime)里面的代码应该就和HelloWorld::update()有关吧。继续看看呗。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// main loop void CCScheduler::update( float dt) {      ................      // Iterate over all the custom selectors      for (tHashTimerEntry *elt = m_pHashForTimers; elt != NULL; )      {          m_pCurrentTarget = elt;          m_bCurrentTargetSalvaged = false ;            if (! m_pCurrentTarget->paused)          {              // The 'timers' array may change while inside this loop              for (elt->timerIndex = 0 ; elt->timerIndex < elt->timers->num; ++(elt->timerIndex))              {                  elt->currentTimer = (CCTimer*)(elt->timers->arr[elt->timerIndex]);                  elt->currentTimerSalvaged = false ;                  elt->currentTimer->update(dt); //看这里                   ......................              }          }           ..................      }      ............... }

重点看elt->currentTimer->update(dt);elt->currentTimer是CCTimer类，看看里面的update函数是神马情况先

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

void CCTimer::update( float dt) {      if (m_fElapsed == - 1 )      {         ....................      }      else      {          if (m_bRunForever && !m_bUseDelay)          { //standard timer usage              ...................              if (m_fElapsed >= m_fInterval)              {                  if (m_pTarget && m_pfnSelector)                  {                      (m_pTarget->*m_pfnSelector)(m_fElapsed); //看这里                  }                  ...................              }          }             else          { //advanced usage              ...............              if (m_bUseDelay)              {                  if ( m_fElapsed >= m_fDelay )                  {                      if (m_pTarget && m_pfnSelector)                      {                          (m_pTarget->*m_pfnSelector)(m_fElapsed); //看这里                      }                      ...............                  }              }              else              {                  if (m_fElapsed >= m_fInterval)                  {                      if (m_pTarget && m_pfnSelector)                      {                          (m_pTarget->*m_pfnSelector)(m_fElapsed); //看这里                      }                      .......................                  }              }              ..............          }      } }

你可能还不知道(m_pTarget->*m_pfnSelector)(m_fElapsed);这个什么意思，没事，重新看看HelloWorldScene.h调用update函数时的代码：this->schedule(schedule_selector( HelloWorld::update));下面是schedule的实现（上面已提过）

?

1 2 3 4 5 6 7 8 9 10 11

void CCNode::schedule(SEL_SCHEDULE selector) {      this ->schedule(selector, 0 .0f, kCCRepeatForever, 0 .0f); } void CCNode::schedule(SEL_SCHEDULE selector, float interval, unsigned int repeat, float delay) {      CCAssert( selector, "Argument must be non-nil" );      CCAssert( interval >= 0 , "Argument must be positive" );        m_pScheduler->scheduleSelector(selector, this , interval , repeat, delay, !m_bRunning); //看这里 }

最后一步，就是看m_pScheduler->scheduleSelector(selector, this, interval , repeat, delay, !m_bRunning)和(m_pTarget->*m_pfnSelector)(m_fElapsed)有什么关系，其中selector是函数指针，指向HelloWorld::update，不懂的可以看schedule_selector的定义。下面是scheduleSelector函数的实现

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

void CCScheduler::scheduleSelector(SEL_SCHEDULE pfnSelector, CCObject *pTarget, float fInterval, unsigned int repeat, float delay, bool bPaused) {      ................      tHashTimerEntry *pElement = NULL;      HASH_FIND_INT(m_pHashForTimers, &pTarget, pElement);      if (! pElement)      {          ...........................      }      else      {          CCAssert(pElement->paused == bPaused, "" );      }        if (pElement->timers == NULL)      {          pElement->timers = ccArrayNew( 10 );      }      else      {         ....................      }        CCTimer *pTimer = new CCTimer();      pTimer->initWithTarget(pTarget, pfnSelector, fInterval, repeat, delay); //看这里      ccArrayAppendObject(pElement->timers, pTimer);      pTimer->release();    }

重点看pTimer->initWithTarget(pTarget, pfnSelector, fInterval, repeat, delay)，其中pTarget就是CCNode（对应HelloWorld类）对象本身，而pfnSelector就是刚才说的函数指针，指向HelloWorld::update，下面是initWithTarget的函数实现

?

1 2 3 4 5 6 7

bool CCTimer::initWithTarget(CCObject *pTarget, SEL_SCHEDULE pfnSelector, float fSeconds, unsigned int nRepeat, float fDelay) {      m_pTarget = pTarget;      m_pfnSelector = pfnSelector;      .....................      return true ; }

由此，我们解决刚才提出的问题：看看m_pScheduler->scheduleSelector(selector, this, interval , repeat, delay, !m_bRunning)和(m_pTarget->*m_pfnSelector)(m_fElapsed)有什么关系，其中selector是函数指针，指向HelloWorld::update。答案就在上面，再次啰嗦说明一下，pTarget就是CCNode（对应HelloWorld类）对象本身，而pfnSelector就是刚才说的函数指针，指向HelloWorld::update，也就是说，HelloWorld类定义的void update(float dt)被调用了，而且是在整个主循环里面CCDirector::sharedDirector()->mainLoop()。（5）结束语：整个cocos2d-x的框架 源码就是这样，具体一些细节还未涉及，但我们已经理解程序一开始从main函数，然后怎么样一步步调用到我们自己是HelloWorld.h里面自己定义实现的函数，特别是update函数，同时也了解了cocos2d-x的一些内存管理机制和回调机制，也在这个框架代码里面，还有整个框架是怎么实现帧数控制的。用《一代宗师》里面的一句话来概括这次框架源码研读之旅吧——”念念不忘，必有回响“。

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

寄语：选择可能就意味着孤独，我们只有不懈的坚持方能看见曙光！

最近比较郁闷，上一个项目还是黄了，自己加入了新的团队，在工作之余打算看看cocos的源代码，于是这一系列的文章便诞生了。

通过源代码分析，可以看到整个cocos引擎的渲染控制函数是：Director::drawScene()

[html] view plain copy

1. // calculate "global" dt  
2.     calculateDeltaTime();  
3.       
4.     // skip one flame when _deltaTime equal to zero.  
5.     if(_deltaTime < FLT_EPSILON)  
6.     {  
7.         return;  
8.     }  
9.   
10.     if (_openGLView)  
11.     {  
12.         _openGLView->pollEvents();  
13.     }  
14.   
15.     //tick before glClear: issue #533  
16.     if (! _paused)  
17.     {  
18.         _scheduler->update(_deltaTime);  
19.         _eventDispatcher->dispatchEvent(_eventAfterUpdate);  
20.     }  
21.   
22.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  
23.   
24.     /* to avoid flickr, nextScene MUST be here: after tick and before draw.  
25.      * FIXME: Which bug is this one. It seems that it can't be reproduced with v0.9  
26.      */  
27.     if (_nextScene)  
28.     {  
29.         setNextScene();  
30.     }  
31.   
32.     pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);  
33.       
34.     if (_runningScene)  
35.     {  
36.         //clear draw stats  
37.         _renderer->clearDrawStats();  
38.           
39.         //render the scene  
40.         _runningScene->render(_renderer);  
41.           
42.         _eventDispatcher->dispatchEvent(_eventAfterVisit);  
43.     }  
44.   
45.     // draw the notifications node  
46.     if (_notificationNode)  
47.     {  
48.         _notificationNode->visit(_renderer, Mat4::IDENTITY, 0);  
49.     }  
50.   
51.     if (_displayStats)  
52.     {  
53.         showStats();  
54.     }  
55.     _renderer->render();  
56.   
57.     _eventDispatcher->dispatchEvent(_eventAfterDraw);  
58.   
59.     popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);  
60.   
61.     _totalFrames++;  
62.   
63.     // swap buffers  
64.     if (_openGLView)  
65.     {  
66.         _openGLView->swapBuffers();  
67.     }  
68.   
69.     if (_displayStats)  
70.     {  
71.         calculateMPF();  
72.     }  

在上面的代码中，我觉的最先开始和渲染有关系的是：
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

有关此函数的详细解释，可参考这篇：http://blog.csdn.net/shuaihj/article/details/7230138

清除完缓存区之后：
if (_nextScene)
    {
        setNextScene();
    }

如果需要切换场景，就设置下一个要渲染的场景。

if (_runningScene)
    {
        //clear draw stats
        _renderer->clearDrawStats();
        
        //render the scene
        _runningScene->render(_renderer);
        
        _eventDispatcher->dispatchEvent(_eventAfterVisit);
    }

上面的代码中_renderer 先不做详细解释，_runningScene->render(_renderer)便可以看出是渲染当前场景的主要  函数。

_eventDispatcher->dispatchEvent(_eventAfterDraw);事件分发

_openGLView->swapBuffers()的实现代码为：

if(_mainWindow)
        glfwSwapBuffers(_mainWindow);

glfwSwapBuffers这个函数的命名就可以看出是opengl的api

此函数的作用参照：http://blog.csdn.net/shuaihj/article/details/7231913

交换缓存之后，drawScene的主要功能就完成了。从上面的代码可以看出cocos渲染的循环体就是这么函数了，所有的渲染的驱动都是在这里开始的。

下篇文章我们去看看coocs的render对象。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

CApplication

  Windows phone上最好的游戏引擎cocos2d-x for XNA发布也有几个月了，作为移植团队我们一直没有时间献上一些教程，现在我们要开始了，打开你的Visual Studio，我们开始学习吧！

   这系列教程我会讲解分析大部分开发者会用到的cocos2d-x for XNA的常用类的功能及用法，带些示例代码，更多的交流请加我们的QQ群，在文章末尾：

 

   大部分框架，基本上都可以分为两部分：

      1.  一个入口主类，它定义了整个应用程序的生命周期，并提供一些全局的资源

      2.  一些绘制到屏幕上的“页面”控件。

   如果大家熟悉 Silverlight for Windows phone ，知道这个入口主类就是 Application ，它订阅并处理 WP 应用程序的生命周期事件，并定义系统资源。

   而这些页面控件就是 Silverlight for Windows phone 应用程序中的 PhoneApplicationPage 。它定义了一个一个的页面外观。

   有了这个基础，我们来看 Cocos2D ，我们发现它们的情形惊人的一致： CCApplication 作为应用程序的入口，负责调控引擎的整个生命周期。而 PhoneApplicationPage 则对应 cocos2d 中的 CCScene ，是的，正如 Wp 应用程序每时每刻会显示一个页面一样， cocos2d 每时每刻会显示一个 CCScene 。  

 
   其实这也不奇怪，图形应用程序大多是这样的思路，只不过游戏轮询的模式更适应于游戏频繁的逻辑和状态更新，而事件的模式适应于开发用户输入驱动的应用程序。

   所以，在 cocos2d 中， CCApplication 主要做三件事情：

            1.     控制应用程序的生命周期

            2.     提供和管理 一些全局的资源

     3. 处理Touch

     4. 循环绘制界面

 
   应用程序的生命周期有一下几个虚方法：

      ///   <summary>

       ///  可以做一些简单全局变量的初始化工作，在DrawableGameComponent的Initialize方法中调用

       ///   </summary>

      public  override  bool initInstance();

 

        ///   <summary>

       ///   资源加载完成之后发生，在DrawableGameComponent的LoadContent方法末尾中调用

       ///   </summary>

      public  override  bool applicationDidFinishLaunching()

  

      ///   <summary>

      ///  程序进入后台被挂起

     ///   </summary>

      public  override  void applicationDidEnterBackground()

     ///   <summary>

      ///  程序从后台被唤醒 

      ///   </summary>

      public  override  void applicationWillEnterForeground()

 

      这和Silverlight for Windows phone总的应用程序生命周期是类似的，不过注意的是目前的cocos2d-x for XNA中并没有加入挂起和唤醒的方法调用，不过很简单，你可以在Game1类的OnActivated和OnDeactivated中调用它们，下个版本修正这个问题。

 

另一个比较重要的变化是， CCApplication 增加了一些 XNA 绘制相关的全局属性，包括：

     1.    ContentManager ：用于管理资源的加载。

    2.     SpriteBatch ：用于绘制 2D 的纹理。

    3.     WorldMatrix ：当前着色器的世界矩阵。

    4.     ViewMatrix ：当前着色器的视图矩阵。

    5.    ProjectionMatrix ：当前着色器的投影矩阵。

    6.    basicEffect ：用来绘制元素的着色器。

   这些属性主要用于绘制，它们会被 CCSprite ， CCSpriteBatchNode 以及 CCTextureAtlas 等与绘制相关的类使用。如果你的游戏中需要自己绘制 2D 或者 3D 的元素，也可以直接调用这些属性进行绘制。

     第三个就是处理Touch事件，我们可以看到Update方法中就只有一个处理Touch的方法。实际上处理的是上一帧的Touch事件。

     第四个就是绘制界面，Draw做两件有意义的事情：

        1. 重置摄像机位置和坐标。（其实这里也不是必须每帧都这么做，因为后面我们看到CCNode的时候就会知道，每帧绘制完毕实际上会将这些矩阵变换还原，后续可以做一些优化）。

        2. 进入CCDirector的mainLoop循环。

 

        CCDirector的mainLoop就是整个游戏的绘制过程了，我们以后会慢慢分析。

        现在，你明白CCApplication了吗？欢迎讨论。