重要：
本文摘自致远电子出品书籍《嵌入式Linux开发教程》，本教程凝聚了ZLG致远电子嵌入式工程师的心血，任何形式的转载请务必标注此段文字！！！
  c% N) z. t! v9 {
/ |" p6 g8 l% U常见的嵌入式Linux图形界面有Qt/Embedded、DirectFB、MicroWindows/NanoX、MiniGUI和OpenGUI等，每个GUI都有各自不同特点和应用场合，在应用编程上也各不相同。
3 w! Y, ?* n. g* }3 u本文将介绍嵌入式Qt的基础编程，从环境搭建入手，然后介绍了qmake工具以及Qt Creator,紧接着给出Qt常见部件编程和范例，最终以一个经典的贪食蛇游戏在Qt上的实现为例，对前面介绍的编程进行综合。
6 M0 M3 M" ]" s* t5 _# Y01
Qt和Qt/Embedded
Qt介绍
Qt是一个跨平台应用程序和UI开发框架。使用Qt只需一次性开发应用程序，无需重新编写源代码，便可跨不同桌面和嵌入式操作系统部署这些应用程序。Qt原为奇趣科技公司（Trolltech，www.trolltech.com）开发维护，现在被Nokia公司收购。目前在Nokia的推动下，Qt的发展非常快速，版本不断更新。目前最新的Qt主版本为5.4，所支持的平台如图1所示。
- w  l. x" s2 R- {' o  G$ x 1 Qt支持的平台
/ Y1 C$ |5 P/ H5 c  x注：本文使用的版本为4.7.3，由于qt 5 和qt 4编程方面有些差别，且市面上大多数都是qt4编程的资料，qt5的相对较少，所以建议使用qt4进行编程开发。
( ~7 D. b: k; l4 [" f$ @% |Qt/Embedded介绍
嵌入式Linux发行版上的Qt属于Qt的Embedded Linux分支平台（本文简称为Qt/E）。Qt/E在原始Qt的基础上，做了许多出色的调整以适合嵌入式环境。同桌面版的Qt/X11相比，嵌入式的Qt/E很节省内存，因为它不需要X server或是Xlib库，它在底层摒弃了Xlib，采用Framebuffer（帧缓冲）作为底层图形接口。Qt/E的应用程序可以直接写内核帧缓冲，这避免开发者使用繁琐的Xlib/Server系统。
Qt/E所面对的硬件平台较多，当开发人员需要在某硬件平台上移植Qt/E时，需要下载Qt源代码，利用交叉编译器编译出Qt库，接着需要将Qt库复制两份，一份放置在开发主机上，供编译使用，一份放在目标板上，供运行时动态加载使用。具体流程如图2所示。
2 编译Qt库流程图
. g+ n3 s- w  Q; ]7 j( c
02Qt/Embedded交叉编译环境的搭建之环境介绍与安装

环境介绍
主机系统：Ubuntu 12.04 32-bit；交叉编译环境：arm-none-linux-gnueabi；开发板：EasyARM-i.MX283A；安装文件目录结构：/home/vmuser/nfs_shared用于开发板的挂载PC机的路径。
1 v: a8 L# f/ w* `9 I1 @安装tslib1.4
在采用触摸屏的移动终端中，触摸屏性能的调试是一个重要问题之一，因为电磁噪声的缘故，触摸屏容易存在点击不准确，有抖动等问题。
tslib是一个开源程序，能够为触摸屏驱动获得的采样提供诸如滤波、去抖动、校准等功能，通常作为触摸屏驱动的适配层，为上层的应用提供了一个统一的接口。
如果不采用触摸屏，可以不安装该库，跳过这一小节。
) d/ c! m9 y" {3 M2 h- l! O: @1. 准备工作
确保已安装autoconf、automake和libtool。如果没有安装，或者不确定，可输入下列命令进行安装：

注意：确保内核源码目录下的include/linux/input.h的EV_VERSION值与交叉编译工具定义的EV_VERSION值一致（本例为arm-none-linux-gnueabi/libc/usr/include/linux/input.h），不然在开发板上tslib会报告“selected device is not a touchscreen I understand”错误。
2. 下载源码
: G) V$ x% @) [) ?( m从网上下载tslib源代码，本文以tslib-1.4.tar.gz为例。下载后，得到tslib-1.4.tar.gz，解压，如下命令：$ tar -zxvf tslib-1.4.tar.gz
3. 配置
进入解压的目录，执行如下命令：
# V8 W& p/ [# j
% o# S8 _6 j! c. f- b) X* c--prefix指定安装路径，用户可以自行指定tslib的安装目录。--host指定交叉编译器，如果交叉编译器是arm-none-linux-guneabi-gcc，则指定arm-none-linux-guneabi。
4. 编译
4 E6 l! h0 q) O0 ]: M' Y5 N, h执行make指令：$ make
5. 安装
' j, ~2 q. ~2 V4 h6 j$ make install编译生成的库，头文件等都拷贝到prefix指定的路径中。如果可以看到该指定的路径下有4个文件夹：/bin、/etc、/lib、/include，则表示安装完成。
, a8 U6 E# o. W6. 修改ts.conf内容
为了在移植开发板的时候，可以制定输入模块，需要修改ts.conf文件的内容。
进入安装目录下的/etc/文件夹，修改ts.conf文件的内容。$ vi ts.conf
找到#module_raw input那一行，去掉注释#，如下图3所示。
# T5 w, m: \" a, E8 D 图3 ts.conf文件内容

