QT 常用类总结

转载:http://www.verydemo.com/demo_c278_i1869.html

       使用Qt进行编程必须对 Qt 中常用的类有一定的了解。这些类可以分成两种:一种不是从 QObject 类派生出来的,用来表示各种基本的数据对象,如字符串、图像、字体等,这里将它们通称为基本类;另一种都是从 QWidget 类派生出来的,它们表示一个顶级窗口或者窗口部件,这里将它们统称为窗口类。

        

        这里介绍的基本类包括 QChar, QString, QPoint, QSize, QRect, QFont, QPixmap, Qlcon。

        这里介绍的窗口类包括 QWidget,QDialog,QLabel,QAbstratacButton,QPushButton, QCheckBox,QRadioButton,QLineEdit

QChar

        QChar 类是 Qt 中用于表示一个字符的类,实现在 QtCore 共享库中。QChar 类内部用2个字节的Unicode编码来表示一个字符。

        

        构造

        QChar 类提供了多个不同原型的构造函数以方便使用,如:

        

[plain] view plaincopyprint?
  1. QChar();                   // 构造一个空字符,即'\0'  
  2. QChar(char ch);         // 由字符数据ch构造  
  3. QChar(uchar ch);        // 由无符号字符数据ch构造  
  4. QChar(ushort code);   // 由无符号短整形数据code构造,code是Unicode编码  
  5. QChar(short code);     //由 短整形数据code构造,code是Unicode编码  
  6. QChar(uint code);      // 由无符号整型数据code构造,code是Unicode编码  
  7. QChar(int code);       // 由整型数据code构造,code是Unicode编码  
  1. QChar();                   // 构造一个空字符,即'\0'  
  2. QChar(char ch);         // 由字符数据ch构造  
  3. QChar(uchar ch);        // 由无符号字符数据ch构造  
  4. QChar(ushort code);   // 由无符号短整形数据code构造,code是Unicode编码  
  5. QChar(short code);     //由 短整形数据code构造,code是Unicode编码  
  6. QChar(uint code);      // 由无符号整型数据code构造,code是Unicode编码  
  7. QChar(int code);       // 由整型数据code构造,code是Unicode编码  
  1. QChar();                   // 构造一个空字符,即'\0'  
  2. QChar(char ch);         // 由字符数据ch构造  
  3. QChar(uchar ch);        // 由无符号字符数据ch构造  
  4. QChar(ushort code);   // 由无符号短整形数据code构造,code是Unicode编码  
  5. QChar(short code);     //由 短整形数据code构造,code是Unicode编码  
  6. QChar(uint code);      // 由无符号整型数据code构造,code是Unicode编码  
  7. QChar(int code);       // 由整型数据code构造,code是Unicode编码  

       实际使用时很少直接构造 QChar 类的对象,而是把这些构造函数当做类型转换来用,让编译器自动构造所需的QChar类对象。也就是说,在所有需要QChar类作为参数的地方都可以安全地使用各种整数类型。

        

       判断

       QChar 类提供了很多成员函数,可以对字符的类型进行判断,如:

[plain] view plaincopyprint?
  1. bool isDigit() const;            // 判断是否是十进制数字('0' - '9')  
  2. bool isLetter() const;          // 判断是否是字母  
  3. bool isNumber() const;        // 判断是否是数字,包括正负号、小数点等  
  4. bool isLetterOrNumber();    // 判断是否是字母或数字  
  5. bool isLower() const;           // 判断是否是小写字母  
  6. bool isUpper() const;           // 判断是否是大写字母  
  7. bool isNull() const;              // 判断是否是空子符'\0'  
  8. bool isPrint() const;            // 判断是否是可打印字符  
  9. bool isSpace() const;         // 判断是否是分隔符,包括空格等  
  1. bool isDigit() const;            // 判断是否是十进制数字('0' - '9')  
  2. bool isLetter() const;          // 判断是否是字母  
  3. bool isNumber() const;        // 判断是否是数字,包括正负号、小数点等  
  4. bool isLetterOrNumber();    // 判断是否是字母或数字  
  5. bool isLower() const;           // 判断是否是小写字母  
  6. bool isUpper() const;           // 判断是否是大写字母  
  7. bool isNull() const;              // 判断是否是空子符'\0'  
  8. bool isPrint() const;            // 判断是否是可打印字符  
  9. bool isSpace() const;         // 判断是否是分隔符,包括空格等  
  1. bool isDigit() const;            // 判断是否是十进制数字('0' - '9')  
  2. bool isLetter() const;          // 判断是否是字母  
  3. bool isNumber() const;        // 判断是否是数字,包括正负号、小数点等  
  4. bool isLetterOrNumber();    // 判断是否是字母或数字  
  5. bool isLower() const;           // 判断是否是小写字母  
  6. bool isUpper() const;           // 判断是否是大写字母  
  7. bool isNull() const;              // 判断是否是空子符'\0'  
  8. bool isPrint() const;            // 判断是否是可打印字符  
  9. bool isSpace() const;         // 判断是否是分隔符,包括空格等  


       转换

       QChar 类提供了一些成员函数进行数据的转换,如:

[plain] view plaincopyprint?
  1. char toAscii() const;           // 得到字符的ASCII码  
  2. QChar toLower() const;    // 转换成小写字母  
  3. QChar toUpper() const;    // 转换成大写字母  
  4. ushort unicode() const;    // 得到Unicode编码  
  1. char toAscii() const;           // 得到字符的ASCII码  
  2. QChar toLower() const;    // 转换成小写字母  
  3. QChar toUpper() const;    // 转换成大写字母  
  4. ushort unicode() const;    // 得到Unicode编码  
  1. char toAscii() const;           // 得到字符的ASCII码  
  2. QChar toLower() const;    // 转换成小写字母  
  3. QChar toUpper() const;    // 转换成大写字母  
  4. ushort unicode() const;    // 得到Unicode编码  

注意这几个函数都不会改变对象自身,转换的结果通过返回值反映出来。

     

      比较

      Qt 中定义了一些与 QChar 类相关的比较操作符, 如:

[plain] view plaincopyprint?
  1. bool operator != (QChar c1, QChar c2);    // 判断 c1 是否不等于 c2  
  2. bool operator < (QChar c1, QChar c2);     // 判断  c1 是否小于 c2  
  3. bool operator <= (QChar c1, QChar c2);   // 判断 c1 是否小于等于 c2  
  4. bool operator == (QChar c1, QChar c2);   // 判断 c1  
  5. 是否等于c2  
  6. bool operator > (QChar c1, QChar c2);    // 判断 c1 是否大于 c2  
  7. bool operator >= (QChar c1, QChar c2);   // 判断  c1  
  8. 是否大于等于 c2  
QString 类是 Qt 中用于表示字符串的类,实现在 QtCore 共享库中。QString 类在实现上有以下特征。

      1)字符串采用 Unicode 内部编码,可以表示世界上大多数语言的文字。

      2)字符串的存储有引用计数,当一个 QString 对象被复制为另一个 QString 对象时,它们实际上指向相同的存储空间,仅仅是增加一个引用计数。

      3)采用 “按需复制” 的技术,当指向相同存储空间的多个 QString 对象中的一个要被修改时,将真正复制一个新的字符串并进行修改。


       构造

       QString 类提供了很多不同原型的构造函数以方便使用。如:

[plain] view plaincopyprint?
  1. Qstring();                                        // 构造空字符串  
  2. QString(QChar ch);                           // 由 QChar 对象 ch构造  
  3. QString(const QChar *pch, int size);    // 由 QChar 数组pch构造,size 是数组大小  
  4. QString(const QString &obj);              // 拷贝构造函数  
  5. QString(const char *str);                  //  由字符串 str 构造,str是一个普通字符串  
  1. Qstring();                                        // 构造空字符串  
  2. QString(QChar ch);                           // 由 QChar 对象 ch构造  
  3. QString(const QChar *pch, int size);    // 由 QChar 数组pch构造,size 是数组大小  
  4. QString(const QString &obj);              // 拷贝构造函数  
  5. QString(const char *str);                  //  由字符串 str 构造,str是一个普通字符串  
  1. Qstring();                                        // 构造空字符串  
  2. QString(QChar ch);                           // 由 QChar 对象 ch构造  
  3. QString(const QChar *pch, int size);    // 由 QChar 数组pch构造,size 是数组大小  
  4. QString(const QString &obj);              // 拷贝构造函数  
  5. QString(const char *str);                  //  由字符串 str 构造,str是一个普通字符串  

       由于存在这些构造函数,凡是可以用 QString 类作为参数的地方,都可以安全地使用 QChar 对象或普通的字符串。


       判断 

       可以用下面的成员函数判断 QString 对象是否为空字符串:

[plain] view plaincopyprint?
  1. bool isEmpty() const;    // 判断是否为空字符串  
  1. bool isEmpty() const;    // 判断是否为空字符串  
  1. bool isEmpty() const;    // 判断是否为空字符串  


       转换

       QString 类提供了很多函数用于将字符串转换为数值,如:

[plain] view plaincopyprint?
  1. double toDouble(bool *ok = 0) const;                                     // 转换为高精度浮点数  
  2. float toFloat(bool *ok = 0) cosnt;                                          // 转换为浮点数  
  3. int toInt(bool *ok, int base = 10) const;                                 // 转换为整型数  
  4. long toLong(bool *ok, int base = 10) cosnt;                            // 转换为长整型  
  5. short toShort(bool *ok, int base = 10) const;                          // 转换为短整型  
  6. uint toUInt(bool *ok = 0; int base = 10) const                         // 转换为无符号整型数  
  7. ulong toLong(bool *ok = 0, int base = 10) const;                     // 转换为无符号长整型数   
  8. ushort toUShort(bool *ok = 0, int base = 10) const;                 // 转换为无符号短整型数  
  1. double toDouble(bool *ok = 0const;                                     // 转换为高精度浮点数  
  2. float toFloat(bool *ok = 0) cosnt;                                          // 转换为浮点数  
  3. int toInt(bool *ok, int base = 10const;                                 // 转换为整型数  
  4. long toLong(bool *ok, int base = 10) cosnt;                            // 转换为长整型  
  5. short toShort(bool *ok, int base = 10const;                          // 转换为短整型  
  6. uint toUInt(bool *ok = 0int base = 10const                         // 转换为无符号整型数  
  7. ulong toLong(bool *ok = 0int base = 10const;                     // 转换为无符号长整型数   
  8. ushort toUShort(bool *ok = 0int base = 10const;                 // 转换为无符号短整型数  
  1. double toDouble(bool *ok = 0const;                                     // 转换为高精度浮点数  
  2. float toFloat(bool *ok = 0) cosnt;                                          // 转换为浮点数  
  3. int toInt(bool *ok, int base = 10const;                                 // 转换为整型数  
  4. long toLong(bool *ok, int base = 10) cosnt;                            // 转换为长整型  
  5. short toShort(bool *ok, int base = 10const;                          // 转换为短整型  
  6. uint toUInt(bool *ok = 0int base = 10const                         // 转换为无符号整型数  
  7. ulong toLong(bool *ok = 0int base = 10const;                     // 转换为无符号长整型数   
  8. ushort toUShort(bool *ok = 0int base = 10const;                 // 转换为无符号短整型数  

       这些函数能够解析 QString 对象的内容,将其转换为相应的数值。其中 ok 参数指向一个 bool 型变量, 这个参数用于输出转换是否成功的信息。base参数则是转换为整数类型时的基。这些函数都不会改变 QString 对象自身。 


注意: 当字符串以 0x开头时,转换的基自动转换为16, 当字符串以0开头时,转换的基自动为8。


       下面这些成员函数可以将一个数值转换为字符串并设为 QString 对象的值:

[plain] view plaincopyprint?
  1. QString &setNum(int n, int base = 10);                                           // 整型数  
  2. QString &setNum(uint n, int base = 10);                                         // 无符号整型数  
  3. QString &setNum(long n, int base = 10);                                        // 长整型  
  4. QString &setNum(ulong n, int base = 10);                                       // 无符号长整型数  
  5. QString &setNum(short n, int base = 10);                                       // 短整型数  
  6. QString &setNum(ushort n, int base = 10);                                      // 无符号短整型数  
  7. QString &setNum(double n, char format = 'g', int precision = 6);          // 高精度浮点数  
  8. QString &setNum(float n, char format = 'g', int precision = 6);            // 浮点数  
  1. QString &setNum(int n, int base = 10);                                           // 整型数  
  2. QString &setNum(uint n, int base = 10);                                         // 无符号整型数  
  3. QString &setNum(long n, int base = 10);                                        // 长整型  
  4. QString &setNum(ulong n, int base = 10);                                       // 无符号长整型数  
  5. QString &setNum(short n, int base = 10);                                       // 短整型数  
  6. QString &setNum(ushort n, int base = 10);                                      // 无符号短整型数  
  7. QString &setNum(double n, char format = 'g'int precision = 6);          // 高精度浮点数  
  8. QString &setNum(float n, char format = 'g'int precision = 6);            // 浮点数  
  1. QString &setNum(int n, int base = 10);                                           // 整型数  
  2. QString &setNum(uint n, int base = 10);                                         // 无符号整型数  
  3. QString &setNum(long n, int base = 10);                                        // 长整型  
  4. QString &setNum(ulong n, int base = 10);                                       // 无符号长整型数  
  5. QString &setNum(short n, int base = 10);                                       // 短整型数  
  6. QString &setNum(ushort n, int base = 10);                                      // 无符号短整型数  
  7. QString &setNum(double n, char format = 'g'int precision = 6);          // 高精度浮点数  
  8. QString &setNum(float n, char format = 'g'int precision = 6);            // 浮点数  


       将浮点数转换为字符串时,format 参数指定转化格式,precision 参数指定转换结果的精度,既有效数组的个数。注意这些函数会改变 QString 对象本身的值,而以下的函数则采用了不同的做法,它们返回一个新的临时对象以供使用:
[plain] view plaincopyprint?
  1. QString number(int n, int base = 10);  
  2. QString number(uint n, int base = 10);  
  3. QString number(long n, int base = 10);  
  4. QString number(ulong n ,int base = 10);  
  5. QString number(double n, char format = 'q', int precision = 6);  
  1. QString number(int n, int base = 10);  
  2. QString number(uint n, int base = 10);  
  3. QString number(long n, int base = 10);  
  4. QString number(ulong n ,int base = 10);  
  5. QString number(double n, char format = 'q'int precision = 6);  
  1. QString number(int n, int base = 10);  
  2. QString number(uint n, int base = 10);  
  3. QString number(long n, int base = 10);  
  4. QString number(ulong n ,int base = 10);  
  5. QString number(double n, char format = 'q'int precision = 6);  

       这些函数都是静态成员函数,因而与某个具体的对象无关,可以直接通过类名调用。

       QString 类也提供了大小写转换的函数,如:

[plain] view plaincopyprint?
  1. QString toLower() const;    // 转换为小写  
  2. QString toUpper() const;    // 转换为大写  
  1. QString toLower() const;    // 转换为小写  
  2. QString toUpper() const;    // 转换为大写  
  1. QString toLower() const;    // 转换为小写  
  2. QString toUpper() const;    // 转换为大写  

       这些函数都不会改变 QString 对象本身,而是将转换后的结果作为返回值。


       比较

       QString 类提供了一个函数用于两个 QString 对象的比较:

[plain] view plaincopyprint?
  1. int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive);  
  1. int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive);  
  1. int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive);  

这是一个静态成员函数,它可以比较 s1 和 s2 的大小,参数 cs 有以下两个取值。

[plain] view plaincopyprint?
  1. Qt::CaseInsensitive: 表示对大小写不敏感  
  2. Qt::Casesensitive :    表示对大小写敏感  
  1. Qt::CaseInsensitive: 表示对大小写不敏感  
  2. Qt::Casesensitive :    表示对大小写敏感  
  1. Qt::CaseInsensitive: 表示对大小写不敏感  
  2. Qt::Casesensitive :    表示对大小写敏感  

       返回值的含义如下:大于 0 表示 s1 大于 s2,等于 0 表示 s1 等于 s2, 小于 0 表示 s1 小于 s2。

       为了方便使用,QString 类还提供了以下重载函数用于比较:

[plain] view plaincopyprint?
  1. int compare(const QString &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  1. int compare(const QString &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  1. int compare(const QString &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

      这个函数用于比较 QString 对象自身和 QString 对象 other。      实际上更为直观的是使用 QString 类的比较操作符,如:
[plain] view plaincopyprint?
  1. bool operator < (StringType other) const;        // 比较是否小于 other人  
  2. bool operator <= (StringType other) const;      // 比较是否小于等于 other  
  3. bool operator == (StringType other) const;      // 比较是否等于 other  
  4. bool operator > (StringType other) constt;       // 比较是否大于 other  
  5. bool operator >= (StringType other) const;      // 比较是否大于等于 other  
  6. bool operator != (StringType other) const;       // 比较是否不等于 other  
  1. bool operator < (StringType other) const;        // 比较是否小于 other人  
  2. bool operator <= (StringType other) const;      // 比较是否小于等于 other  
  3. bool operator == (StringType other) const;      // 比较是否等于 other  
  4. bool operator > (StringType other) constt;       // 比较是否大于 other  
  5. bool operator >= (StringType other) const;      // 比较是否大于等于 other  
  6. bool operator != (StringType other) const;       // 比较是否不等于 other  
  1. bool operator < (StringType other) const;        // 比较是否小于 other人  
  2. bool operator <= (StringType other) const;      // 比较是否小于等于 other  
  3. bool operator == (StringType other) const;      // 比较是否等于 other  
  4. bool operator > (StringType other) constt;       // 比较是否大于 other  
  5. bool operator >= (StringType other) const;      // 比较是否大于等于 other  
  6. bool operator != (StringType other) const;       // 比较是否不等于 other  

      这里的 StringType 指的是 (const QString &)或 (const char *),哥也就是说,这些操作副既可以与 QString 对象比较,也可以与普通的字符串比较。它们的局限性是第一个操作数必须是 QString 对象,因此,Qt 中又定义了以下操作符:
[plain] view plaincopyprint?
  1. bool operator < (const char *s1, const QString &s2);                 // 比较 s1 是否小于 s2  
  2. bool operator <= (const char *s1, const QString &s2);               // 比较 s1 是否小于等于 s2  
  3. bool operator == (const char *s1, const QString &s2);               // 比较 s1 是否等于 s2  
  4. bool operator > (const char *s1, const QString &s2);                 // 比较 s1 是否大于 s2  
  5. bool operator >= (const char *s1, const QString &s2);               // 比较 s1 是否大于等于 s2  
  6. bool operator != (const char *s1, const QString &s2);                // 比较 s1 是否不等于 s2  
  1. bool operator < (const char *s1, const QString &s2);                 // 比较 s1 是否小于 s2  
  2. bool operator <= (const char *s1, const QString &s2);               // 比较 s1 是否小于等于 s2  
  3. bool operator == (const char *s1, const QString &s2);               // 比较 s1 是否等于 s2  
  4. bool operator > (const char *s1, const QString &s2);                 // 比较 s1 是否大于 s2  
  5. bool operator >= (const char *s1, const QString &s2);               // 比较 s1 是否大于等于 s2  
  6. bool operator != (const char *s1, const QString &s2);                // 比较 s1 是否不等于 s2  
  1. bool operator < (const char *s1, const QString &s2);                 // 比较 s1 是否小于 s2  
  2. bool operator <= (const char *s1, const QString &s2);               // 比较 s1 是否小于等于 s2  
  3. bool operator == (const char *s1, const QString &s2);               // 比较 s1 是否等于 s2  
  4. bool operator > (const char *s1, const QString &s2);                 // 比较 s1 是否大于 s2  
  5. bool operator >= (const char *s1, const QString &s2);               // 比较 s1 是否大于等于 s2  
  6. bool operator != (const char *s1, const QString &s2);                // 比较 s1 是否不等于 s2  

       这些操作符不是 QString 类的成员,它们的第一个参数是普通字符串。

        

       查找
       用以下的成员函数可以判断 QString 对象是否包含指定的字符串或字符:

[plain] view plaincopyprint?
  1. bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;        
  2. bool contains(cosnt ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  1. bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;        
  2. bool contains(cosnt ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  1. bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;        
  2. bool contains(cosnt ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

        用以下的成员函数可以得到 QString 对象包含某个特定字符串或字符的个数:
[plain] view plaincopyprint?
  1. int count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  2. int count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  1. int count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  2. int count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  1. int count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  2. int count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

        用以下的成员函数可以得到 QString 对象中某个特定字符串或字符出现的位置:
[plain] view plaincopyprint?
  1. int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  2. int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  1. int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  2. int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  1. int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  2. int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

        这里参数 from 是查找的起点,它可以为负数,-i 表示倒数第i个字符。查找的方向是从前往后。返回值是查找到的字符串或字符的位置,如果没有找到则返回 -1。

        QString 类中还有与此功能相似的函数用于从后往前查找字符串或字符:

[plain] view plaincopyprint?
  1. int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  2. int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const  
  1. int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  2. int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const  
  1. int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
  2. int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const  

      

        字符串处理

 QString  类支持用赋值操作符进行对象的复制,其赋值操作符的声明如下:    

[plain] view plaincopyprint?
  1. QString &operator = (const QString &other);        // 复制另外一个 QString 对象  
  2. QString &operator = (const char *str);               // 复制普通字符串  
  3. QString &operator = (char ch);                         // 复制字符  
  4. QString &operator = (QChar ch);                       // 复制 QChar 类对象  
  1. QString &operator = (const QString &other);        // 复制另外一个 QString 对象  
  2. QString &operator = (const char *str);               // 复制普通字符串  
  3. QString &operator = (char ch);                         // 复制字符  
  4. QString &operator = (QChar ch);                       // 复制 QChar 类对象  
  1. QString &operator = (const QString &other);        // 复制另外一个 QString 对象  
  2. QString &operator = (const char *str);               // 复制普通字符串  
  3. QString &operator = (char ch);                         // 复制字符  
  4. QString &operator = (QChar ch);                       // 复制 QChar 类对象  

        以下的成员函数可以将另一个字符串或字符接在 QString 对象后面,形成一个整体的字符串:

[plain] view plaincopyprint?
  1. QString &append(const QString &str);                // 接续 QString 对象  
  2. QString &append(const char *str);                    // 接续普通字符串  
  3. QString &append(QChar ch);                            // 接续 QChar 对象   
  1. QString &append(const QString &str);                // 接续 QString 对象  
  2. QString &append(const char *str);                    // 接续普通字符串  
  3. QString &append(QChar ch);                            // 接续 QChar 对象   
  1. QString &append(const QString &str);                // 接续 QString 对象  
  2. QString &append(const char *str);                    // 接续普通字符串  
  3. QString &append(QChar ch);                            // 接续 QChar 对象   

        它们的返回值是 QString 对象自己的引用,也就是说,可以用在这个返回值再次调用成员函数,形成连续的字符串接续操作。


        为了让代码更直观, QString 类中还定义了一个操作符用于字符串的接续:

[plain] view plaincopyprint?
  1. QString &operator += (const QString &other);     // 续接 QString 对象  
  2. QString &operator += (const char *str);    // 续接普通字符串  
  3. QString &operator += (char ch);    // 接续字符型数据  
  4. QString &operator += (QChar ch);   // 接续 QChar 对象  
  1. QString &operator += (const QString &other);     // 续接 QString 对象  
  2. QString &operator += (const char *str);    // 续接普通字符串  
  3. QString &operator += (char ch);    // 接续字符型数据  
  4. QString &operator += (QChar ch);   // 接续 QChar 对象  
  1. QString &operator += (const QString &other);     // 续接 QString 对象  
  2. QString &operator += (const char *str);    // 续接普通字符串  
  3. QString &operator += (char ch);    // 接续字符型数据  
  4. QString &operator += (QChar ch);   // 接续 QChar 对象  

        它们的功能与 append 相同。由于 C++ 语言允许赋值操作符和复合赋值操作符的返回值作为左值使用,因此它们的返回值也被设计为 QString 对象自己的引用,故也可以连续操作。但由于复合赋值操作符的结合顺序是从右往左,要想先计算左边的操作数需要加括号。
        

       与 append 函数功能类似,以下的成员函数也能够将另一个字符串或字符与 QString 对象连接起来,但是接在原字符串的前面:

[plain] view plaincopyprint?
  1. QString &prepend(const QString &str);          // 在前面接续 QString 对象  
  2. QString &prepend(const char *str);              // 在前面接续普通字符串  
  3. QString &prepend(QChar ch);                      // 在前面接续 QChar 对象  
  1. QString &prepend(const QString &str);          // 在前面接续 QString 对象  
  2. QString &prepend(const char *str);              // 在前面接续普通字符串  
  3. QString &prepend(QChar ch);                      // 在前面接续 QChar 对象  
  1. QString &prepend(const QString &str);          // 在前面接续 QString 对象  
  2. QString &prepend(const char *str);              // 在前面接续普通字符串  
  3. QString &prepend(QChar ch);                      // 在前面接续 QChar 对象  

       功能更一般化的是在 QString 对象的任意位置插入另一个字符串或字符,如:

[plain] view plaincopyprint?
  1. QString &insert(int position, const QString &str);                   // 插入字符串  
  2. QString &insert(int position, const QChar *pch, int size);         // 插入 QChar 数组  
  3. QString &insert(int position, QChar ch);                               // 插入 QChar 对象  
  1. QString &insert(int positionconst QString &str);                   // 插入字符串  
  2. QString &insert(int positionconst QChar *pch, int size);         // 插入 QChar 数组  
  3. QString &insert(int position, QChar ch);                               // 插入 QChar 对象  
  1. QString &insert(int positionconst QString &str);                   // 插入字符串  
  2. QString &insert(int positionconst QChar *pch, int size);         // 插入 QChar 数组  
  3. QString &insert(int position, QChar ch);                               // 插入 QChar 对象  

       这里 position 参数是要插入的位置,返回值也是对 QString 对象自己的引用。 

       与插入相反的操作是移除 QString 对象中的一部分,如:

[plain] view plaincopyprint?
  1. QString &remove(int position, int n);  
  1. QString &remove(int positionint n);  
  1. QString &remove(int positionint n);  
       

       这个函数可以移除 QString 对象中从位置 position 开始的 n 个字符,下面两个成员函数则可以从 QString 对象中移除指定的字符串或字符:

[plain] view plaincopyprint?
  1. QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive);  
  2. QString &remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive);  
  1. QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive);  
  2. QString &remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive);  
  1. QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive);  
  2. QString &remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive);  

       以下是 QString 对象的替换操作:
[plain] view plaincopyprint?
  1. QString &replace(int position, int n, const QString &after);                    // QString 对象  
  2. QString &replace(int position, int n, const QChar *pch, int size);            // QChar 数组  
  3. QString &replace(int opsition, int n, QChar after);                                // QChar 对象  
  1. QString &replace(int positionint n, const QString &after);                    // QString 对象  
  2. QString &replace(int positionint n, const QChar *pch, int size);            // QChar 数组  
  3. QString &replace(int opsition, int n, QChar after);                                // QChar 对象  
  1. QString &replace(int positionint n, const QString &after);                    // QString 对象  
  2. QString &replace(int positionint n, const QChar *pch, int size);            // QChar 数组  
  3. QString &replace(int opsition, int n, QChar after);                                // QChar 对象  

      这三个函数的功能是将 QString 对象从 position 开始的 n 个字符替换为新内容,新内容分别由 QString 对象、QChar 数组 和 QChar 对象表示。

      以下成员函数则可以搜索指定的字符串或字符并开始替换:

[plain] view plaincopyprint?
  1. QString &replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);      // QString 替换为 QString  
  2. QString &replace(QChar ch, cosnt QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                       // QChar 替换为 QString  
  3. QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                              // Qchar 替换为 QChar  
  1. QString &replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);      // QString 替换为 QString  
  2. QString &replace(QChar ch, cosnt QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                       // QChar 替换为 QString  
  3. QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                              // Qchar 替换为 QChar  
  1. QString &replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);      // QString 替换为 QString  
  2. QString &replace(QChar ch, cosnt QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                       // QChar 替换为 QString  
  3. QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                              // Qchar 替换为 QChar  

      下面这个成员函数可以清空一个 QString 对象的内容,使之成为空字符串。
[plain] view plaincopyprint?
  1. void clear();  
  1. void clear();  
  1. void clear();  

       而下面这个成员函数可以截断 QStrring 对象,也就是去掉指定位置后的所有内容:
[plain] view plaincopyprint?
  1. void truncate(int position);      // 从位置 position 截断,位置从0开始编号  
  1. void truncate(int position);      // 从位置 position 截断,位置从0开始编号  
  1. void truncate(int position);      // 从位置 position 截断,位置从0开始编号  

       下面这个成员函数可以截掉 QString 对象最后的若干个字符:
[plain] view plaincopyprint?
  1. void chop(int n);     // 截掉最后的 n个字符  
  1. void chop(int n);     // 截掉最后的 n个字符  
  1. void chop(int n);     // 截掉最后的 n个字符  

        以下几个成员函数可以得到 QString 对象的子字符串:
[plain] view plaincopyprint?
  1. QString left(int n) const;      // 得到左边 n 个字符构成的子字符串  
  2. QString right(int n) const;    // 得到右边 n 个字符构成的子字符串  
  3. QString mid(int position, int n = -1) const;  // 从中间得到子字符串  
  1. QString left(int n) const;      // 得到左边 n 个字符构成的子字符串  
  2. QString right(int n) const;    // 得到右边 n 个字符构成的子字符串  
  3. QString mid(int positionint n = -1) const;  // 从中间得到子字符串  
  1. QString left(int n) const;      // 得到左边 n 个字符构成的子字符串  
  2. QString right(int n) const;    // 得到右边 n 个字符构成的子字符串  
  3. QString mid(int positionint n = -1) const;  // 从中间得到子字符串  

        从中间得到子字符串时,参数 position 是子字符串的起始位置,参数 n 是字符串的个数,如果n 为 -1,则表示一直到原字符串的结尾。

        注意上述三个函数并不修改 QString 对象自身,而是返回一个临时对象以供使用。

        下面这个成员函数可以截去 QString 对象中头部和尾部的空白字符:

[plain] view plaincopyprint?
  1. QString trimmed() const;  
  1. QString trimmed() const;  
  1. QString trimmed() const;  
         

        空白字符包括空格、回车、换行、制表符等字符。下面这个成员函数不仅能去掉 QString 对象头尾的空白字符,还能将中间的连续多个空白字符全部替换成一个空格:

[plain] view plaincopyprint?
  1. QString simlified() const;  
  1. QString simlified() const;  
  1. QString simlified() const;  

        加法操作符可以将两个字符串或字符连接起来并以 QString 临时对象的方式返回:
[plain] view plaincopyprint?
  1. const QString operator+(const QString &s1, const QString &s2);         
  2. const QString operator+(const QString &s1, const char *s2);  
  3. const QString operator+(const char s1, const QString &s2);  
  4. const QString operator+(const QString &s, char ch);   
  1. const QString operator+(const QString &s1, const QString &s2);         
  2. const QString operator+(const QString &s1, const char *s2);  
  3. const QString operator+(const char s1, const QString &s2);  
  4. const QString operator+(const QString &s, char ch);   
  1. const QString operator+(const QString &s1, const QString &s2);         
  2. const QString operator+(const QString &s1, const char *s2);  
  3. const QString operator+(const char s1, const QString &s2);  
  4. const QString operator+(const QString &s, char ch);   

        注意加法操作符的两个操作数中必须至少有一个是 QString 对象,否则无法重载操作符。显然,加法操作副都不是 QString 类的成员。     

        

        索引

        QString 类也像普通的字符串一样可以根据下标得到某个位置上的字符:

[plain] view plaincopyprint?
  1. const QChar at(int position) const;  
  1. const QChar at(int positionconst;  
  1. const QChar at(int positionconst;  

        这是一个成员函数,更直观的方法是用以下的操作符:
[plain] view plaincopyprint?
  1. const QChar operator[] (int position) const;  
  2. const QChar operator[] (uint position) const;  
  1. const QChar operator[] (int positionconst;  
  2. const QChar operator[] (uint positionconst;  
  1. const QChar operator[] (int positionconst;  
  2. const QChar operator[] (uint positionconst;  

         这样对 QString 对象的取字符操作就类似于对一个字符数组的操作。事实上,通过【】操作符得到的字符还可以被修改,要用到另外两个重载的【】操作符:
[plain] view plaincopyprint?
  1. QCharRef operator[] (int position);  
  2. QCharRef operator[] (uint position);  
  1. QCharRef operator[] (int position);  
  2. QCharRef operator[] (uint position);  
  1. QCharRef operator[] (int position);  
  2. QCharRef operator[] (uint position);  

         返回的 QCharRef 类是一个辅助类,对它的修改将反映到原字符串中去。


         统计

         以下两个成员函数都可以得到 QString 对象中字符的个数:

[plain] view plaincopyprint?
  1. int size() const;  
  2. int length() const;  
  1. int size() const;  
  2. int length() const;  
  1. int size() const;  
  2. int length() const;  

         注意字符的个数并不一定等于字节数。

QPoint 类代表一个坐标点,实现在 QtCore 共享库中。它可以认为是一个整型的横坐标和一个整型的纵坐标的组合。


    构造

    QPoint 类支持以下两种构造方式:

[plain] view plaincopyprint?
  1. QPoint();    // 构造横纵坐标均为 0 的 QPoint 对象  
  2. QPoint(int x, int y);    // 构造横纵坐标分别为 x 和 y 的 QPont 对象  
  1. QPoint();    // 构造横纵坐标均为 0 的 QPoint 对象  
  2. QPoint(int x, int y);    // 构造横纵坐标分别为 x 和 y 的 QPont 对象  
  1. QPoint();    // 构造横纵坐标均为 0 的 QPoint 对象  
  2. QPoint(int x, int y);    // 构造横纵坐标分别为 x 和 y 的 QPont 对象  

    属性

    通过以下成员函数可得到 QPoint 对象中的横纵坐标的引用:

[plain] view plaincopyprint?
  1. int &rx();    // 得到横坐标的引用  
  2. int &ry();    // 到到纵坐标的引用  
  1. int &rx();    // 得到横坐标的引用  
  2. int &ry();    // 到到纵坐标的引用  
  1. int &rx();    // 得到横坐标的引用  
  2. int &ry();    // 到到纵坐标的引用  

     注意这些引用都不是只读的,也就是说可以通过它们直接修改 QPoint。

     通过以下的成员函数可以设置 QPoint 对象中的横纵坐标:

[plain] view plaincopyprint?
  1. void setX(int x);    // 设置横坐标为 x  
  2. void setY(int y);    // 设置纵坐标为 y  
  1. void setX(int x);    // 设置横坐标为 x  
  2. void setY(int y);    // 设置纵坐标为 y  
  1. void setX(int x);    // 设置横坐标为 x  
  2. void setY(int y);    // 设置纵坐标为 y  

     下面两个成员函数则是只读的,可以获得 QPoint 对象中的横纵坐标:
[plain] view plaincopyprint?
  1. int x() const;    // 获得横坐标  
  2. int y() const;    // 获得纵坐标  
  1. int x() const;    // 获得横坐标  
  2. int y() const;    // 获得纵坐标  
  1. int x() const;    // 获得横坐标  
  2. int y() const;    // 获得纵坐标  



     操作符

QPoint 类支持加法和减法的复合赋值操作:

[plain] view plaincopyprint?
  1. QPoint &operator+=(const QPoint &point);    // 加赋值  
  2. QPoint &operator-=(const QPoint &point);    // 减赋值  
  1. QPoint &operator+=(const QPoint &point);    // 加赋值  
  2. QPoint &operator-=(const QPoint &point);    // 减赋值  
  1. QPoint &operator+=(const QPoint &point);    // 加赋值  
  2. QPoint &operator-=(const QPoint &point);    // 减赋值  

    这两个操作符是它的成员。而以下的操作符则不是它的成员:
[plain] view plaincopyprint?
  1. cosnt QPoint operator+(const QPoint &p1, const QPoint &p2);    // 加法  
  2. const QPoint operator-(const QPoint &p1, const QPoint &p2);     // 减法  
  3. const QPoint operator-(const QPoint &point);                          // 取负数  
  4. bool operator==(const QPoint &p1, const QPoint &p2);            // 判断是否相等  
  5. bool operator!=(const QPoint &p1, const QPoint);                   // 判断是否不等  

 QSize 类代表一个矩形区域的大小,实现在 QtCore 共享库中。它可以认为是由一个整型的宽度和整型的高度组合而成的。


        构造

[plain] view plaincopyprint?
  1. QSize();    // 构造一个非法的 QSize 对象  
  2. QSize(int width, int height);    // 构造宽度为 width、高度为 height 的 QSize  对象   
  1. QSize();    // 构造一个非法的 QSize 对象  
  2. QSize(int widthint height);    // 构造宽度为 width、高度为 height 的 QSize  对象   
  1. QSize();    // 构造一个非法的 QSize 对象  
  2. QSize(int widthint height);    // 构造宽度为 width、高度为 height 的 QSize  对象   


        属性

        以下成员函数可以得到 QSize 对象中宽度和高度的引用:

[plain] view plaincopyprint?
  1. void setWidth(int width);    // 设置宽度  
  2. void setHeight(int height);    // 设置高度  
  1. void setWidth(int width);    // 设置宽度  
  2. void setHeight(int height);    // 设置高度  
  1. void setWidth(int width);    // 设置宽度  
  2. void setHeight(int height);    // 设置高度  

        通过以下成员函数可以获得 QSize 对象的宽度和高度:
[plain] view plaincopyprint?
  1. int width() const;    // 获得宽度  
  2. int height() const;  // 获得高度  
  1. int width() const;    // 获得宽度  
  2. int height() const;  // 获得高度  
  1. int width() const;    // 获得宽度  
  2. int height() const;  // 获得高度  

        操作符

        QSize 类支持和 QPoint 类相似的操作符。


QFont  类代表字体,实现在 QtGui 共享库中。


      构造

      QFont 类有以下几个常用的构造函数:

[plain] view plaincopyprint?
  1. QFont();    // 由应用程序的默认字体构造新字体对象  
  2. QFont(const QString &family, int pointSize = -1, int weight = -1, bool italic = false);    
  1. QFont();    // 由应用程序的默认字体构造新字体对象  
  2. QFont(const QString &family, int pointSize = -1int weight = -1bool italic = false);    
  1. QFont();    // 由应用程序的默认字体构造新字体对象  
  2. QFont(const QString &family, int pointSize = -1int weight = -1bool italic = false);    

       其中第二个构造函数的各个参数的含义解释如下。

       1) family: 字体的名称。

       2) pointSize: 字体的点大小,如果这个参数小于等于0,则自动设为 12。

       3) weight: 字体的粗细。

       4) italic: 字体是否为斜体。

       这些参数也可以在字体对象构造以后通过属性来修改。


        

       属性

       QFont 类的常用属性如下所示:


     字体的属性                                                                获取所用成员函数                                                               设置所有成员函数

           名称                                                                   QString family() const;                                                      void setFamily(const QString &family);

        点大小                                                                  int pointSize() const;                                                         void setPointSize(int pointSize);

      像素大小                                                                int pixelSize() const;                                                          void setPixelSize(int pixelSize);

          粗细                                                                    int weight() const;                                                              void setWeight(int weight);

          粗体                                                                    bool bold() const;                                                              void setBold(bool enable);

          斜体                                                                    bool italic() const;                                                              void setItalic(bool enable);

       下划线                                                                   bool underline() const;                                                     void setUnderline(bool enable);


       其中设置粗体属性实际上就是将字体的粗细设为一个确定的值。点大小与像素大小是指定字体大小的两种方式。如果指定了点大小,则像素大小属性的值就是 -1;反之如果指定了像素大小,则点大小属性的值就是 -1。  

       如果指定的字体在使用时没有对应的字体文件,Qt 将自动选择最接近的字体。如果要显示的字符在字体中不存在,则字符会被显示为一个空心方框。      

QPixmap 类代表图像,实现在 QtGui 共享库中。

      构造

      以下构造函数生成的 QPixmap 对象为空图像:

[plain] view plaincopyprint?
  1. QPixmap();     // 构造一个大小为 0 的空图像  
  1. QPixmap();     // 构造一个大小为 0 的空图像  
  1. QPixmap();     // 构造一个大小为 0 的空图像  

      以下构造函数生成大小的 QPixmap 对象,但图像数据未初始化:
[plain] view plaincopyprint?
  1. QPixmap(const QSize &size);     // 构造大小为 size 的图像,图像数据未初始化  
  2. QPixmap(int width, int height);    // 等价于 QPixmap(QSize(width, height));  
  1. QPixmap(const QSize &size);     // 构造大小为 size 的图像,图像数据未初始化  
  2. QPixmap(int widthint height);    // 等价于 QPixmap(QSize(width, height));  
  1. QPixmap(const QSize &size);     // 构造大小为 size 的图像,图像数据未初始化  
  2. QPixmap(int widthint height);    // 等价于 QPixmap(QSize(width, height));  

      以下构造函数能够从指定的文件中加载图像并生成 QPixmap 对象:
[plain] view plaincopyprint?
  1. QPixmap(const QString &filename, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);  
  1. QPixmap(const QString &filename, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);  
  1. QPixmap(const QString &filename, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);  

      其各个参数的含义解释如下。

      1) filename: 文件名。

      2) format: 字符串,表示图像文件的格式,如果为 0,将进行自动识别。

      3) flags:表示颜色的转换模式。


       如果图像文件加载失败则产生空图像,这里 flags 参数有以下取值。

       1) Qt::AutoColor:由系统自动决定。

       2) Qt::ColorOnly:彩色模式。

       3) Qt::MonoOnly:单色模式。


       

       图像参数

       以下成员函数可以获得 QPixmap 对象所表示的图像的相关信息:

[plain] view plaincopyprint?
  1. int depth() const;     // 颜色深度,既每像素所占的比特数  
  2. int width() const;     // 图像宽度,单位是像素  
  3. int height() const;   // 图像高度,单位是像素  
  4. QSize size() cosnt;  // 图像的大小,即 QSize(width(), height());  
  5. QRect rect() const;   // 图像的矩形区域,即 QRect(QPoint(0,0),size());  
  1. int depth() const;     // 颜色深度,既每像素所占的比特数  
  2. int width() const;     // 图像宽度,单位是像素  
  3. int height() const;   // 图像高度,单位是像素  
  4. QSize size() cosnt;  // 图像的大小,即 QSize(width(), height());  
  5. QRect rect() const;   // 图像的矩形区域,即 QRect(QPoint(0,0),size());  
  1. int depth() const;     // 颜色深度,既每像素所占的比特数  
  2. int width() const;     // 图像宽度,单位是像素  
  3. int height() const;   // 图像高度,单位是像素  
  4. QSize size() cosnt;  // 图像的大小,即 QSize(width(), height());  
  5. QRect rect() const;   // 图像的矩形区域,即 QRect(QPoint(0,0),size());  


       加载和保存图像

       用下面的成员函数可以从文件加载图像:

[plain] view plaincopyprint?
  1. bool load(const QString &filename, const char *fornat = 0, Qt::ImageCoversionFlags flags = Qt::AutoColor);  
  1. bool load(const QString &filename, const char *fornat = 0, Qt::ImageCoversionFlags flags = Qt::AutoColor);  
  1. bool load(const QString &filename, const char *fornat = 0, Qt::ImageCoversionFlags flags = Qt::AutoColor);  


       这里各个参数的含义与构造函数中一样,返回值为 true 表示加载成功,false 表示加载失败。相反的操作是将 Qpixmap 代表的图像保存到文件,可用以下成员函数:
[plain] view plaincopyprint?
  1. bool save(const QString &filename, const char *format = 0, int quality = -1) const;  
  1. bool save(const QString &filename, const char *format = 0int quality = -1const;  
  1. bool save(const QString &filename, const char *format = 0int quality = -1const;  

       其各个参数及返回值的含义解释如下。

       1) filename:文件名。

       2) format:字符串,表示图像文件的格式,如果为 0,将根据文件名的后缀自动确定文件格式。

       3) quality:对于有损压缩的文件格式来说,它表示图像保存的质量,质量越低压缩率越大。取值范围为 0~100,-1 表示采用默认值。

       4) 返回值:true 表示保存成功,false 表示保存失败。

       


        判断

        以下成员函数可以判断 QPixmap 对象是否为空图像:

[plain] view plaincopyprint?
  1. bool isNull() const;     // 判断是否为空图像 
  1. bool isNull() const;     // 判断是否为空图像  
  1. bool isNull() const;     // 判断是否为空图像  
QIcon  类代表图标,实现在 QtGui 共享库中。QIcon 对象可以认为是一系列图像的组合,每个图像代表窗口在某种状态下应该1显示的图标。


       构造

       QIcon 类支持以下构造函数:

[plain] view plaincopyprint?
  1. QIcon();                                     // 构造一个空图像构成的图标  
  2. QIcon(const QPixmap &pixmap);     // 从 Pixmap 对象构造函数  
  3. QIcon(const QString &filename);     // 从图像文件构造图标  
  1. QIcon();                                     // 构造一个空图像构成的图标  
  2. QIcon(const QPixmap &pixmap);     // 从 Pixmap 对象构造函数  
  3. QIcon(const QString &filename);     // 从图像文件构造图标  
  1. QIcon();                                     // 构造一个空图像构成的图标  
  2. QIcon(const QPixmap &pixmap);     // 从 Pixmap 对象构造函数  
  3. QIcon(const QString &filename);     // 从图像文件构造图标  

        当从 QPixmap 对象构造图标时,系统会自动产生窗口不同状态下对应的图像,比如窗口在禁用状态下其图标为灰色。从文件构造图标时,文件并不是立刻加载,而是当图标要显示时才加载。


        

        添加图像

        下面的成员函数可以从图像文件中向 QIcon 对象添加图像:

[plain] view plaincopyprint?
  1. void addFile(const QString &filename, const QSize &size = QSize(), Mode mode = Normal, State state = Off);  
  1. void addFile(const QString &filename, const QSize &size = QSize(), Mode mode = Normal, State state = Off);  
  1. void addFile(const QString &filename, const QSize &size = QSize(), Mode mode = Normal, State state = Off);  

         其中各个参数的含义解释如下。

         1)filename:文件名。

         2)size:指定大小。

         3)mode:指定使用模式,即窗口在何种状态下使用这个图像。

         4)state:指定使用状态。


         Mode 为 QIcon 类的成员类型,有以下取值。

         1)QIcon::Normal:窗口为使能状态,但未激活。

         2)QIcon::Disabled:窗口为禁用状态。

         3)QIcon::Active:窗口为激活状态。

         4)QIcon::Selected:窗口被选中。


         当窗口的状态切换时,默认的图标绘制函数会自动根据窗口的状态重绘图标。如果窗口还有所谓的开关状态(比如一个按钮可以有按下和弹起两个状态),则还可以根据 state 参数来选择不同的图像。state 参数为 State 类型,这也是一个 QIcon 类的成员类型,它有以下取值。

         QIcon::Off:窗口在关状态。

         QIcon::On:窗口在开状态。


         另外一个成员函数可以直接将 QPixmap 对象添加到 QIcon 对象中:

[plain] view plaincopyprint?
  1. void addPixmap(const QPixmap &pixmap, Mode mode = Normal, State state = Off);  
  1. void addPixmap(const QPixmap &pixmap, Mode mode = Normal, State state = Off);  
  1. void addPixmap(const QPixmap &pixmap, Mode mode = Normal, State state = Off);  

         这里的 pixmap 参数是要添加的 QPixmap 对象,mode 参数和 state 参数的含义与 addFile 函数中相同。



         获取图像

         下面的成员函数可以获取 QIcon 对象中的图像:

[plain] view plaincopyprint?
  1. QPixmap pixmap(const QSize &size, Mode  mode = Normal, State state = Off) const;  
  1. QPixmap pixmap(const QSize &size, Mode  mode = Normal, State state = Off) const;  
  1. QPixmap pixmap(const QSize &size, Mode  mode = Normal, State state = Off) const;  

         其中参数 size 是指定的大小,参数 mode 和 state 则是使用模式和状态。这个函数还有以下重载版本:
[plain] view plaincopyprint?
  1. QPixmap pixmap(int w, int h, Mode mode = Normal, State state = Off) const;  
  2. QPixmap pixmap(int extent, Mode mode = Normal, State state = Off) const;  
  1. QPixmap pixmap(int w, int h, Mode mode = Normal, State state = Off) const;  
  2. QPixmap pixmap(int extent, Mode mode = Normal, State state = Off) const;  
  1. QPixmap pixmap(int w, int h, Mode mode = Normal, State state = Off) const;  
  2. QPixmap pixmap(int extent, Mode mode = Normal, State state = Off) const;  

         它们分别等价于以下的函数调用:
[plain] view plaincopyprint?
  1. pixmap(QSize(w, h), mode, state);  
  2. pixmap(QSize(extent,, extent), mode, state);  
  1. pixmap(QSize(w, h), mode, state);  
  2. pixmap(QSize(extent,, extent), mode, state);  
  1. pixmap(QSize(w, h), mode, state);  
  2. pixmap(QSize(extent,, extent), mode, state);  

         注意返回的图像大小可能比指定的小,但不会比指定的大。  


         

         判断

         以下成员函数可以判断 QIcon 对象是否为空图像构成的图标:         

[plain] view plaincopyprint?
  1. bool isNull() const;     // 判断是否为空图像构成的图标  
  1. bool isNull() const;     // 判断是否为空图像构成的图标  
  1. bool isNull() const;     // 判断是否为空图像构成的图标  
QWidget  类代表一般的窗口,其他窗口类都是从 QWidget 类继承出来的。而 QWidget 类则同时继承了 QObject 类 和 QPaintDevice 类,也就是说,窗口类都是 Qt 对象类。这里的 QPaintDevice 类则是所有可绘制的对象的基类。


       常用窗口类的继承关系如图所示:

       


       构造

       QWidget 类的构造函数如下:

[plain] view plaincopyprint?
  1. QWidget(QWidget *parent = 0, Qt::WindowFlags f = 0);  
  1. QWidget(QWidget *parent = 0, Qt::WindowFlags f = 0);  
  1. QWidget(QWidget *parent = 0, Qt::WindowFlags f = 0);  
       其中参数 parent 指向父窗口,如果这个参数为 0,则窗口就成为一个顶级窗口

       参数 f 是构造窗口的标志,主要用于控制窗口的类型和外观等,有以下常用值。

       1)Qt::FramelessWindowHint:没有边框的窗口。

       2)Qt::WindowStaysOnTopHint:总是最上面的窗口。

       3)Qt::CustomizeWindowHint:自定义窗口标题栏,以下标志必须与这个标志一起使用才有效,否则窗口将有默认的标题栏。

       4)Qt::WindowTitleHint:显示窗口标题栏。

       5)Qt::WindowSystemMenuHint:显示系统菜单。

       6)Qt::WindowMinimizeButtonHint:显示最小化按钮。

       7)Qt::WindowMaximizeButtonHint:显示最大化按钮。

       8)Qt::WindowMinMaxbuttonHint:显示最小化按钮和最大化按钮。

       9)Qt::WindowCloseButtonHint:显示关闭按钮。


           
       独立窗口

       窗口构造的时候如果有 Qt::Window 标志,那么它就是一个独立窗口,否则就是一个依附于其他独立窗口的窗口部件。顶级窗口一定是独立窗口,但独立窗口不一定是顶级的,它可以有父窗口,当父窗口被析构时它也会随之被析构。独立窗口一般有自己的外边框和标题栏,可以有移动、改变大小等操作。

       一个窗口是否为独立窗口可用下面的成员函数来判断:

[plain] view plaincopyprint?
  1. bool isWindow() const;     // 判断是否为独立窗口  
  1. bool isWindow() const;     // 判断是否为独立窗口  
  1. bool isWindow() const;     // 判断是否为独立窗口  

       下面这个函数可以得到窗口部件所在的独立窗口。
[plain] view plaincopyprint?
  1. QWidget *window() const;      // 所得所在的独立窗口  
  1. QWidget *window() const;      // 所得所在的独立窗口  
  1. QWidget *window() const;      // 所得所在的独立窗口  
       
        当然,如果窗口本身就是独立窗口,那么得到的就是自己。

        而下面这个函数可以得到窗口的父窗口:

[plain] view plaincopyprint?
  1. QWidget *parentWidget() const;    // 得到父窗口  
  1. QWidget *parentWidget() const;    // 得到父窗口  
  1. QWidget *parentWidget() const;    // 得到父窗口  

          

        窗口标题

        WindowTitle 属性表示窗口的标题,与之相关的成员函数如下:

[plain] view plaincopyprint?
  1. QString windowTitle() const;    // 获得窗口标题  
  2. void setWindowTitle(const QString &text);    // 设置窗口标题为 text  
  1. QString windowTitle() const;    // 获得窗口标题  
  2. void setWindowTitle(const QString &text);    // 设置窗口标题为 text  
  1. QString windowTitle() const;    // 获得窗口标题  
  2. void setWindowTitle(const QString &text);    // 设置窗口标题为 text  

       几何参数

       这里的几何参数指的是窗口的大小和位置。一个窗口有两套几何参数,一套是窗口外边框所占的矩形区域,另一套是窗口客户区所占的矩形区域。所谓窗口客户区就是窗口中去除边框和标题栏用来显示内容的区域。

       这两套几何参数分别由两个 QRect 型的属性代表,相关的成员函数如下:

[plain] view plaincopyprint?
  1. const QRect &geometry() const;                 // 获取客户区几何参数  
  2. void setGeometry(int x, int y, int w, int h);    // 设置客户取几何参数  
  3. void setGeometry(const QRect &rect);         // 设置客户区几何参数  
  4. QRect frameGeometry() const;                  // 获取外边框几何参数  
  1. const QRect &geometry() const;                 // 获取客户区几何参数  
  2. void setGeometry(int x, int y, int w, int h);    // 设置客户取几何参数  
  3. void setGeometry(const QRect &rect);         // 设置客户区几何参数  
  4. QRect frameGeometry() const;                  // 获取外边框几何参数  
  1. const QRect &geometry() const;                 // 获取客户区几何参数  
  2. void setGeometry(int x, int y, int w, int h);    // 设置客户取几何参数  
  3. void setGeometry(const QRect &rect);         // 设置客户区几何参数  
  4. QRect frameGeometry() const;                  // 获取外边框几何参数  
     
       这里虽然没有直接设置外边框几何参数的函数,但客户区几何参数变化之后,外边框的几何参数也会随之变化。设置几何参数可能会使窗口的位置及大小发生变化,这时会发送窗口移动事件 QMoveEvent,如果大小有变化,还会发送窗口改变大小事件 QResizeEvent,事件的处理函数分别是 moveEvent 和 resizeEvent。注意这里的坐标都是相对于父窗口的,因此移动一个窗口并不导致它的所有部件都接收到移动事件。