2 d( i( W1 s0 [  D' X; a* ~

注意：行首不要留空格，要顶格。
7. 移植到开发板
将安装路径下的tslib整个文件夹，下载到开发板上，本例子放置在开发板的/usr/local/下，如图4所示。
图4 开发板tslib路径
# D' _+ {- r' Q9 r' y8. 设置开发板环境
& \) T5 w2 R# m+ e, @通过串口软件（如本文使用的Tera Term），打开开发板的环境变量文件/etc/profile。# sudo vi /etc/profile
  m5 K! z/ r  u/ d5 q在末尾添加如下内容：

其中TSLIB_ROOT更改为自己实际存放的tslib的绝对路径。
/ w( ?' L) G4 U- H/ v- @TSLIB_TSDEVICE和QWS_MOUSE_PROTO这两项需要查看自己的开发板触摸屏设备对应/dev/input/下的文件。
- e! B# P( I( q0 \* O9. 执行测试命令
" {; a3 Y# x7 k5 |重新启动开发板，使系统重新读取/etc/profile的环境变量，进入tslib/bin目录，执行如下命令：# cd /usr/local/tslib/bin# ./ts_calibrate
如果开发板出现如图5所示界面，则至此，tslib的安装和移植已经成功完成。
可以执行该目录下的其他程序，体检触摸屏。
2 T0 v; O6 X& b) O* N" d  j* y& J 图5 5点触摸屏校准画面
, y& ]3 o8 n/ {7 N7 k: ~& T03Qt/Embedded交叉编译环境的搭建之编译qt4.7.3-arm

3 _; m# \& `" X8 J. T* E下载qt-4.7.3源码包（qt-everywhere-opensource-src-4.7.3.tar.gz），进入源码包的目录，然后解压缩，进入解压缩的目录，配置相应的选项内容保存到脚本build-qt里面，脚本文件内容如图6所示。
图6 build-qt文件
: z2 j: K6 Y7 C4 K2 c然后在该目录下的mkspec/qws/linux-arm-gnueabi-g++/qmake.conf文件添加-lts参数和在文件末尾添加如下两行：

  ~. C0 g  h! P5 @+ j8 y& ^实际操作后的效果如图7所示。
图7 qmake.conf文件内容
然后开始安装，具体命令如下：

2 R, F- I; o: A, `, G: X注意：需要指定tslib相关文件的路径如：-I /home/zlg/nfs_shared/tslib/include –L /hone/zlg/nfs_shared/tslib/lib和-qt-mouse-tslib，另外配置之前确保g++已安装。
至于./configure 的选项可以通过./configure -help查看，并参照实际开发板，选择合适的选项。例如选项-prefix <安装路径>指定安装目录。
7 r' U7 X3 E1 J% d. j6 L. p如果没有指定安装路径则默认安装在/usr/local/Trolltech/QtEmbedded-4.7.3-arm。
( F: N, a5 k# [/ [# n/ Q7 V配置完成后，开始执行如下命令：$ make
此处根据配置的选项，可能花费的时间比较久，需要耐心等待。
接下来执行如下命令进行安装：$ make install
1 a( q% d  a4 g6 a7 J! z安装成功后，则可以在安装目录下查看到相关文件夹，如本例安装路径为/home/vmuser/nfs_shared/qt-4.7.3-arm，查看到有bin、imports、include、lib、mkspec、plugins、translations。
9 B; j9 L! G8 B' M! e7 P接下来就要移植到开发板上。
; w, Q5 n1 ?4 x" s9 X% K7 m需要将安装目录下的lib和plugins移植到ARM开发板上，本例安装在/usr/local/qt-4.7.3-arm，所以在开发板上执行如下命令：# mkdir /usr/local/qt-4.7.3-arm
# b7 x& \8 O  l. J  Q" M, v: H通过NFS，将lib和plugins下载到开发板上。在开发板上执行的命令如下：

) T4 F/ n2 X6 o3 n设置相应的环境变量，在开发板上执行如下命令：# vi /etc/profile
然后在文件末尾追加如下内容：
% W0 J) a. U+ q( ^) n
& {7 L  E) B) F5 a1 \04Qt Sdk搭建
Qt SDK简介

  W  v: d( E- _! r( R

Qt是一个跨平台的图形框架，在安装了桌面版本的Qt SDK的情况下，用户可以先在PC主机上进行Qt应用程序的开发调试，待应用程序基本成型后，再将其移植到目标板上。
桌面版本的Qt SDK主要包括以下部分：
  Q( [, O% j$ L用于桌面版本的Qt库集成开发环境IDE（Qt Creator）
: `5 S. S' Y( u% w% m4 ]" A$ KQt SDK安装

桌面版本的Qt SDK支持三个平台：Windows、Linux、Mac。这里只讲述Linux桌面版本的Qt SDK的安装。其他平台下的安装可查阅官方资料。用户可以在Qt官方网站找到三个平台对应的安装包。推荐通过Ubuntu下的apt-get获取Linux版的Qt SDK。在Linux主机可以正常上网的条件下，先进行安装源的更新，否则可能导致Qt-SDK安装失败。安装源更新命令如下：
$ sudo apt-get update        
" H2 V" M& K% N9 s/ S其执行过程如所图8示。
5 w2 j5 m/ X( Y& g# z; L0 V' I 图18 更新Linux安装源
安装源更新成功后，可以使用如下命令获取并安装Qt SDK。
7 F4 h5 N1 D7 Z' p% q$ sudo apt-get install qt-sdk        
在Qt SDK的安装过程中可能会出现如图9所示的警告窗口，这时只需要选中该窗口并按回车键即可。
图9 Qt SDK安装过程中可能出现的警告窗口
当Qt SDK安装完成后，终端显示如图10所示。
7 w8 i8 f9 j5 P 图10 完成Qt SDK的安装
7 u! D8 V& n5 X( X0 @8 j安装成功后，会在/usr/bin/目录下产生两个可执行文件qmake和qmake-qt4如图11所示。
图11 qmake可执行文件路径
第1个qmake是qt5版本的，本文使用第2个qmake-qt4可执行文件，为了区别用于嵌入式的qmake指令和桌面版本的qmake指令，可以通过设置别名，如本文用qmake-arm来指定嵌入式版本的qmake，在~/.bashrc文件的末尾添加如下命令：
alias qmake-arm=/home/vmuser/nfs_shared/qt-4.7.3-arm/bin/qmake

添加成功后，可以执行source ~/.bashrc使其立刻生效。然后可以分别执行qmake-qt4–v和qmake-arm–v，查看版本是否分别对应嵌入式和桌面版本，命令如下：
        
2 ^. T- q! Z+ W1 v0 dPC终端上显示如图12所示。
图12 qmake的不同版本
至此，Qt SDK的环境搭建已经全部完成，接下来将介绍如何编译Qt应用程序。
2 R% w) c# w+ j# u% y; PQt可以使用三种方法来编译Qt应用程序：第一种方法是使用Qt提供的qmake工具，第二种方法是使用集成开发环境（IDE），而第三种使用第三方的编译工具。本文主要介绍前两种方法。
05Qt CreatorQt Creator配置
Qt Creator是一个强大的跨平台IDE，集编辑，编译，运行，调试功能与一体。其代码编辑器支持关键字高亮，上下文信息提示，自动完成，智能重命名等高级功能。IDE中集成的可视化界面编辑器，可以让用户以所见即所得的方式进行图形程序的设计。其编译，运行无需敲入命令，直接点击按钮或使用快捷键即可完成。同时还支持图形化的调试方式，可以以插入断点，单步运行，追踪变量，查看函数堆栈等方式进行应用程序的调试开发。
通过如下命令启动QtCreator：$ qtcreator
Qt Creator主界面如图15所示。
图15 Qt Creator主界面
如果已安装了桌面版的Qt和嵌入式版的Qt，则需要设置Qt Creator所使用的Qt版本。点击菜单栏的Tools→Options，将得到如图16所示的界面。
. c0 `! H4 N3 S 图16 Qt工具-选项界面
点击左边的Build & Run，在右边弹出的Build & Run中，选择Qt Version，手动加入Qt的版本，以加入桌面版的Qt为例：
$ ^$ m+ l0 A8 [% w. ~1 F, J点击Add，弹出选择qmake可执行文件的窗口,然后选择路径/usr/bin/qmake-qt4的执行文件如图17所示，点击打开。
( G- _6 o" B& n8 I" z 图17 选择qmake可执行文件窗口
1 {/ X/ u" f$ U# t; v0 u1 \* g3 K在Version Name一栏输入版本名字，如Destop-qt4，点击Apply如下图18所示。
  _* s0 _  c  M/ `0 T 图18 添加Qt版本的窗口
4 e7 q! t2 S/ ~4 O- b然后选择Qt Version旁边的Kits，点击Add，输入Name，选择编译器、Qt-version等，配置选项如图19所示，点击Apply，然后点击OK即可。
图19 配置编译工具(Kits)窗口
( E/ ?; j5 S$ a' jQt Creator使用范例
* ?% x6 f  z. T4 q下面将通过一个简单的例程，说明一下如何使用Qt Creator进行程序的开发。
单击Qt Creator主界面的New Project，得到如下图20所示的界面。
8 F- P& c' d2 \2 q 图20 创建新项目界面
选择Qt Widgets Application，点击Choose，进入如图21的界面，设置项目名称和路径。接下来可以一路点击下一步，选择默认的方式，直到出现如图22的界面。
# m2 ^, H, C5 l$ v6 k: D, G+ f& I: q 图21 项目名称和路径的界面
% K: ]/ K: J, @2 u/ _4 f6 J
图22 项目管理界面
. j+ G0 t$ [+ x, @) M单击Finish，将进入如图23界面，Qt Creator已经自动生成一个最基本Qt程序所需的代码，用户可以在此基础上做进一步的开发。
) @! P; z0 A9 K) W8 a8 ?/ s+ z 图23 mainwindow.cpp界面
单击侧边栏的Forms中的mainwindow.ui可以启动可视化编辑器，如图24所示。
" s" s& x% f/ }& ^5 b, T3 d$ Q' K 图24 可视化界面编辑器
在图25的界面中，通过拖动左边控件侧边栏中的控件到程序主界面中，以所见即所得的方式设计程序界面。下面拖动一个QLabel控件到程序主页面上，点击QLabel控件，在右下角栏目中设置QLabel上文字为“Hello Qt！”。如图14.25所示。
$ s$ l  u. J( C* v4 P, T+ ] 图25 hello Qt程序界面
接下来通过左边侧边栏上的Debug，选择前面所设置桌面版本的Qt的Debug。如图26所示。
8 Q, Q* d1 J+ s% g% j 图26 选择Qt版本
最后，点击“▶”按钮对程序进行编译链接运行。如编译无误，将自动启动应用程序。界面如图14.27所示。
图27 hello Qt界面
9 u3 \( N4 `' u  d3 q& M( q; X06在嵌入式环境运行Qt程序
* Z8 H, b. I$ @; j) `! B5 a将程序编译成嵌入式版本
由于Qt具有良好的可移植性，在桌面版本中编译运行成功的应用程序，一般只需要用交叉编译工具的qmake重新编译，即可在目标板上运行。执行嵌入式的qmake（别名qmake-arm），重新交叉编译，便可获得嵌入式版本的Qt程序。如图28所示：

图28 移植hello Qt
' O- \# t& N0 @1 k9 P在目标板上运行程序
+ a9 i; s6 p, ~7 D建议通过nfs挂载PC主机上的目录至目标板上，便于调试开发。具体的nfs挂载方法请查阅6.4章节的内容。下面假设已经将PC上hello目录挂载在目标板上，接下来的操作都在目标板上进行。
4 w# u  `' n. s在启动hello程序前，需要先设定Qt的鼠标设备，进行如下命令：
( O: Q7 b. g* Z: F# H. f( U

---

# export QWS_MOUSE_PROTO=tslib:/dev/input/event0

---

上述命令中tslib指定了触摸屏对应的设备文件，这里指定为/dev/input/event0。但是其值并不固定，需要根据实际情况确定。正常情况下，所需的设备文件位于/dev/input目录下。
在命令行下输入如下命令：

---

# cat /dev/input/event0 | hexdump

---

点击触摸屏，如果有数据输出，那么对应的设备文件就是所需要的设备文件。
成功设定鼠标设备后，可以执行如下命令启动Qt程序。

---

# ./hello -qws

---

-qws指明这个Qt程序同时作为一个窗口服务器运行，在目标板上启动的第一个Qt程序应使用此参数启动。
/ M5 k' m7 q8 e+ ~+ Q在本例中，程序启动成功后，界面如图29所示：
+ F5 t; g; i" O
图29 hello程序运行界面
Qt帮助文档
由于Qt中包含了许多类和函数，开发人员不可能每一个类都熟记。所以可以使用参考文档查阅每个类和函数的使用方法。
; w# h( K' s  n% v! h可以使用Qt的帮助浏览器Qt Assistant，它具有强大的查询和索引功能，自身也是由Qt程序构成的。
在Linux命令行终端下，输入如下命令：
3 o% B& e$ _; z

---

$ assitant-qt4

---

即会弹出如图30所示的界面。

图30 assistant界面

8 a/ [) ~0 A1 ^4 z  H$ e4 t07Qt编程实战（上）
接下来将要介绍一些功能部件的简单使用方法，然后在最后通过一个经典的小游戏—贪食蛇示例来说明功能部件之间的组合使用。
这些例子都是手动敲代码，然后用桌面版的qmake（即我们设置别名的qmake-qt4指令）进行编译，而不是借助IDE来进行编程。因为这样可以让读者更加明白代码的运作原理。
4 t1 d' v; a7 X# B1 按钮本例子由一个按钮构成，这个应用程序的源代码与Hello程序的源代码非常相似，quitButton源代码如程序清单2所示。
程序清单2 quitButon.cpp源码
: T& D9 U* Q" v; C

1. 1 /* quitButton.cpp */
   7 Z1 ~7 ?, ^3 k7 S1 ^* d7 B7 I- ]2 {
2. 2 #include <QApplication> /* 包含类QApplication的定义 */
   4 ?2 @" W* i9 v5 L
3. 3 #include <QPushButton> /* 包含类QPushButton的定义 */
   & }4 w9 h- I4 ^% r
4. 4 int main(int argc, char *argv[])
   
5. 5 {
   9 Q1 k8 N+ E0 }
6. 6 QApplication app(argc, argv);
   ( m- Q7 ^1 ?  V
7. 7 QPushButton *button = new QPushButton("Quit") ; /*创建一个显示为Quit的按钮窗口部件*/
   
8. 8 button->show(); /* 使按钮可见 */
   
9. 9 return app.exec();
   
10. 10 }

复制代码

第5行创建了一个QApplication对象，用来管理整个应用程序所用到的资源。Qt支持一些命令行参数，所以这个QApplication构造函数需要两个参数，分别是argc和argv。
; j* x: a2 `4 R- d/ a  ^* h第8行将应用程序的控制权转移给Qt。此时，程序将进入事件循环状态，程序会等候用户的动作，例如鼠标单击和按键等操作。
新建一个quitButton目录，然后在该目录下添加quitButton.cpp，内容如上述程序清单1.2所示，然后在该目录下执行如下命令进行编译和执行。
3 k8 a; u/ k3 f

1. $ qmake-qt4 –project
   
2. $ qmake-qt4
   ; |- Y# i  R0 S' ]4 p3 q5 e
3. $ make
   . o/ e" t& K; I# S3 O: H

复制代码

% {( X5 E+ `/ r' i, y" [
! H5 m, F, |9 F5 r% ZPC上执行过程如图31所示。
8 S* o6 k2 Q( R, A, W 图31 quitButton编译和执行过程
由于没有为按钮按下的事件提供任何处理。所以无法按下“按钮”之后退出窗口。这个功能可以通过后面将要介绍的信号与槽的机制来实现。
2 标签和文本框
这一节将简单说明一下窗口加入标签和文本框的使用方法。与按钮源代码差不多，只是调用的类不同而已。
. i9 ]: O6 t; f8 B8 Y  w( x本例由三个窗口部件组成：QLabel，QLineEdit和QWidget。QWidget是该应用程序的主窗口。QLabel和QLineEdit会显示在QWidget中，它们都是QWidget窗口部件的子对象。另外，为了将窗口部件摆放整齐，调用了Qt的布局管理器。下一小节将具体介绍布局管理器的使用方法。
% z& U8 _0 ?% }8 P. |% D程序清单3 account.cpp源代码

1. 1 /* account.cpp */
   + l" Z5 J( ^& e  n# G0 {0 c
2. 2 #include <QApplication>
   # o) A( |+ X5 U/ O
3. 3 #include <QLabel>
   " Q7 _, ~3 P7 F% s9 N  L. e% C  ~
4. 4 #include <QLineEdit>
   
5. 5 #include <QHBoxLayout>
   ! {/ T- i3 }& f, u
6. 6
   % }8 o- l4 S% C5 Y8 x; k' @
7. 7 intmain(int argc, char *argv[])
   + G1 p; C  X4 m! @5 X4 ~/ T
8. 8 {
   % `8 b5 j6 x; P+ l3 n* v: `
9. 9 QApplication app(argc, argv);
   # B* X' Y& I% V& u1 s: T! l2 A
10. 10 QWidget *window = new QWidget; /* 创建Qwidget对象，作为主窗口*/
    1 L; F5 C' _0 Y2 K1 @' q, u
11. 11 window->setWindowTitle("Enter Your account"); /*设置显示在窗口标题栏上的文字*/
    
12. 12
    1 J. g4 B: p& ?: J) C% Q
13. 13 QLabel *accountLabel = new QLabel("Account: ", window); /*创建标签对象，并显示为Accoutn */
    
14. 14 QLineEdit *accountEdit = new QLineEdit(window); /* 创建文本框对象 */
    
15. 15
    
16. 16 QHBoxLayout *layout = new QHBoxLayout; /* 创建水平布局管理器 */
    6 o6 v% w9 X& U6 U) m$ c! H) q
17. 17 layout->addWidget(accountLabel);
    9 q$ b3 D! c1 _! Q+ i  M
18. 18 layout->addWidget(accountEdit);
    , B5 q+ ?# b: i' [
19. 19
    + ^8 k5 F9 ~$ M8 z