注意:不要在 moveEvent 或 resizeEvent 两个事件处理函数中设置几何参数,否则将导致无限循环。


       窗口的几何参数也可以由用户的操作改变,这时也会发送相应的事件。

       为了方便使用,与几何参数相关的成员函数还有以下这些:

[plain] view plaincopyprint?
  1. QPoint pos() const;     // 获得窗口左上角的坐标(外边框几何参数)  
  2. QSize size() const;      // 窗口大小 (客户区几何参数)  
  3. int x() const;                  // 窗口左上角横坐标 (外边框几何参数)  
  4. int y() const;                  // 窗口左上角纵坐标 (外边框几何参数)  
  5. int height() const;        // 窗口高度 (客户区几何参数)  
  6. int width() const;          // 窗口宽度 (客户区几何参数)  
  1. QPoint pos() const;     // 获得窗口左上角的坐标(外边框几何参数)  
  2. QSize size() const;      // 窗口大小 (客户区几何参数)  
  3. int x() const;                  // 窗口左上角横坐标 (外边框几何参数)  
  4. int y() const;                  // 窗口左上角纵坐标 (外边框几何参数)  
  5. int height() const;        // 窗口高度 (客户区几何参数)  
  6. int width() const;          // 窗口宽度 (客户区几何参数)  
  1. QPoint pos() const;     // 获得窗口左上角的坐标(外边框几何参数)  
  2. QSize size() const;      // 窗口大小 (客户区几何参数)  
  3. int x() const;                  // 窗口左上角横坐标 (外边框几何参数)  
  4. int y() const;                  // 窗口左上角纵坐标 (外边框几何参数)  
  5. int height() const;        // 窗口高度 (客户区几何参数)  
  6. int width() const;          // 窗口宽度 (客户区几何参数)  

       可以看出,坐标全部是外边框几何参数,而大小全部是客户区几何参数。要获得外边框的大小需要用下面这个成员函数:
[plain] view plaincopyprint?
  1. QSize frameSize() const;    // 窗口大小 (外边框几何参数)  
  1. QSize frameSize() const;    // 窗口大小 (外边框几何参数)  
  1. QSize frameSize() const;    // 窗口大小 (外边框几何参数)  

       改变这些属性可以用下面这些成员函数:
[plain] view plaincopyprint?
  1. void move(int x, int y);    // 将窗口左上角移动到坐标(x,  y)处;  
  2. void move(const QPoint &pos);     // 将窗口左上角移动到 pos 处;  
  3. void resize(int w, int h);     // 将窗口的宽度改为 w, 高度改为 h  
  4. void resize(const QSize &size);     // 将窗口的大小改为  size  
  1. void move(int x, int y);    // 将窗口左上角移动到坐标(x,  y)处;  
  2. void move(const QPoint &pos);     // 将窗口左上角移动到 pos 处;  
  3. void resize(int w, int h);     // 将窗口的宽度改为 w, 高度改为 h  
  4. void resize(const QSize &size);     // 将窗口的大小改为  size  
  1. void move(int x, int y);    // 将窗口左上角移动到坐标(x,  y)处;  
  2. void move(const QPoint &pos);     // 将窗口左上角移动到 pos 处;  
  3. void resize(int w, int h);     // 将窗口的宽度改为 w, 高度改为 h  
  4. void resize(const QSize &size);     // 将窗口的大小改为  size  

       同样,这里 move 函数用的是外边框几何参数,而 resize 函数用的是客户区几何参数。

       还有一个属性比较特殊,相关的成员函数如下:

[plain] view plaincopyprint?
  1. QRect rect() const;     // 获取窗口区域  
  1. QRect rect() const;     // 获取窗口区域  
  1. QRect rect() const;     // 获取窗口区域  

       它获得的坐标都是相对于窗口自己的客户区的,也就是说横纵坐标永远为 0。


注意: 对于一个窗口部件来说,它的两套几何参数是一致的。


     

       可见性与隐藏

       可见性指的是窗口是否显示在屏幕上的属性。被其他窗口暂时遮挡住的窗口也属于可见的。可见性由窗口的 visible 属性表示,与之相关的成员函数如下:

[plain] view plaincopyprint?
  1. bool isVisible() const;    // 判断窗口是否可见  
  2. bool isHidden() const;   // 判断窗口是否隐藏  
  3. virtual void setVisible(bool visible);   // 设置窗口是否隐藏  
  4. void setHidden(bool hidden);    // 等价于 setvisible(!hidedn);  
  1. bool isVisible() const;    // 判断窗口是否可见  
  2. bool isHidden() const;   // 判断窗口是否隐藏  
  3. virtual void setVisible(bool visible);   // 设置窗口是否隐藏  
  4. void setHidden(bool hidden);    // 等价于 setvisible(!hidedn);  
  1. bool isVisible() const;    // 判断窗口是否可见  
  2. bool isHidden() const;   // 判断窗口是否隐藏  
  3. virtual void setVisible(bool visible);   // 设置窗口是否隐藏  
  4. void setHidden(bool hidden);    // 等价于 setvisible(!hidedn);  

        visible 属性为 true 时表示窗口可见,为 false 时表示窗口不可见。这里要注意的是,setVisible 函数实际上设置的是窗口是否隐藏,而不是可见性。可见性与隐藏有如下关系。

        1)隐藏的窗口一定是不可见的。

        2)非隐藏的窗口在它的父窗口可见的情况下也是可见的。

        3)非隐藏的顶级窗口是可见的。


        setVisible 和 setHidden 同时也是槽,它们一般并不直接使用,而是使用以下几个槽:

[plain] view plaincopyprint?
  1. void show();     // 显示窗口,等价于 setVisible(true);  
  2. void hide();       // 隐藏窗口,等价于 setHidden(true);  
  1. void show();     // 显示窗口,等价于 setVisible(true);  
  2. void hide();       // 隐藏窗口,等价于 setHidden(true);  
  1. void show();     // 显示窗口,等价于 setVisible(true);  
  2. void hide();       // 隐藏窗口,等价于 setHidden(true);  

        当窗口显示时,将发送 QShowEvent 事件;当窗口隐藏时,将发送 QHideEvent 事件。事件的处理函数分别是 showEvent 和 hideEvent。


           

        窗口状态

        独立窗口有正常、全屏、最大化、最小化几种状态,与之相关的成员函数如下:

[plain] view plaincopyprint?
  1. bool isMinimized() const;     // 判断窗口是否为最小化  
  2. bool isMaximized() const;    // 判断窗口是否为最大化  
  3. bool isFullScreen() const;   // 判断窗口是否为全屏  
  4. void showMinimized();         // 以最小化方式显示窗口,这是一个槽  
  5. void showMaximized();        // 以最大化方式显示窗口,这是一个槽  
  6. void showFullScreen();        // 以全屏方式显示窗口,这是一个槽  
  7. void showNormal();              // 以正常方式显示窗口,这是一个槽  
  1. bool isMinimized() const;     // 判断窗口是否为最小化  
  2. bool isMaximized() const;    // 判断窗口是否为最大化  
  3. bool isFullScreen() const;   // 判断窗口是否为全屏  
  4. void showMinimized();         // 以最小化方式显示窗口,这是一个槽  
  5. void showMaximized();        // 以最大化方式显示窗口,这是一个槽  
  6. void showFullScreen();        // 以全屏方式显示窗口,这是一个槽  
  7. void showNormal();              // 以正常方式显示窗口,这是一个槽  
  1. bool isMinimized() const;     // 判断窗口是否为最小化  
  2. bool isMaximized() const;    // 判断窗口是否为最大化  
  3. bool isFullScreen() const;   // 判断窗口是否为全屏  
  4. void showMinimized();         // 以最小化方式显示窗口,这是一个槽  
  5. void showMaximized();        // 以最大化方式显示窗口,这是一个槽  
  6. void showFullScreen();        // 以全屏方式显示窗口,这是一个槽  
  7. void showNormal();              // 以正常方式显示窗口,这是一个槽  

        注意后 4 个函数同时也是槽。全屏方式与最大化的区别在于:全屏方式下窗口的边框和标题栏消失,客户区占据整个屏幕。窗口的各种状态仅对独立窗口有效,对窗口部件来说没有意义。

        另外还有一个 windowState 属性和窗口状态有关,相关的成员函数如下:

[plain] view plaincopyprint?
  1. Qt::WindowStates windowState() const;                         // 获取窗口状态  
  2. void setWindowState(Qt::WindowStates windowState);      // 设置窗口状态  
  1. Qt::WindowStates windowState() const;                         // 获取窗口状态  
  2. void setWindowState(Qt::WindowStates windowState);      // 设置窗口状态  
  1. Qt::WindowStates windowState() const;                         // 获取窗口状态  
  2. void setWindowState(Qt::WindowStates windowState);      // 设置窗口状态  

        这里的 Qt::WindowStates 类型有以下几个取值。

        1)Qt::WindowNoState:无标志,正常状态。

        2)Qt::WindowMinimized:最小化状态。

        3)Qt::WindowMaxmized:最大化状态。

        4)Qt::WindowFullScreen:全屏状态。

        5)Qt::WindowActive:激活状态。


        这里取值可以用 “按位或” 的方式组合起来使用。

        需要注意的是,调用 setWindowState 函数将使窗口变为隐藏状态。

         

        

        使能

        处于使能状态的窗口才能处理键盘和鼠标等输入事件,反之,处于禁用状态的窗口不能处理这些事件。窗口是否处于使能状态由属性 enabled 表示,相关成员函数如下:

[plain] view plaincopyprint?
  1. bool isEnabled() const;     // 获得窗口的使能装态  
  2. void setEnabled(bool enable);  // 设置窗口的使能状态,这是一个槽  
  3. void setDisabled(bool disabled);     // 等价于 setEnabled(!disable),这是一个槽  
  1. bool isEnabled() const;     // 获得窗口的使能装态  
  2. void setEnabled(bool enable);  // 设置窗口的使能状态,这是一个槽  
  3. void setDisabled(bool disabled);     // 等价于 setEnabled(!disable),这是一个槽  
  1. bool isEnabled() const;     // 获得窗口的使能装态  
  2. void setEnabled(bool enable);  // 设置窗口的使能状态,这是一个槽  
  3. void setDisabled(bool disabled);     // 等价于 setEnabled(!disable),这是一个槽  
         

        其中两个设置属性的函数同时也是槽。窗口的使能状态也可能影响外观,比如处于禁用状态的按钮文本本身为灰色。

        使能状态和窗口的可见性有相似的逻辑:禁用一个窗口同 时会使它的所有子窗口成为禁用状态。


         

        激活状态

        当有多个独立窗口同时存在时,只有一个窗口能够处于激活状态。系统产生的键盘、鼠标等输入事件将被发送给处于激活状态的窗口。一般来说,这样的窗口会被提升到堆叠层次的最上面,除非其他窗口有总在最上面的属性。与激活状态相关的成员函数如下:

[plain] view plaincopyprint?
  1. bool isActiveWindow() const;   // 判断窗口所在的独立窗口是否激活  
  2. void activateWindow();    //  设置窗口所在的独立窗口为激活状态  
  1. bool isActiveWindow() const;   // 判断窗口所在的独立窗口是否激活  
  2. void activateWindow();    //  设置窗口所在的独立窗口为激活状态  
  1. bool isActiveWindow() const;   // 判断窗口所在的独立窗口是否激活  
  2. void activateWindow();    //  设置窗口所在的独立窗口为激活状态  

注意:这里操作的其实不是窗口本身,而是窗口所在的独立窗口,因为窗口部件时没有激活状态的概念的。



        焦点

        焦点用来控制同一个独立窗口内哪一个部件可以接受键盘事件,同一时刻只能有一个部件获得焦点。与焦点有关的成员函数如下:

[plain] view plaincopyprint?
  1. bool hasFocus() const;                     // 判断窗口是否获得焦点  
  2. void setFocus();                             // 使窗口获得焦点,这是一个槽  
  3. void clearFocus();                          // 使窗口失去焦点  
  4. QWidget *focusWidget() const;        // 得到窗口内获得焦点的子窗口   
  1. bool hasFocus() const;                     // 判断窗口是否获得焦点  
  2. void setFocus();                             // 使窗口获得焦点,这是一个槽  
  3. void clearFocus();                          // 使窗口失去焦点  
  4. QWidget *focusWidget() const;        // 得到窗口内获得焦点的子窗口   
  1. bool hasFocus() const;                     // 判断窗口是否获得焦点  
  2. void setFocus();                             // 使窗口获得焦点,这是一个槽  
  3. void clearFocus();                          // 使窗口失去焦点  
  4. QWidget *focusWidget() const;        // 得到窗口内获得焦点的子窗口   


        setFocus 函数同时又是一个槽。窗口部件得到焦点以后,别忘了还需要它所在的独立窗口处于激活状态才能得到键盘事件。

        一个窗口获得焦点,同时意味着另一个窗口失去焦点。当窗口获得或失去焦点时,将发送 QFocusEvent 事件,它有两个处理函数:forceInEvent 和 focusOutEvent,分别对应获得焦点和失去焦点。

        值得一提的是 editFocus 属性,这是一个专门用于嵌入式系统的属性。因为嵌入式系统通常键盘较小,没有专门用于切换焦点的 Tab 键,所以上下方向键被用来切换焦点。如果一个窗口部件设置 editFocus 属性为 true,则上下方向键就不再用于切换焦点,而是发送给这个窗口。与这个属性相关的成员函数如下:

[plain] view plaincopyprint?
  1. bool hasEditfocus() const;     // 判断窗口是否有 editFocus 属性  
  2. void QWidget::setEditFocus(bool enable);     // 设置窗口的 editFocus 属性  
  1. bool hasEditfocus() const;     // 判断窗口是否有 editFocus 属性  
  2. void QWidget::setEditFocus(bool enable);     // 设置窗口的 editFocus 属性  
  1. bool hasEditfocus() const;     // 判断窗口是否有 editFocus 属性  
  2. void QWidget::setEditFocus(bool enable);     // 设置窗口的 editFocus 属性  

  

        捕获键盘和鼠标事件

        窗口部件即使获得焦点,也不一定能获得按键事件,因为其他窗口可能会捕获键盘事件。捕获了键盘事件的窗口将得到所有键盘事件,而其他窗口将完全得到不到键盘事件,直到捕获了键盘事件的窗口释放键盘事件。与键盘事件捕获相关的成员函数如下:

[plain] view plaincopyprint?
  1. void grabKeyboard();           // 捕获键盘事件  
  2. void releaseKeyboard();     // 释放键盘事件  
  1. void grabKeyboard();           // 捕获键盘事件  
  2. void releaseKeyboard();     // 释放键盘事件  
  1. void grabKeyboard();           // 捕获键盘事件  
  2. void releaseKeyboard();     // 释放键盘事件  

        类似的还有鼠标事件的捕获和释放,其成员函数如下:
[plain] view plaincopyprint?
  1. void grabMouse();          // 捕获鼠标事件  
  2. void releaseMouse();    // 释放鼠标事件  
  1. void grabMouse();          // 捕获鼠标事件  
  2. void releaseMouse();    // 释放鼠标事件  
  1. void grabMouse();          // 捕获鼠标事件  
  2. void releaseMouse();    // 释放鼠标事件  

        对键盘事件和鼠标事件的捕获是相互独立的。这里要注意两点:一是如果有另外一个窗口进行了捕获操作,则当前处于捕获状态的窗口将失去对事件的捕获;二是只有可见的窗口才能进行输入事件捕获。

        以下的成员函数能够得到应用程序中正在捕获键盘或鼠标事件的窗口:

[plain] view plaincopyprint?
  1. QWidget *keyboardGrabber();      // 得到正在捕获键盘事件的窗口  
  2. QWidget *mouseGrabber();        // 得到正在捕获鼠标事件的窗口  
  1. QWidget *keyboardGrabber();      // 得到正在捕获键盘事件的窗口  
  2. QWidget *mouseGrabber();        // 得到正在捕获鼠标事件的窗口  
  1. QWidget *keyboardGrabber();      // 得到正在捕获键盘事件的窗口  
  2. QWidget *mouseGrabber();        // 得到正在捕获鼠标事件的窗口  

        这两个函数是静态函数。



        布局

        属性 layout 代表窗口的顶级布局,相关的成员函数如下:

[plain] view plaincopyprint?
  1. QLayout *layout() const;                   // 获得顶级布局  
  2. void setLayout(QLayout *layout);        // 设置顶级布局  
  1. QLayout *layout() const;                   // 获得顶级布局  
  2. void setLayout(QLayout *layout);        // 设置顶级布局  
  1. QLayout *layout() const;                   // 获得顶级布局  
  2. void setLayout(QLayout *layout);        // 设置顶级布局  

      

        字体

        font 属性表示所用的字体,相关的成员函数如下:    

[plain] view plaincopyprint?
  1. const QFont &font() const;         // 获得字体  
  2. void setFont(const QFont &);    // 设置字体  
  1. const QFont &font() const;         // 获得字体  
  2. void setFont(const QFont &);    // 设置字体  
  1. const QFont &font() const;         // 获得字体  
  2. void setFont(const QFont &);    // 设置字体  

       如果没有为窗口设置字体,则窗口自动使用父窗口的字体,顶级窗口则使用应用程序的默认字体。



       信号

       当窗口要被析构时会发射以下信号:       

[plain] view plaincopyprint?
  1. void destoryed(QObject *obj = 0);  
  1. void destoryed(QObject *obj = 0);  
  1. void destoryed(QObject *obj = 0);  

        这是一个从 QOjbect 类继承过来的信号。QObject 对象析构时,先发射这个信号,然后才析构它的所有子对象。



        槽

        在前面的介绍中已经提及了 QWidget 类的许多槽,这里将介绍其他常用的槽。

        下面的槽可以关闭窗口:

[plain] view plaincopyprint?
  1. bool close();  
  1. bool close();  
  1. bool close();  
        当这个槽被调用时,首先向这个窗口发送一个关闭事件,如果事件被接受,则窗口隐藏,如果被拒绝,则什么也不做。如果窗口设置了 Qt::WA_QuitOnClose 属性,则窗口对象会被析构,大多数类型的窗口都默认设置了这个属性。

         这个槽的返回值表示关闭事件是否被接受,也就是窗口是否真的被关闭了。

         下面的槽可以提升或降低窗口所在的堆叠层次:

[plain] view plaincopyprint?
  1. void lower();