20. 20 window->setLayout(layout); /* window窗口上安装该布局管理*/
    . J9 I- W  @2 R4 P6 _2 f
21. 21 window->show();
      c1 b* Z! H: s' y9 v0 o
22. 22 return app.exec();
    
23. 23 }
    

复制代码

第13和14行把window对象传递给QLabel和QLineEdit的构造函数，说明这两个窗口部件为window的子对象。
第16到18行使用了一个水平布局管理器对标签和文本框进行布局处理。下一小节将具体介绍布局管理器。
建立一个新目录为account，在该目录下添加account.cpp源代码文件，然后调用如下命令进行编译，然后执行。

1. $ qmake-qt4 –project
   
2. $ qmake-qt4
   
3. $ make

复制代码

9 p+ t4 }! y" w# [. T" ?" sPC上执行过程如图32所示。

图32 account编译和运行界面
/ Z: k7 x- c, @7 d, d3 布局管理器
( @6 p( Q$ i9 ]" y, G9 B* ~/ s布局管理器是一个能够对窗口部件的尺寸大小和位置进行设置的对象。Qt有三个主要的布局管理器类：
- N6 E$ U) A/ @  I

1、QHBoxLayout：在水平方向上排列窗口部件，从左到右；
# Q+ i8 I7 U, k; x6 j2、QVBoxLayout：在垂直方向上排列窗口部件，从上到下；
5 [* |  |3 x0 ^( F: u5 _7 _3、QGridLayout：把各个窗口部件排列在一个网格中。

下面编写一个范例来展示一下布局管理器的灵活用途。本例子将把前两小节的功能部件结合起来使用。
3 u) b; r" S2 Y7 i3 B程序清单4 layout.cpp
) @3 R+ X* n( n

1. 1 /* layout.cpp */
   % }% }% |7 \/ X( g; r
2. 2 #include <QtGui>
   
3. 3 #include <QApplication>
   
4. 4
   . [1 \2 }, u5 t# h, D
5. 5 int main(int argc, char *argv[])
   : n5 u! n5 r* t$ W" w( J  u& x
6. 6 {
   
7. 7 QApplication app(argc, argv);
   ! z2 {; D' m. y5 L2 s# S
8. 8 QWidget *window = new QWidget;
   
9. 9 window->setWindowTitle("Layout");
   
10. 10
    
11. 11 QLabel *accountLabel = new QLabel("Account: ");
    ' Q7 R/ E, {( m/ I' G
12. 12 QLabel *pwLabel = new QLabel("Password: ");
    6 r& A) I* d! d' ^. s4 m5 `
13. 13 QLineEdit *accountEdit = new QLineEdit;
    
14. 14 QLineEdit *pwEdit = new QLineEdit;
    2 M( Z* x1 g2 H/ A8 b8 y
15. 15 QPushButton *quitButton = new QPushButton("Quit");
    
16. 16 QPushButton *nextButton = new QPushButton("Next");
    . D' S: d# Y) H: n( R) `
17. 17
    
18. 18 QHBoxLayout *topLayout = new QHBoxLayout; /* 创建一个水平布局管理器 */
    
19. 19 topLayout->addWidget(accountLabel); /* 从左到右放置窗口部件 */
    # G& R4 T" N& ~7 ^/ d* B. d% r3 w% a
20. 20 topLayout->addWidget(accountEdit);
    6 b; U& j" E6 k; E1 `
21. 21
    ; G' {! C$ Q' @. T' D% U# k
22. 22 QHBoxLayout *downLayout = new QHBoxLayout;
    
23. 23 downLayout->addWidget(pwLabel);
    
24. 24 downLayout->addWidget(pwEdit);
    
25. 25
    ; s. T: Y! l0 P8 \0 e" T
26. 26 QVBoxLayout *leftLayout = new QVBoxLayout; /* 创建一个垂直布局管理器 */
    ; c& e5 ]% L" a" I4 A
27. 27 leftLayout->addLayout(topLayout); /* 内嵌布局管理器 */
    
28. 28 leftLayout->addLayout(downLayout);
    6 s  P+ l) `2 }" |4 H
29. 29 leftLayout->addStretch(); /* 添加分隔符 */
    6 b" D% b; ]. ?
30. 30
    0 |  @9 R+ Q, C  a9 a- o
31. 31 QVBoxLayout *rightLayout = new QVBoxLayout; /* 创建一个垂直布局管理器 */
    
32. 32 rightLayout->addWidget(quitButton); /* 从上到下放置窗口部件 */
    
33. 33 rightLayout->addWidget(nextButton);
    3 K* O' n. t  b4 r
34. 34 rightLayout->addStretch();
    6 M+ i/ p, }6 O0 @6 s' U0 i
35. 35
    - E5 ~. P: I2 ^
36. 36 QHBoxLayout *mainLayout = new QHBoxLayout;
    
37. 37 mainLayout->addLayout(leftLayout);
    7 A) D: U4 {5 b" A3 X- p, O
38. 38 mainLayout->addLayout(rightLayout);
    ) X' O3 }0 j5 ?& a: E6 c8 ~2 }; `$ @% F2 Z
39. 39
    / f2 O0 v, a) _( a! `3 c  ?
40. 40 QObject::connect(quitButton, SIGNAL(clicked()), &app, SLOT(quit()));
    
41. 41 window->setLayout(mainLayout);
    
42. 42 window->show();
    ; O7 K9 Y  Y- @
43. 43 return app.exec();
    
44. 44 }
    * O4 E! u( u3 r$ A

复制代码

& p! ]2 [. A  o+ B) ^* {1 L
0 Q7 h9 E, I) T8 w第29行和34行添加了分隔符（或者称为伸展器），用它来占据余下的空白区域，这样可以确保如果用户将窗口高度变高，可以确保这些按钮和标签部件可以完全占用它们所在布局的上部空间，不会跟随窗口高度变高而变高。
5 A* g4 L5 u; r5 m1 a# Y使用布局管理器摆放这些子窗口部件，布局中既可以包含多个窗口部件，也可以包含其他子布局。通过QHBoxLayout、QVBoxLayout和QGridLayout这三个布局的不同嵌套组合，就可能构建出相当复杂的布局层次。如下图33所示：
( r/ _! s; o$ _
图33 Layout层次图
5 j! n3 X' N9 |+ ?, W3 m  I当将子布局对象添加到父布局对象中时（第27、28、37和38行），子布局对象里面的窗口部件就会自动重定义自己的父对象。换言之，当将主布局装到window对象中时（第42行）时，它就会成为window指向的对象的子对象了。于是它的所有子窗口部件都会重定义自己的父对象，从而变成window的子对象。
建立一个新目录为layout，在该目录下添加layout.cpp源代码文件，然后调用如下命令进行编译和执行。

1. $ qmake-qt4 –project
   : @. w. M+ W, d7 e: m8 G
2. $ qmake-qt4
   
3. $ make

复制代码

* P( M: Y; |* p  j
. g' T3 }; M5 w0 Q; v  w* X4 w
PC上的执行过程如图34所示。

图34 layout编译和执行过程
; ~9 T' \: w7 H! c: K) v/ N9 q6 N08Qt编程实战（中）
. H+ U6 H0 ^" i7 L- [% d信号与槽
# `% K6 A6 g. ]! z; w
信号与槽的机制是Qt编程的一个重要部分。这个机制可以在对象之间彼此并不了解的情况下，将它们的行为联系起来。它跟UNIX的信号不是同一个概念，不可相互混淆。
3 o3 _# u& H1 O9 o, U2 {槽和普通的C++成员函数很像，它们可以是虚函数（virtual），也可被重载（overload），可以是公有的（public），保护的（protected），它们可以像任何c++成员函数一样被调用，可以传递任何类型的参数。不同在于一个槽函数能和一个信号相连接，只要信号发出了，这个槽函数就会自动被调用。信号和槽函数间的链接通过connect实现。Connect函数语法如下：
" D( H5 |3 ], x# g3 B

connect(sender, SIGNAL(signal), receiver, SLOT(slot));

' ^+ v6 M7 U% F, \# S  Nsender和receive是QObject对象（QObject是所有Qt对象的基类）指针，signal和slot是不带参数的函数原型。SIGNAL宏和SLOT宏的作用是把它们转换成字符串。
虽然在之前的小节中，已经使用了信号和槽，但是在实际应用中还需要考虑一些规则：
& |8 h: @$ p% m& R+ X) s# C# o1）一个信号可以连接到多个槽

connect(slider, SIGNAL(valueChanged(int)), spinBox, SLOT(setValue(int)));
. \% `* t4 Z( O, wconnect(slider, SIGNAL(valueChanged(int)), this, SLOT(updateStatusBar(int)));
9 l; }4 x( X+ Q, ]* G

1 o+ x& e% I9 e将滑块的值改变信号，连接微调框的设置值大小的槽和当前对象的更新状态栏的槽。
当信号发出后，槽函数都会被调用，但是调用的顺序不确定，随机的。
" s! }8 \; ~' c3 f; g  C2）多个信号可以连接到一个槽

connect(lcd, SIGNAL(over()), this, SLOT(handleError());
; L* C5 d# H+ {4 S% @) n! c: s, bconnect(calculator, SIGNAL(divisionError()), this, SLOT(handleError()));
! _; l  P$ X7 Q+ A3 J

将lcd的over()信号和计算器的divisionError()信号与当前对象的handleError()的槽连接。
任何一个信号发出，槽函数都会被执行。
4 E5 ^8 o2 {0 Y1 p8 M' j3）一个信号可以和另一个信号相连
7 H5 D6 |+ N& F$ b  S

connect(lineEdit, SIGNAL(textChanged(Qstring &)), this, SIGNAL(update(Qstring &)));

将文本框的文本改变信号与当前对象的更新信号相连。
6 x$ Y5 v+ @$ Z) B+ h  \( [# @: i第一个信号发出后，第二个信号也同时发送，除此之外，信号与信号连接上，和信号和槽连接相同。
4）连接可以被删除
9 o0 s! g6 C8 q9 }: l; q0 D

disconnect(lcd, SIGNAL(over()), this, SLOT(handleError()));

8 \& ?+ U* U2 ^0 Y# d* c这个函数很少使用，一个对象删除后，Qt自动删除与这个对象相关的所有连接。
& T0 ^, A3 C/ |0 D  e8 P
9 F0 d. v$ h$ @6 {7 W注：信号和槽函数必须有着相同的参数类型，这样信号和槽函数才能成功连接。
如果信号里的参数个数多余槽函数的参数，多余的参数被忽略：
- b5 Q  f7 e0 {6 h

connect(ftp, SIGNAL(rawReply(int, const Qstring &)), this, SLOT(checkError(int)));

5 g  q8 h; J: Y$ _; I+ y+ N如果参数类型不匹配，或者信号和槽不存在，则当应用程序使用debug模式构建后，Qt会在运行期间发出警告。如果信号和槽连接时包含了参数的名字，Qt将会给出警告。
接下来，可以利用信号与槽将前面小节介绍的按钮部件提供退出功能，更新的quitButton.cpp源码如程序清单5所示。
# E8 o7 c5 ~' D3 L' W程序清单5更新的quitButton.cpp源码

1. 1 /* quitButton.cpp */
   
2. 2 #include <QApplication>
   % ~$ u: X$ M3 m, q6 x
3. 3 #include <QPushButton>
   ; \( N' O, V% L' t% q' K
4. 4 int main(int argc, char *argv[])
   
5. 5 {
   2 P% e. X' `6 F) {3 d) d2 ^
6. 6 QApplication app(argc, argv);
   
7. 7 QPushButton *button = new QPushButton("Quit");
   
8. 8 QObject::connect(button, SIGNAL(clicked()),&app, SLOT(quit()));
   , i$ S/ @6 j6 b; A- ^& G, a
9. 9 button->show();
   9 L+ p2 }& t4 b8 n6 Q% }
10. 10 return app.exec();
    
11. 11 }
    

复制代码

! A5 D5 Q7 F4 ]' e9 g1 ?! Z/ ?其实就只是增加了第7行代码，将这个按钮的clicked()信号与QApplication对象的quit()槽连接起来。
再介绍一个简单的示例，说明如何利用信号与槽的机制来同步窗口部件，可以通过操作微调框（spin box）或者滑块（slider）来完成数字输入，源码如程序清单6所示。
程序清单6number.cpp源码
* }; I, W# f2 }; V" Q

1. 1 /* number.cpp */
   
2. 2 #include <QApplication>
   
3. 3 #include <QHBoxLayout>
   
4. 4 #include <QSlider>
   9 c7 w1 T2 d  |8 o# H
5. 5 #include <QSpinBox>
   ( G/ r' m# ]/ |7 }" S( \- q
6. 6
   
7. 7 int main(int argc, char *argv[])
   
8. 8 {
   $ E0 U0 q, Y5 v0 L# ^
9. 9 QApplication app(argc, argv);
   
10. 10 QWidget *window = new QWidget;
    ) v8 f# w( h+ T& ~; S- U
11. 11 window->setWindowTitle("Enter Number");
    4 ]- W* y/ p; L
12. 12
    
13. 13 QSpinBox *spinBox = new QSpinBox; /* 创建微调框 */
    
14. 14 QSlider *slider = new QSlider(Qt::Horizontal); /* 创建滑块 */
    
15. 15 spinBox->setRange(0, 100); /* 设置微调框有效范围 */
    
16. 16 slider->setRange(0, 100); /* 设置滑块有效范围 */
    
17. 17
    $ r. O+ F8 F1 x" q3 a
18. 18 QObject::connect(spinBox, SIGNAL(valueChanged(int)),slider, SLOT(setValue(int)));
    9 y( l4 v# j+ P
19. 19 QObject::connect(slider, SIGNAL(valueChanged(int)),spinBox, SLOT(setValue(int)));
    9 E4 A) U! ]" |- i0 f* g
20. 20 spinBox->setValue(25); /* 设置微调框的值为25 */
    
21. 21
    
22. 22 QHBoxLayout *layout = new QHBoxLayout; /* 创建水平布局管理器 */
    
23. 23 layout->addWidget(spinBox); /* 从左到右放置部件 */
    
24. 24 layout->addWidget(slider);
    
25. 25 window->setLayout(layout);
    
26. 26
    
27. 27 window->show();
    
28. 28
    , @8 G1 s1 C, T$ b1 T
29. 29 return app.exec();
    ( @8 |6 z/ \- D+ c2 T
30. 30 }

复制代码

第18至19行调用了两次QObject::connect函数，这是为了确保能够让微调框和滑块同步，以便它们两个总是可以显示相同的数值。只要有一个窗口部件的值改变了，就会发射它的valueChanged(int)信号，而另一个窗口部件就会用这个新值调用它的setValue(int)槽。
建立一个新目录为number，在该目录下添加number.cpp源代码文件，然后调用qmake命令进行编译，然后执行查看效果，命令如下：
8 e; o' m8 e8 Y. @% o) ~9 _

1. $ qmake-qt4–project
   # U. K' C! B1 x( b. T
2. $ qmake-qt4
   , t: h( p* Q, i
3. $ make

复制代码

$ y, I! \! \+ l* B9 A# H
4 y7 [4 L: r! Q' w8 C7 R2 h本机执行过程如图35所示。
" b: M6 t1 c5 V' j: k
图35 number编译和执行过程
; a' Z4 ~# ^" Q1 m主窗口（MainWindow）
! _" |$ f7 T& U# [" v8 Q应用程序的主窗口提供了用于构建应用程序用户界面的框架，可以通过子类化QMainWindow创建。
一个主窗口主要由菜单栏，工具栏，状态栏、停靠窗口和中央窗口部件组成，如图36所示。
9 W( Q1 F7 X6 R: T) u5 V& m& s
图36主窗口示意图
最上面是窗口标题栏，用于显示标题和一些按钮，如最小化、最大化、关闭按钮等。接下来是菜单栏，显示菜单，然后是工具栏，用于显示工具条，由于Qt的窗口支持多个工具条的显示，所以你可以在四周显示或者并排显示工具条。工具条的下面是停靠窗口，所谓停靠窗口就像画图的工具箱一样，可以在中央窗口的四周显示。再下来是状态栏，显示一些状态，比如鼠标当前位置等。中间最大的中央窗口部件是主要的工作区。
8 e! b% p! g' F: T6 m2 b一个最基本的主窗口可以由以下三个文件组成：main.cpp、mainwindow.h和mainwindow.cpp。
0 g* v4 f- N( l* Nmainwindow.h的源码如程序清单7所示。
程序清单7mainwindow.h源代码
) `2 I# ^* h2 Q$ L8 g' w. p5 D$ |

1. 1 /* mainwindow.h */
   0 \) U! b# @: f. v7 ~6 S8 f5 W
2. 2 #ifndef MAINWINDOW_H
   1 r1 m% x7 l& \: X9 M/ Q0 f
3. 3 #define MAINWINDOW_H
   
4. 4
   
5. 5 #include <QMainWindow> /* 包含对QMainWindow的定义 */
   
6. 6
   
7. 7 class MainWindow : public QMainWindow /* 声明MainWindow为QMainWindow的子类*/
   
8. 8 {
   4 ~, V1 O: N4 h; d0 m
9. 9 Q_OBJECT;
   7 Z8 }/ p; K* e$ q9 D' q( a
10. 10 public:
      U  B) O5 ~3 x: x1 x5 }
11. 11 MainWindow(void);
    1 }! V( s1 m9 D& D* y
12. 12 ~MainWindow(void);
    1 E4 H9 E' Q$ Z
13. 13 };
    , y; n" r: T' T# x
14. 14
    
15. 15 #endif
    / C; q7 N3 `# S

复制代码

第2和3行能够防止对该头文件的多重包含。
; z# y3 @' T  t# O& Y# }" ^6 ?第9行对于所有定义了信号和槽的类，在类定义开始处的Q_OBJECT宏是必需的。
3 W% z* H5 B3 a6 @8 r
0 s4 g3 O- Q2 m3 r第11和12行声明类MainWindow的构造函数和析构函数。
接下来看一下mainwindow.cpp对类MainWindow的实现，源码如程序清单14.8所示。
. q; t. d2 Q4 \1 d4 K& D! b程序清单8mainwindow.cpp源码

1. 1 /* mainwindow.cpp */
   
2. 2
   
3. 3 #include "mainwindow.h" /* 包含mainwindow.h头文件 */
   5 j( T+ `5 b. }! O
4. 4
   1 X0 Z! z% p7 Q+ o, V* p
5. 5 MainWindow::MainWindow(void)
   
6. 6 {
   2 r& k0 b7 r5 R' `& J5 ~
7. 7 }
   
8. 8
   
9. 9 MainWindow::~MainWindow(void)
   
10. 10 {
    + \# W5 \/ l3 }  j' L- T4 k1 l# @: s/ o
11. 11 }

复制代码

* X, H0 d( R5 [9 v7 W

由于只是创建一个基本的主窗口，不包含其他窗口部件，所以，构造函数和析构函数都没有内容。下一小节将会在里面添加构造菜单栏和工具栏的实现。
最后，看一下main.cpp文件，源码如程序清单9所示。
程序清单9main.cpp源码

1. 
   2 b2 Q9 [; D, F. I3 e% K$ I
2. 1  /* main.cpp */23  #include <QApplication>4  #include "mainwindow.h"56  int main(int argc, char *argv[])7  {8    QApplication app(argc, argv);9    MainWindow main;            /* 创建自定义的MainWindow对象 */10    main.show();              /* 使对象显示 */11    return app.exec();12   }
   

复制代码

% A6 y5 ^; F9 p* G5 }6 f( _
- h+ Q* @# g3 M* u& d# @$ {( A: L4 T这就是一个最基本的主窗口的所需要的文件。
建立一个新目录为mainwindow，在该目录下添加mainwindow.h、mainwindow.cpp和main.cpp文件，然后调用qmake-qt4命令进行编译，然后执行查看效果，命令如下：
& B- @3 x) U  \1 M" b9 D: K. K

1. $ qmake-qt4 –project
   2 X' ?+ w! b1 u6 z! L
2. $ qmake-qt4
   
3. $ make
   

复制代码

) n4 g. F, e/ t2 h
PC上的运行效果如图37所示。
, V* t# z+ {! {" V4 |  l
2 |. o. Z7 f2 u+ |: b: T3 J图37 mainwindow运行界面
* @: A. S- w" F! o- w6 b. s4 r08Qt编程实战（下）
0 J4 C/ r! f6 C, ?7 n% z1 菜单栏、工具栏和状态栏
4 M: @- y& J& k6 y1 r$ [2 X
& e( ~# m/ |9 D* A5 L) D大多数图形用户界面都会提供菜单栏和工具栏，以便用户对那些常用的功能进行快速访问。
Qt通过“动作（Action）”的概念简化了有关菜单和工具栏的编程。一个动作（action）是一个可以添加到任意数量的菜单和工具栏上的项。创建菜单和工具栏主要包括以下步骤：
, t$ V( R& ^0 V* z' R4 M1 \1、创建并且设置动作；2、创建菜单并且把动作添加到菜单上；3、创建工具栏并且把动作添加到工具栏上。
& q$ M; @- ?1 Z& q0 L这一小节，将为上一节创建的主窗口添加菜单栏、工具栏和状态栏。
( {% l2 J/ d- I& w6 A& @更新的mainwindow.h源码如程序清单14.10所示。
+ H$ ]% H: I! r6 A' B程序清单14.10更新的mainwindow.h源码

1. 1 /* mainwindow.h */
   $ e0 u2 [$ f0 ^# D& V' ^( {9 I
2. 2 #ifndef MAINWINDOW_H
   
3. 3 #define MAINWINDOW_H
   
4. 4
   9 L* u. t7 m4 h/ U2 d3 o7 Z! V
5. 5 #include <QMainWindow> /* 包含对QMainWindow的定义 */
   
6. 6
   # ]9 I& b: {+ M7 I/ K/ z/ w
7. 7 class QAction;
   
8. 8 class QMenu;
   
9. 9 class QToolBar;
   
10. 10 class QLabel;
    
11. 11
    
12. 12 class MainWindow : public QMainWindow /* 声明MainWindow为QMainWindow的子类*/
    
13. 13 {
    
14. 14 Q_OBJECT;
    : X0 g' `: @6 m8 r5 \
15. 15 public:
    
16. 16 MainWindow(void);
    
17. 17 ~MainWindow(void);
    2 }8 C- |. S0 t- k2 @' i7 ~
18. 18
    
19. 19 private:
    
20. 20 QMenu *fileMenu; /* 文件菜单 */
    % ~6 ~. e) k% L2 z  S+ I6 A: S
21. 21 QMenu *helpMenu; /* 帮助菜单 */
    
22. 22
    / }! d. U: Y  m. d
23. 23 QToolBar *fileToolBar; /* 工具栏 */
    ( e. H# ^0 N6 P. K) T" _1 }& E
24. 24
    
25. 25 QAction *openAction; /* 打开动作 */
    % d; \# v7 }$ K
26. 26 QAction *closeAction; /* 关闭动作 */
    * O; S. {$ u0 T! {7 m% A  L$ G( @
27. 27 QAction *aboutAction; /* 关于动作 */
    
28. 28
    
29. 29 QLabel *statusLabel;
    
30. 30 };
    
31. 31
    
32. 32 #endif
    $ Z" j: L- Q1 \. a6 J

复制代码

, |' v1 e* B/ P/ f该头文件主要添加一些私有成员的声明，如第20到29行的私有成员变量。
对于这些私有变量，使用了它们的类前置声明（第7到10行）。这样就不用包含与这些类相关的头文件（如<QMenu>、<QLabel>等），可以使编译过程更快一些。
9 f& f4 _  U- j+ Y$ f接下来主要看一下更新的mainwindow.cpp源码，具体实现如程序清单14.11所示。
5 d! y  |0 Q+ q5 @6 h9 d" O% t程序清单14.11更新的mainwindow.cpp源代码

1. <section style="margin: 0px; padding: 0px; max-width: 100%; box-sizing: border-box !important; word-wrap: break-word !important; color: rgba(0, 0, 0, 0.498039); font-family: -apple-system-font, BlinkMacSystemFont, " !important;"="" break-word="" 1.75em;="" 1em;="" both;="" 0px;="" 2;="" normal;="" none;="" justify;="" 0.544px;="" 15px;="" sans-serif;="" arial,="" yahei",="" "microsoft="" ui",="" yahei="" gb",="" sans="" "hiragino="" sc",="" "pingfang="" neue",="" helvetica=""><div class="blockcode"><blockquote>1 /* mainwindow.cpp */
   " r! L' o; c) D# v- ~. v
2. 2
   + ^8 P# N; [* @' s4 C
3. 3 #include <QtGui>
   ) K$ F# L& T1 ~/ }
4. 4 #include "mainwindow.h"
   
5. 5
   * m" o, b" s) T  p! K( z. s
6. 6 MainWindow::MainWindow(void)
   
7. 7 {
   
8. 8 openAction = new QAction(tr("&Open"), this); /* 创建打开动作 */
   2 w6 P& ^2 {2 ^$ b! a" p, P  V
9. 9 openAction->setStatusTip(tr("Open the file")); /* 设置状态提示 */
   
10. 10
    
11. 11 closeAction = new QAction(tr("&Close"), this); /* 创建关闭动作 */
    ( L# _! v0 q; s
12. 12 closeAction->setStatusTip(tr("Close the file")); /* 设置状态提示 */
    - s3 ^2 z  \7 M5 |( H: |- U
13. 13
    
14. 14 aboutAction = new QAction(tr("&About"), this); /* 创建关于动作 */
    
15. 15 aboutAction->setStatusTip(tr("About")); /* 设置状态提示 */
    
16. 16
    
17. 17 fileMenu = menuBar()->addMenu(tr("&File")); /* 创建file菜单 */
    
18. 18 fileMenu->addAction(openAction);
    
19. 19 fileMenu->addAction(closeAction);
    + q/ c6 s& r9 }6 `6 \; a
20. 20
    
21. 21 helpMenu = menuBar()->addMenu(tr("&Help")); /* 创建help菜单 */
    
22. 22 helpMenu->addAction(aboutAction);
    ; b6 ]  x1 i/ E! u: j: p/ g7 ^$ V
23. 23
    2 p+ M/ b/ w' y6 u8 Q
24. 24 fileToolBar = addToolBar(tr("&File")); /* 创建File工具栏 */
    ; p$ j' [. _* K. R! z& Q
25. 25 fileToolBar->addAction(openAction); /* 添加打开动作到File工具栏*/
    ; H; j! k; b! w0 Z4 f( x' W/ I/ W
26. 26 fileToolBar->addAction(closeAction); /* 添加关闭动作到工具栏 */
    ! G+ W3 }2 N. G4 }7 c
27. 27 fileToolBar->addAction(aboutAction); /* 添加关于动作到工具栏 */
    
28. 28
    
29. 29 statusLabel = new QLabel;
    1 S( i7 H# g+ ]/ b/ v
30. 30 statusLabel->setMinimumSize(statusLabel->sizeHint());
    ) A- Z: g. A2 _) K
31. 31 statusLabel->setAlignment(Qt::AlignHCenter); /* 设置居中 */
    1 H" o! h7 `! l6 }: w' Y9 h* Z- [
32. 32
    
33. 33 statusBar()->addWidget(statusLabel); /* 添加状态标签到状态栏 */
    ; u1 }* M  \8 Q% W5 G2 n! \
34. 34 }
    
35. 35
    
36. 36 MainWindow::~MainWindow(void)
    
37. 37 {
    
38. 38 }
    

复制代码

第8至15分别创建不同的项，在字符串周围的tr函数调用是把它们翻译成其他语言的标记。每个QObject对象以及包含有Q_OBJECT宏的子类中都有这个函数的声明。尽管应用程序并没有要翻译成其他语言的打算，但是在用户可见的字符串周围使用tr()是一个很不错的习惯。
在这些字符串中，使用了“&”来表示快捷键，用户可在支持快捷键的平台下通过按快捷键激活，如本例的按下Alt + O激活Open动作。
+ A& b% C# Q, c2 L4 V在Qt中，菜单都是QMenu的实例。QmainWindow::menuBar函数返回一个指向QMenuBar的指针，菜单栏会在第一次调用menuBar函数的时候就创建出来。第17至19行创建了file菜单后，把Open和Close动作添加进去。通过类似的方法创建help菜单。
创建工具栏与创建菜单的过程很相似，第24至27行创建了file工具栏，添加了Open、Close和About的动作。
状态栏位于主窗口的最下方，用于显示状态提示消息。QMainWindow::statusBar函数返回一个指向状态栏的指针，第一次调用statusBar函数的时候会创建状态栏。状态栏指示器是一些简单的QLabel。
main.cpp文件不用改变，重新调用qmake-qt4命令进行编译，然后执行查看效果，命令如下：
4 _& G0 T0 E. _/ e" h

1. $ qmake-qt4 –project
   
2. $ qmake-qt4
   & q- g9 {3 o" A) X! X
3. $ make

复制代码

PC上的运行效果如图38所示。

4 H7 `: O1 \8 A' N6 d2 c图38更新的mainwindow界面
& T# x+ [+ e7 e8 E. |2 事件
" k: U# f( n" F% V事件（event）是由窗口系统或者Qt自身产生的，用于响应所发生的各类事情。当用户按下或者松开键盘或者鼠标上的按键时，就会产生一个键盘或者鼠标事件。当用户改变窗口的大小的时候也会产生一个绘制窗口的事件。刚才谈到的事件都是对用户的操作做出响应而产生的，还有一些事件是系统独立产生的，如定时器事件。
由于有信号与槽的机制，一般不需要考虑事件，在发生某些重要的事情时，Qt窗口部件都会发射信号。但是当需要编写自定义的窗口部件，或者希望改变已经存在的Qt窗口部件的行为，事件就变得十分有用。
不应该把“事件”和“信号”这两个概念混淆。事件关注的是窗口部件本身的实现，而信号关注的是窗口部件的使用。例如，当使用QPushButton时，用户更多关注该窗口部件是否有被人点击使用，即对它的clicked信号更为关注。而很少关心发射该信号的底层鼠标或者键盘事件。除非是要自定义一个类似QPushButton的类（窗口部件本身），就需要编写一定的处理鼠标和键盘事件的代码。
所有组件的父类QWidget定义了很多事件处理函数，如keyPressEvent函数、keyReleaseEvent函数、muuseDoubleClickEvent函数、mouseMoveEvent函数、mousePressEvent函数和mouseRelease函数等。
* ^0 ]6 W  }5 X6 Q& e' o+ i. w0 \下面通过自定义一个标签的子类，当用户点击鼠标、移动鼠标和释放鼠标后，在该窗口部件中显示鼠标当前的坐标。该实例由三个文件组成：main.cpp、coordinate_label.h和coordinate_label.cpp。
coordinate_label.h源码如程序清单12所示。
* o% P5 {6 m5 y* {" }% K6 A程序清单12 coordinate_label.h源码
, F0 A  s$ i( o2 i

1. 1 /* coordinate_label.h */
   
2. 2
   9 ]7 x. Q0 D: F# x) }7 I2 N
3. 3 #ifndef COORDINATE_LABEL_H
   ( s2 q% |# g# B6 w0 e( U
4. 4 #define COORDINATE_LABEL_H
   . {: N9 k+ t$ i( {
5. 5
   
6. 6 #include <QLabel>
   1 b$ e, G3 `- A6 x; b' ~: G
7. 7
   ; }2 s0 [6 ]  L
8. 8 class QMouseEvent;
   5 z8 t! G6 U0 Z
9. 9
   ) ]) m( F" L  \. E4 Q6 I
10. 10 class CoordinateLabel : public QLabel /* 自定义QLabel的子类 */
    ( t' B" O1 Y* ^3 r# F- b- D$ p
11. 11 {
    
12. 12 protected:
    
13. 13void mousePressEvent(QMouseEvent *event); /* 定义鼠标按下事件 */
    - R3 N0 C& }7 ^* |  y$ R
14. 14void mouseMoveEvent(QMouseEvent *event); /* 定义鼠标移动事件 */
    + ?+ C/ ~. z: p6 l( y. [
15. 15void mouseReleaseEvent(QMouseEvent *event); /* 定义鼠标释放事件 */
    
16. 16 };
    
17. 17
    & h* e: p: j3 o: |( _  Z
18. 18 #endif

复制代码

, u8 {" b# S3 G
第13至15行声明需要重定义的事件处理函数。具体代码实现在coordinate_label.cpp文件中，源码如程序清单13所示。
5 {# S. y) o" r1 m程序清单13 coordinate_label.cpp源码
# L/ k2 Z+ O4 Q0 U% |

1. 1 /* coordinate_label.cpp */
   " o7 b% I+ y* |8 X% S0 Z
2. 2
   3 j+ G& x- `2 i( f* l& [
3. 3 #include <QMouseEvent>
   ) @$ |8 f( n) }: u- t
4. 4 #include "coordinate_label.h"
   
5. 5
   
6. 6 void CoordinateLabel::mousePressEvent(QMouseEvent *event)
   # l+ N5 v  S! X- I
7. 7 {
   4 V% v' f( [5 ^; y
8. 8 this->setText(QString("Mouse Press at:[%1, %2]")
   
9. 9 .arg(event->x())
   " J5 Y  I/ S- D+ T- `
10. 10 .arg(event->y()));
    
11. 11 }
    
12. 12
    * J( U+ H5 S' u9 V, A
13. 13 void CoordinateLabel::mouseMoveEvent(QMouseEvent *event)
    ! O+ e( Z4 ^% Q* j" h# J  Y
14. 14 {
    ! l5 p/ m" R. Q1 `* {8 z
15. 15 this->setText(QString("Mouse Move at:[%1, %2]")
    ; o7 C9 a, p) m: `9 K( ~
16. 16 .arg(event->x())
    
17. 17 .arg(event->y()));
    
18. 18 }
    
19. 19
    
20. 20 void CoordinateLabel::mouseReleaseEvent(QMouseEvent *event)
    
21. 21 {
    
22. 22 this->setText(QString("Mouse Release at:[%1, %2]")
    
23. 23 .arg (event->x())
    % }2 \$ J6 u) k  I$ p
24. 24 .arg(event->y()));
    
25. 25 }

复制代码

类QString的具体用法可以查阅帮助文档，在本例中，将自定义的QLabel的子类CoordinateLabel，设置其文本显示为当前鼠标事件的x轴与y轴。
" Y+ {6 r: `* D  R  P- Omain.cpp的源码如程序清单14所示。
5 K1 y( Z; I& T% d程序清单14main.cpp源码
  K% `! |: c; E

1. 1 /* main.cpp */
   
2. 2
   
3. 3 #include <QApplication>
   
4. 4 #include "coordinate_label.h"
   
5. 5
   
6. 6 int main(int argc, char *argv[])
   
7. 7 {
   
8. 8 QApplication app(argc, argv);
   
9. 9 CoordinateLabel *myLabel = new CoordinateLabel;
   , U) i! A+ _! C! r' X$ B" B6 q3 r
10. 10 myLabel->setWindowTitle("Mouse Event Demo"); /* 设置窗口标题 */
    
11. 11 myLabel->resize(300,200); /* 设置自定义的窗口部件尺寸*/
    
12. 12 myLabel->show();
    3 |8 w+ H3 p3 X% f
13. 13 return app.exec();
    
14. 14 }

复制代码

$ |" m" w0 H! `: J( E7 I+ u

1 e" N" q, n. g) F建立一个新目录为coordinate_label，在该目录下添加coordinate_label.h、coordinate_label.cpp和main.cpp文件，然后调用qmake-qt4命令进行编译，然后执行查看效果，命令如下：
; w0 C6 k8 Z- {1 V# C3 E

1. $ qmake-qt4 –project
   
2. $ qmake-qt4
   
3. $ make

复制代码

( K& p9 d( [& P* J1 m/ o( R3 s3 f
5 u- R  `1 p. N' ^3 MPC上的运行效果如图39所示。

; ]6 p" M2 C% I0 ~4 d7 e' [& q图39 coordinateLabel界面
7 S8 B1 y& t( g- @; o3 S, d
" Z) ^5 m: G6 w" l! f: V