xiegenwendada
xiegenwendada

QT常用类总结

        使用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 plain copy print ?
  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();                   // 构造一个空字符，即'\0'
QChar(char ch);         // 由字符数据ch构造
QChar(uchar ch);        // 由无符号字符数据ch构造
QChar(ushort code);   // 由无符号短整形数据code构造，code是Unicode编码
QChar(short code);     //由 短整形数据code构造，code是Unicode编码
QChar(uint code);      // 由无符号整型数据code构造，code是Unicode编码
QChar(int code);       // 由整型数据code构造，code是Unicode编码

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

        

       判断

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

[plain] view plain copy print ?
  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;         // 判断是否是分隔符，包括空格等  
bool isDigit() const;            // 判断是否是十进制数字（'0' - '9'）
bool isLetter() const;          // 判断是否是字母
bool isNumber() const;        // 判断是否是数字，包括正负号、小数点等
bool isLetterOrNumber();    // 判断是否是字母或数字
bool isLower() const;           // 判断是否是小写字母
bool isUpper() const;           // 判断是否是大写字母
bool isNull() const;              // 判断是否是空子符'\0'
bool isPrint() const;            // 判断是否是可打印字符
bool isSpace() const;         // 判断是否是分隔符，包括空格等


       转换

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

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

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

     

      比较

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

[plain] view plain copy print ?
  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 plain copy print ?
  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();                                        // 构造空字符串
QString(QChar ch);                           // 由 QChar 对象 ch构造
QString(const QChar *pch, int size);    // 由 QChar 数组pch构造，size 是数组大小
QString(const QString &obj);              // 拷贝构造函数
QString(const char *str);                  //  由字符串 str 构造，str是一个普通字符串

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


       判断 

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

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


       转换

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

[plain] view plain copy print ?
  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;                 // 转换为无符号短整型数  
double toDouble(bool *ok = 0) const;                                     // 转换为高精度浮点数
float toFloat(bool *ok = 0) cosnt;                                          // 转换为浮点数
int toInt(bool *ok, int base = 10) const;                                 // 转换为整型数
long toLong(bool *ok, int base = 10) cosnt;                            // 转换为长整型
short toShort(bool *ok, int base = 10) const;                          // 转换为短整型
uint toUInt(bool *ok = 0; int base = 10) const                         // 转换为无符号整型数
ulong toLong(bool *ok = 0, int base = 10) const;                     // 转换为无符号长整型数 
ushort toUShort(bool *ok = 0, int base = 10) const;                 // 转换为无符号短整型数

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


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


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

[plain] view plain copy print ?
  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);            // 浮点数  
QString &setNum(int n, int base = 10);                                           // 整型数
QString &setNum(uint n, int base = 10);                                         // 无符号整型数
QString &setNum(long n, int base = 10);                                        // 长整型
QString &setNum(ulong n, int base = 10);                                       // 无符号长整型数
QString &setNum(short n, int base = 10);                                       // 短整型数
QString &setNum(ushort n, int base = 10);                                      // 无符号短整型数
QString &setNum(double n, char format = 'g', int precision = 6);          // 高精度浮点数
QString &setNum(float n, char format = 'g', int precision = 6);            // 浮点数


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

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

       QString 类也提供了大小写转换的函数，如：

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

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


       比较

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

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

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

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

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

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

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

      这个函数用于比较 QString 对象自身和 QString 对象 other。      实际上更为直观的是使用 QString 类的比较操作符，如：
[plain] view plain copy print ?
  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  
bool operator < (StringType other) const;        // 比较是否小于 other人
bool operator <= (StringType other) const;      // 比较是否小于等于 other
bool operator == (StringType other) const;      // 比较是否等于 other
bool operator > (StringType other) constt;       // 比较是否大于 other
bool operator >= (StringType other) const;      // 比较是否大于等于 other
bool operator != (StringType other) const;       // 比较是否不等于 other

      这里的 StringType 指的是 （const QString &）或 （const char *），哥也就是说，这些操作副既可以与 QString 对象比较，也可以与普通的字符串比较。它们的局限性是第一个操作数必须是 QString 对象，因此，Qt 中又定义了以下操作符：
[plain] view plain copy print ?
  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  
bool operator < (const char *s1, const QString &s2);                 // 比较 s1 是否小于 s2
bool operator <= (const char *s1, const QString &s2);               // 比较 s1 是否小于等于 s2
bool operator == (const char *s1, const QString &s2);               // 比较 s1 是否等于 s2
bool operator > (const char *s1, const QString &s2);                 // 比较 s1 是否大于 s2
bool operator >= (const char *s1, const QString &s2);               // 比较 s1 是否大于等于 s2
bool operator != (const char *s1, const QString &s2);                // 比较 s1 是否不等于 s2

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

        

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

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

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

        用以下的成员函数可以得到 QString 对象中某个特定字符串或字符出现的位置：
[plain] view plain copy print ?
  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;  
int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;

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

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

[plain] view plain copy print ?
  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  
int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const

      

        字符串处理

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

[plain] view plain copy print ?
  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 &operator = (const QString &other);        // 复制另外一个 QString 对象
QString &operator = (const char *str);               // 复制普通字符串
QString &operator = (char ch);                         // 复制字符
QString &operator = (QChar ch);                       // 复制 QChar 类对象

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

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

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


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

[plain] view plain copy print ?
  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 &operator += (const QString &other);     // 续接 QString 对象
QString &operator += (const char *str);    // 续接普通字符串
QString &operator += (char ch);    // 接续字符型数据
QString &operator += (QChar ch);   // 接续 QChar 对象

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

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

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

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

[plain] view plain copy print ?
  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 对象  
QString &insert(int position, const QString &str);                   // 插入字符串
QString &insert(int position, const QChar *pch, int size);         // 插入 QChar 数组
QString &insert(int position, QChar ch);                               // 插入 QChar 对象

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

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

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

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

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

       以下是 QString 对象的替换操作：
[plain] view plain copy print ?
  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 对象  
QString &replace(int position, int n, const QString &after);                    // QString 对象
QString &replace(int position, int n, const QChar *pch, int size);            // QChar 数组
QString &replace(int opsition, int n, QChar after);                                // QChar 对象

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

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

[plain] view plain copy print ?
  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 &replace(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);      // QString 替换为 QString
QString &replace(QChar ch, cosnt QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                       // QChar 替换为 QString
QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);                              // Qchar 替换为 QChar

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

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

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

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

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

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

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

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

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

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

        加法操作符可以将两个字符串或字符连接起来并以 QString 临时对象的方式返回:
[plain] view plain copy print ?
  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);   
const QString operator+(const QString &s1, const QString &s2);       
const QString operator+(const QString &s1, const char *s2);
const QString operator+(const char s1, const QString &s2);
const QString operator+(const QString &s, char ch);

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

        

        索引

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

[plain] view plain copy print ?
  1. const QChar at(int position) const;  
const QChar at(int position) const;

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

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

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


         统计

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

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

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

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


    构造

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

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

    属性

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

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

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

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

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

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



     操作符

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

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

    这两个操作符是它的成员。而以下的操作符则不是它的成员：
[plain] view plain copy print ?
  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 plain copy print ?
  1. QSize();    // 构造一个非法的 QSize 对象  
  2. QSize(int width, int height);    // 构造宽度为 width、高度为 height 的 QSize  对象   
QSize();    // 构造一个非法的 QSize 对象
QSize(int width, int height);    // 构造宽度为 width、高度为 height 的 QSize  对象


        属性

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

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

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

        操作符

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


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


      构造

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

[plain] view plain copy print ?
  1. QFont();    // 由应用程序的默认字体构造新字体对象  
  2. QFont(const QString &family, int pointSize = -1, int weight = -1, bool italic = false);    
QFont();    // 由应用程序的默认字体构造新字体对象
QFont(const QString &family, int pointSize = -1, int weight = -1, bool 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 plain copy print ?
  1. QPixmap();     // 构造一个大小为 0 的空图像  
QPixmap();     // 构造一个大小为 0 的空图像

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

      以下构造函数能够从指定的文件中加载图像并生成 QPixmap 对象：
[plain] view plain copy print ?
  1. QPixmap(const QString &filename, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);  
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 plain copy print ?
  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());  
int depth() const;     // 颜色深度，既每像素所占的比特数
int width() const;     // 图像宽度，单位是像素
int height() const;   // 图像高度，单位是像素
QSize size() cosnt;  // 图像的大小，即 QSize(width(), height());
QRect rect() const;   // 图像的矩形区域，即 QRect(QPoint(0,0),size());


       加载和保存图像

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

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


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

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

       1) filename：文件名。

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

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

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

       


        判断

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

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


       构造

       QIcon 类支持以下构造函数：

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

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


        

        添加图像

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

[plain] view plain copy print ?
  1. void addFile(const QString &filename, const QSize &size = QSize(), Mode mode = Normal, State state = Off);  
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 plain copy print ?
  1. void addPixmap(const QPixmap &pixmap, Mode mode = Normal, State state = Off);  
void addPixmap(const QPixmap &pixmap, Mode mode = Normal, State state = Off);

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



         获取图像

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

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

         其中参数 size 是指定的大小，参数 mode 和 state 则是使用模式和状态。这个函数还有以下重载版本：
[plain] view plain copy print ?
  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;  
QPixmap pixmap(int w, int h, Mode mode = Normal, State state = Off) const;
QPixmap pixmap(int extent, Mode mode = Normal, State state = Off) const;

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

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


         

         判断

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

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


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

       


       构造

       QWidget 类的构造函数如下：

[plain] view plain copy print ?
  1. QWidget(QWidget *parent = 0, Qt::WindowFlags f = 0);  
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 plain copy print ?
  1. bool isWindow() const;     // 判断是否为独立窗口  
bool isWindow() const;     // 判断是否为独立窗口

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

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

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

          

        窗口标题

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

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

       几何参数

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

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

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


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


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

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

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

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

       改变这些属性可以用下面这些成员函数：
[plain] view plain copy print ?
  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  
void move(int x, int y);    // 将窗口左上角移动到坐标（x,  y）处；
void move(const QPoint &pos);     // 将窗口左上角移动到 pos 处；
void resize(int w, int h);     // 将窗口的宽度改为 w， 高度改为 h
void resize(const QSize &size);     // 将窗口的大小改为  size

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

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

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

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


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


     

       可见性与隐藏

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

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

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

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

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

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


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

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

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


           

        窗口状态

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

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

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

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

[plain] view plain copy print ?
  1. Qt::WindowStates windowState() const;                         // 获取窗口状态  
  2. void setWindowState(Qt::WindowStates windowState);      // 设置窗口状态  
Qt::WindowStates windowState() const;                         // 获取窗口状态
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 plain copy print ?
  1. bool isEnabled() const;     // 获得窗口的使能装态  
  2. void setEnabled(bool enable);  // 设置窗口的使能状态，这是一个槽  
  3. void setDisabled(bool disabled);     // 等价于 setEnabled(!disable)，这是一个槽  
bool isEnabled() const;     // 获得窗口的使能装态
void setEnabled(bool enable);  // 设置窗口的使能状态，这是一个槽
void setDisabled(bool disabled);     // 等价于 setEnabled(!disable)，这是一个槽
         

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

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


         

        激活状态

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

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

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



        焦点

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

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


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

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

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

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

  

        捕获键盘和鼠标事件

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

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

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

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

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

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

        这两个函数是静态函数。



        布局

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

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

      

        字体

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

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

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



       信号

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

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

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



        槽

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

        下面的槽可以关闭窗口：

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

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

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

[plain] view plain copy print ?
  1. void lower();         // 降低窗口到最下面  
  2. void raise();        // 提升窗口到最上面  
void lower();         // 降低窗口到最下面
void raise();        // 提升窗口到最上面



         事件

         QWidget 类能够处理类型丰富的事件，这里将介绍一些常用的事件处理函数。

         窗口事件：

[plain] view plain copy print ?
  1. virtual void closeEvent(QCloseEvent *event);    // 关闭  
  2. virtual void showEvent(QShowEvent *event);    //  显示  
  3. virtual void hideEvent(QHideEvent *event);        // 隐藏  
  4. virtual void moveEvent(QMoveEvent *evnet);     // 移动  
  5. virtual void resizeEvent(QResizeEvent *event);  // 改变大小  
virtual void closeEvent(QCloseEvent *event);    // 关闭
virtual void showEvent(QShowEvent *event);    //  显示
virtual void hideEvent(QHideEvent *event);        // 隐藏
virtual void moveEvent(QMoveEvent *evnet);     // 移动
virtual void resizeEvent(QResizeEvent *event);  // 改变大小

         这里通过 QMoveEvent 类的以下成员函数可以获得窗口的旧坐标和新坐标：
[plain] view plain copy print ?
  1. const QPoint &oldPos() const;     // 旧坐标  
  2. const QPoint &newPos() constl   // 新坐标  
const QPoint &oldPos() const;     // 旧坐标
const QPoint &newPos() constl   // 新坐标

         通过 QResizeEvent 类的以下成员函数可以获得窗口的旧大小和新大小：
[plain] view plain copy print ?
  1. const QSize &oldSize() const;     // 旧大小  
  2. const QSize &newSize() const;   // 新大小  
const QSize &oldSize() const;     // 旧大小
const QSize &newSize() const;   // 新大小

         键盘事件：
[plain] view plain copy print ?
  1. virtual void keyPressEvent(QKeyEvent *event);   // 键按下  
  2. virtual void keyReleaseEvent(QKeyEvent *event);  // 键松开      
virtual void keyPressEvent(QKeyEvent *event);   // 键按下
virtual void keyReleaseEvent(QKeyEvent *event);  // 键松开

         这里通过  QKeyEvent 类的成员函数可以获得关于按键的一些信息，如：

[plain] view plain copy print ?
  1. int key() const;     // 得到键值  
int key() const;     // 得到键值

          鼠标事件：         
[plain] view plain copy print ?
  1. virtual void mousePressEvent(QMouseEvent *event);                               // 鼠标键按下  
  2. virtual void mouseReleaseEvent(QMouseEvent *event);                            // 鼠标键松开  
  3. virtual void mouseDoubleCllckEvent(QMouseEvent *event);                       // 鼠标键双击  
  4. virtual void mouseMoveEvent(QMouseEvent *event);                               // 鼠标移动  
  5. virtual void enterEvent(QEvent *event);                                                // 鼠标进入窗口  
  6. virtual void leaveEvent(QEvent *event);                                                // 鼠标离开窗口  
  7. virtual void wheelEvent(QWheelEvent *event);                                       // 鼠标滚轮移动  
virtual void mousePressEvent(QMouseEvent *event);                               // 鼠标键按下
virtual void mouseReleaseEvent(QMouseEvent *event);                            // 鼠标键松开
virtual void mouseDoubleCllckEvent(QMouseEvent *event);                       // 鼠标键双击
virtual void mouseMoveEvent(QMouseEvent *event);                               // 鼠标移动
virtual void enterEvent(QEvent *event);                                                // 鼠标进入窗口
virtual void leaveEvent(QEvent *event);                                                // 鼠标离开窗口
virtual void wheelEvent(QWheelEvent *event);                                       // 鼠标滚轮移动

         这里通过 QMouseEvent 事件的成员函数可获得关于鼠标的信息，如：
[plain] view plain copy print ?
  1. const QPoint &pos() const;                                                             // 得到鼠标坐标（相对于接收事件的窗口）  
  2. int x()  const;                                                                              // 得到鼠标横坐标（相对于接收事件的窗口）  
  3. int y() const;                                                                               // 得到鼠标纵坐标（相对于接收事件的窗口）  
  4. const QPoint &globalPos() const;                                                     // 得到鼠标坐标（全局坐标）  
  5. int globalX() const;                                                                        // 得到鼠标横坐标 （全局坐标）  
  6. int globalY() const;                                                                        // 得到鼠标纵坐标 （全局坐标）  
  7. Qt::MouseButton button() const;                                                       // 得到引起事件的鼠标键  
  8. Qt::MouseButtons buttons() const;                                                    // 得到事件发生时的鼠标键状态   
const QPoint &pos() const;                                                             // 得到鼠标坐标（相对于接收事件的窗口）
int x()  const;                                                                              // 得到鼠标横坐标（相对于接收事件的窗口）
int y() const;                                                                               // 得到鼠标纵坐标（相对于接收事件的窗口）
const QPoint &globalPos() const;                                                     // 得到鼠标坐标（全局坐标）
int globalX() const;                                                                        // 得到鼠标横坐标 （全局坐标）
int globalY() const;                                                                        // 得到鼠标纵坐标 （全局坐标）
Qt::MouseButton button() const;                                                       // 得到引起事件的鼠标键
Qt::MouseButtons buttons() const;                                                    // 得到事件发生时的鼠标键状态

         其中，Qt::MouseButton 是一个枚举类型，有以下常用取值。

         1）Qt::NoButton：无键。

         2）Qt::LeftButton：左键。

         3）Qt::RightButton：右键。

         4）Qt::MidButton：中键。

         

         注意，对于鼠标移动事件 QMouseEvent 和 button 函数总是返回 Qt::NoButton，而 buttons 函数返回值则是 Qt::MouseButton 类型的 “按位或” 组合，它能反映事件发生时鼠标键的按下状态。

         

          QWheelEvent 类代表滚轮事件，它有一套与 QMountEvent 类几乎相同的成员函数，但少一个 button 函数，多以下两个函数：

[plain] view plain copy print ?
  1. int delta() const;    // 获得滚轮转动的角度  
  2. Qt::Orientation orientationI() const;    // 获得滚轮转动的方向  
int delta() const;    // 获得滚轮转动的角度
Qt::Orientation orientationI() const;    // 获得滚轮转动的方向

          其中 Qt::Orientation 是一个枚举类型，它有以下取值。

          1）Qt::Horizontal：横向。

          2）Qt::Vertical：纵向。


          焦点事件：

[plain] view plain copy print ?
  1. virtual void focusInEvent(QFocusEvent *event);    // 获得焦点  
  2. virtual void focusOutEvent(QFocusEvent *event);  // 时取焦点  
virtual void focusInEvent(QFocusEvent *event);    // 获得焦点
virtual void focusOutEvent(QFocusEvent *event);  // 时取焦点

          这些事件处理函数都没有返回值，因此如果要接受或拒绝和一个事件要调用 QEvent 类的成员函数，如：
[plain] view plain copy print ?
  1. event->accept();    // 接受事件  
  2. event->ignore();    // 拒绝事件  
event->accept();    // 接受事件
event->ignore();    // 拒绝事件

          事件被拒绝后的结果视具体情况而定，比如关闭事件被拒绝后，窗口将不会被关闭，而键盘、鼠标等输入事件被拒绝后会向上传播到父窗口。  

 

QDialog 类代表对话框。对话框一般用来实现那些只是暂时存在的用户界面。对话框是独立的窗口，但通常它也有父窗口，当对话框显示时，默认的位置在父窗口的中央。从外观上来看，对话框一般没有最大化、最小化按钮。

        对话框有模态和非模态两种形式。非模态对话框的的行为和使用方法都类似于普通的窗口。模态对话框则有所不同，当模态对话框显示时，其他窗口将全部进入非激活状态，不能接受键盘和鼠标事件。模态的方式又可以分为两种，一种是对整个应用程序模态，这时它的出现将导致程序中的所有窗口失去响应；另一种是对窗口模态，这时仅仅会导致它所在的整个窗口树失去响应。  



        构造

        QDialog 类的构造函数与 QWidget 类形式相同：

[plain] view plain copy print ?
  1. QDialog (QWidget *parent = 0, Qt::WindowFlags f = 0);  
QDialog (QWidget *parent = 0, Qt::WindowFlags f = 0);



        模态性

        用下面的成员函数可将对话框设为模态：

[plain] view plain copy print ?
  1. void setModal(bool modal);    // 设置对话框的模态性  
void setModal(bool modal);    // 设置对话框的模态性

         当参数 model 为 true 时，对话框设为模态，否则设为非模态。如果设为模态，则默认是对整个应用程序模态的。要设为对窗口模态，则需要用以下函数：
[plain] view plain copy print ?
  1. void setWindowModality(Qt::WindowModality windowModality);  
void setWindowModality(Qt::WindowModality windowModality);

         实际上它是从 QWidget 类继承过来的一个成员函数，其中 Qt::WindowModality 是一个枚举类型，有以下取值。

         1）Qt::NonModal：非模态。

         2）Qt::WindowModal：窗口模态。

         3）Qt::ApplicationModal：应用程序模态。


         与模态性相关的成员函数还有以下两个：

[plain] view plain copy print ?
  1. Qt::WindowModality windowModality() const;    // 得到窗口的模态性  
  2. bool isModel() const;                                  // 判断窗口是否为模态的  
Qt::WindowModality windowModality() const;    // 得到窗口的模态性
bool isModel() const;                                  // 判断窗口是否为模态的
 

        执行与结果

        下面这个函数将以模态方式显示对话框：

[plain] view plain copy print ?
  1. int exec();     // 这是一个槽  
int exec();     // 这是一个槽

        同时它也是一个槽。这个函数不管对话框的模态性如何，总是显示模态对话框。调用这个函数的代码将阻塞直到对话框被关闭，返回值表示对胡框的结果。注意这个函数总是在其他窗口的代码中调用，一般不在对话框自己的代码中使用。

        对话框的结果与下面的函数有关：

[plain] view plain copy print ?
  1. virtual void done(int r);    // 关闭对话框并返回结果 r，这是一个槽。  
virtual void done(int r);    // 关闭对话框并返回结果 r，这是一个槽。

        这时一个槽，它将使对话框关闭，使对 exec 函数的调用返回。参数 r 是整数值，但最好使用 QDialog::DialogCode 枚举类型所定义的两个值。

        1）QDialog::Accepted：表示确定。

        2）QDialog::Rejected：表示取消。


        对话框通常有一个确定按钮和一个取消按钮，它们能使对话框关闭并返回相应的值。为了与按钮的 clicked() 信号连接，需要用到以下的槽：

[plain] view plain copy print ?
  1. virtual void accept();    // 槽，等价于 done(QDialog::Accepted)  
  2. virtual void reject();      // 槽，等价于 done(QDialog::Rejected)  
virtual void accept();    // 槽，等价于 done(QDialog::Accepted)
virtual void reject();      // 槽，等价于 done(QDialog::Rejected)


        

         打开

         下面这个函数将以对窗口模态的方式显示对话框：

[plain] view plain copy print ?
  1. void open();    // 这是一个槽  
void open();    // 这是一个槽

         它也是一个槽。与 exec 函数不同的是，open 函数将立刻返回而不是等待对话框关闭。它一般用在需要显示模态对话框但又要继续进行工作的场合，比如一个进度对话框。这时候，需要在工作处理过程中间歇性地调用 QApplication 对象的 processEvents 成员函数，否则对话框的事件将的不到处理。


QLabel 类代表标签，它是一个用于显示文本或图像的窗口部件。

        

        构造

        QLabel 类支持以下构造函数：

[plain] view plain copy print ?
  1. QLabel(QWidget *parent = 0, Qt::WindowFlags f = 0);  
  2. QLabel(const QString &text, QWidget *parent = 0, Qt::WindowFlags f= 0);  
QLabel(QWidget *parent = 0, Qt::WindowFlags f = 0);
QLabel(const QString &text, QWidget *parent = 0, Qt::WindowFlags f= 0);

        其中第二个构造函数能够同时通过参数 text 给出要显示的文本，因此是最常用的构造方式。


         

        属性

        QLabel 对象的显示内容可以通过属性获取或修改，相关成员函数如下：

[plain] view plain copy print ?
  1. QString text() const;                                                 // 获取显示的文本  
  2. void settext(const QString &text);                                // 设置显示的文本，这是一个槽  
  3. const QPixmap *pixmap() const;                                 // 获取显示的图像  
  4. void setPixmap(const QPixmap &pixmap);                     // 设置显示的图像，这时一个槽  
  5. void setNum(int num);                                              // 设置显示的文本为代表整数 num 的字符串，这是一个槽  
  6. void setNum(double num);                                         // 设置显示的文本为代表浮点数 num 的字符串，这时一个槽  
QString text() const;                                                 // 获取显示的文本
void settext(const QString &text);                                // 设置显示的文本，这是一个槽
const QPixmap *pixmap() const;                                 // 获取显示的图像
void setPixmap(const QPixmap &pixmap);                     // 设置显示的图像，这时一个槽
void setNum(int num);                                              // 设置显示的文本为代表整数 num 的字符串，这是一个槽
void setNum(double num);                                         // 设置显示的文本为代表浮点数 num 的字符串，这时一个槽


        其中进行设置的函数同时也都是槽。新设置的内容将取代原来的内容。

        用以下的成员函数则可以清空显示内容：       

[plain] view plain copy print ?
  1. void clear();    // 清空显示内容  
void clear();    // 清空显示内容

        alignment 属性代表内容的对齐方式，相关函数成员如下：
[plain] view plain copy print ?
  1. Qt::Alignment alignment() const;    // 获取对齐方式  
  2. void setAlignment(Qt::Alignment align);    // 设置对齐方式  
Qt::Alignment alignment() const;    // 获取对齐方式
void setAlignment(Qt::Alignment align);    // 设置对齐方式

        这里的 Qt::Alignment 类型有以下取值。

        1）Qt::AlignLeft:：水平方向靠左。

        2）Qt::AlignRight：水平方向靠右。

        3）Qt::AlignHCenter：水平方向居中。

        4）Qt::AlignJustify：水平方向调整间距两端对齐。

        5）Qt::AlignTop：垂直方向靠上。

        6）Qt::AlignButton：垂直方向靠下。

        7）Qt::AlignVCenter：垂直方向居中。

        8）Qt::AlignCenter：等价于 Qt::AlignHCenter | Qt::AlignVCenter。


        其中一个水平方向的取值和一个垂直方向的取值可以用 “按位或” 的方式组合起来以同时指定两个方向的对齐方式。默认的对齐方式为水平靠左、垂直居中。

        indent 属性代表文本的缩进值，相关的成员函数如下：

[plain] view plain copy print ?
  1. int indent() const;    // 获取文本缩进值  
  2. void setIndex(int indent);    //设置文本缩进值  
int indent() const;    // 获取文本缩进值
void setIndex(int indent);    //设置文本缩进值

        margin 属性代表显示内容的边距，相关的成员函数如下：
[plain] view plain copy print ?
  1. int margin() const;                   // 获取边距  
  2. void setMargin(int margin);        // 设置边距  
int margin() const;                   // 获取边距
void setMargin(int margin);        // 设置边距

        wordWrap 属性代表显示的文本是否允许换行，相关的成员函数如下：
[plain] view plain copy print ?
  1. bool wordWrap() const;            // 判断是否允许换行  
  2. void setWordWrap(bool on);     // 设置是否允许换行  
bool wordWrap() const;            // 判断是否允许换行
void setWordWrap(bool on);     // 设置是否允许换行

        scaledContents 属性表示显示图像时是否允许缩放，相关的成员函数如下：
[plain] view plain copy print ?
  1. bool hasScaledContenes() const;    // 判断是否允许图像缩放  
  2. void setScaledContents(bool on);    // 设置是否允许图像缩放  
bool hasScaledContenes() const;    // 判断是否允许图像缩放
void setScaledContents(bool on);    // 设置是否允许图像缩放

        如果允许缩放，则显示图像时会进行缩放以填满整个显示区域。

 

QAbstractButton 类是 QPushButton，QCheckBox，QRadioButton 等类的基类，它可以代表按钮、单选纽、复选纽等重要窗口部件。通常不会直接使用这个类，这里主要介绍它的一些属性、信号和槽，介绍时暂时将这些窗口部件统称为钮。


        属性

        checkable 属性代表钮是否支持开关状态，比如按钮一般没有开关状态，而单选钮和复选钮都有打开和关闭两个状态。与 checkable 属性相关的成员函数如下：

[plain] view plain copy print ?
  1. bool isCheckable() const;               // 判断是否支持开关状态  
  2. void setCheckable(bool on);            // 设置是否支持开关状态  
bool isCheckable() const;               // 判断是否支持开关状态
void setCheckable(bool on);            // 设置是否支持开关状态

       如果一个钮支持开关状态，则可以用 checked 属性设置它的开关状态，相关的成员函数如下：
[plain] view plain copy print ?
  1. bool isChecked() const;                // 判断是否打开  
  2. void setChecked(bool on);            // 设置是否打开，这是一个槽  
bool isChecked() const;                // 判断是否打开
void setChecked(bool on);            // 设置是否打开，这是一个槽

      其中 setChecked 函数同时也是一个槽。

      autoExclusive 属性表示一个钮是否排他，相关的成员函数如下：

[plain] view plain copy print ?
  1. bool autoExclusive() const;         // 判断是否排他  
  2. void setAutoExclusive(bool on);    // 设置是否排他   
bool autoExclusive() const;         // 判断是否排他
void setAutoExclusive(bool on);    // 设置是否排他

      排他属性也和钮的开关状态有关，同一个父窗口下的多个排他的钮同时只能有一个是打开的，当一个钮被打开时，其他的钮将自动关闭。

      down 属性代表钮是否处于被按下的状态，相关成员函数如下：

      

[plain] view plain copy print ?
  1. bool isDown() const;        // 判断是否被按下  
  2. void setDown(bool on);    // 设置是否被按下  
bool isDown() const;        // 判断是否被按下
void setDown(bool on);    // 设置是否被按下

      注意设置这个属性仅仅是改变钮的外观，不会发射任何信号。

      通过 icon 和 text 属性可以设置钮所显示的图标及文本，相关成员函数如下：

[plain] view plain copy print ?
  1. QIcon icon() const;                              // 获得图标  
  2. void setIcon(const QIcon &icon);            // 设置图标  
  3. QString text() const;                            // 获得文本  
  4. void setText(const QString &text);          // 设置文本  
QIcon icon() const;                              // 获得图标
void setIcon(const QIcon &icon);            // 设置图标
QString text() const;                            // 获得文本
void setText(const QString &text);          // 设置文本

      shortcut 属性代表钮的快捷键，相关成员函数如下：
[plain] view plain copy print ?
  1. QKeySequence shortcut() const;                     // 获得快捷键  
  2. void setShortcut(const QKeySequence &key);    // 设置快捷键  
QKeySequence shortcut() const;                     // 获得快捷键
void setShortcut(const QKeySequence &key);    // 设置快捷键
 
      从键盘输入一个钮的快捷键等价于单击这个钮。设置快捷键所需的 QKeySequence 对象可用如下方式构造：
[plain] view plain copy print ?
  1. QKeySequence("Ctrl+P");                            // 构造表示 Ctrl+P 组合键的 QKeySequence 对象  
QKeySequence("Ctrl+P");                            // 构造表示 Ctrl+P 组合键的 QKeySequence 对象

 

     

      信号

      在钮上用鼠标左键或者当钮得到焦点的时候用空格键都能操作这个钮。当钮被按下和松开时，将发射以下信号：

[plain] view plain copy print ?
  1. void pressed();     // 钮被按下  
  2. void released();    // 钮被松开  
void pressed();     // 钮被按下
void released();    // 钮被松开

      当单击钮时，将发射以下信号：
[plain] view plain copy print ?
  1. void clicked(bool checked = false);  
void clicked(bool checked = false);

      其中参数 checked  表示钮是否被打开。

      当钮的开关状态变化时，将发射以下信号：

[plain] view plain copy print ?
  1. void toggled(bool checked);  
void toggled(bool checked);

      其中参数 checked 表示钮是否被打开。



      槽

      下面的两个槽都能够模拟钮被单击的过程：

[plain] view plain copy print ?
  1. void click();   
  2. void animateclick(int msec = 100);  
void click(); 
void animateclick(int msec = 100);

      两者的不同点在于，click 函数不会改变钮的外观，它会直接进行单击的处理过程；而animateClick() 函数将完全模拟用户按下按的过程，参数 msec 就是钮被按下的毫秒数。两者最终都会导致 pressed，released 和 clicked 信号的发射。

      下面的槽将导致钮的开关状态发生切换：

[plain] view plain copy print ?
  1. void toggle();  
void toggle();

       当然，它只对有开关状态的钮发生作用。

QPushButton 类代表按钮，它继承了 QAbstractButton 类，因此也有其全部的属性、信号和槽。

        

        

        构造

        QPushButton 类支持以下构造函数：

[plain] view plain copy print ?
  1. QPushButton(QWidget *parent = 0);  
  2. QPushButton(const QString &text, QWidget *parent = 0);  
  3. QPushButton(const QIcon &icon, const QString &text, QWidget *parent = 0);  
QPushButton(QWidget *parent = 0);
QPushButton(const QString &text, QWidget *parent = 0);
QPushButton(const QIcon &icon, const QString &text, QWidget *parent = 0);

        其中参数 text 是按钮上显示的文本，icon 是按钮的图标。生成的 QPushButton 对象默认是没有开关状态的。



       属性

       按钮的外观一般是有立体感的。通过它的 flat 属性可以控制外观是否为扁平状，相关成员函数如下：

[plain] view plain copy print ?
  1. bool isFlat() const;         // 判断外观是否为扁平状  
  2. void setFlat(bool flat);    // 设置外观是否为扁平状  
bool isFlat() const;         // 判断外观是否为扁平状
void setFlat(bool flat);    // 设置外观是否为扁平状

       如果这个属性为 true，则按钮就是扁平的，否则就是立体的。

       如果一个按钮在对话框中，那么它就有默认和自动默认的概念，分别由 defaults 属性以及 autoDefault 属性控制，相关的成员函数如下：

[plain] view plain copy print ?
  1. bool isDefault() const;         // 判断按钮是否为默认按钮  
  2. void setDefault(bool on);     // 设置按钮是否为默认按钮  
  3. bool autoDefault() const;    // 判断按钮是否为自动默认按钮  
  4. void setAutoDefault(bool);   // 设置按钮是否为自动默认按钮  
bool isDefault() const;         // 判断按钮是否为默认按钮
void setDefault(bool on);     // 设置按钮是否为默认按钮
bool autoDefault() const;    // 判断按钮是否为自动默认按钮
void setAutoDefault(bool);   // 设置按钮是否为自动默认按钮

        对话框中同一时刻只能有一个默认按钮，当用户按回车键时，等价于在对话框中单击这个按钮。实际上，对话框中还有一个主默认按钮的概念。一个自动默认按钮得到焦点时，就会变成默认那钮；失去焦点时，主默认按钮就成为默认按钮。而设置一个按钮的默认属性为 true 将同时使它成为对话框的主默认按钮。  

QCheckBox 类代表复选钮，它继承了 QAbstractButton 类，因此也有其全部的属性、信号和槽。


        

        构造 

        QCheckBox 支持以下构造函数：

[plain] view plain copy print ?
  1. QCheckBox(QWidget *parent= 0);  
  2. QCheckBox(const QString &text, QWidget *parent = 0);  
QCheckBox(QWidget *parent= 0);
QCheckBox(const QString &text, QWidget *parent = 0);

        其中 text 参数表示要显示的文本。生成的复选钮默认是不排他的。



        属性

        tristate 属性用于控制复选钮是否为三态的，相关的函数函数如下：

[plain] view plain copy print ?
  1. bool isTristate() const;     // 判断是否三态  
  2. void setTristate(bool y = true);    // 设置是否为三态的  
bool isTristate() const;     // 判断是否三态
void setTristate(bool y = true);    // 设置是否为三态的

        三态的复选钮不只有打开和关闭两种状态，其状态由 checkState 属性来代表，相关的成员函数如下：
[plain] view plain copy print ?
  1. Qt::CheckState checkState() const;    // 获得状态  
  2. void setCheckState(Qt::CheckState state);    // 设置是否为三态的  
Qt::CheckState checkState() const;    // 获得状态
void setCheckState(Qt::CheckState state);    // 设置是否为三态的

        这里 Qt::CheckState 是一个枚举类型，它有以下取值。

        1）Qt::Unchecked：未选中。

        2）Qt::PartiallyChecked：部分选中。

        3）Qt::Checked：选中。


        部分选中的状态经常用来表示一个选项树中某个选项的子选项有的选中、有的未选的状态。如果是一个复选钮不是三态的，则也可以用从 QAbstractButton 继承来的 checked 属性操作它的状态。



        信号

        当复选钮的状态发生变化时，将发射以下信号：

[plain] view plain copy print ?
  1. void stateChanged(int state);  
void stateChanged(int state);

        其中参数 state 表示复选钮的新状态。

QRadioButton 类表示单选钮，它继承了 QAbstractButton 类，因此也有其全部的属性、信号和槽。QRadioButton 类支持以下构造函数：

[plain] view plain copy print ?
  1. QRadioButton(QWidget *parent = 0);  
  2. QRadioButton(const QString &text, QWidget *parent = 0);  
QRadioButton(QWidget *parent = 0);
QRadioButton(const QString &text, QWidget *parent = 0);

        其中参数 text 表示要显示的文本。生成的单选钮默认是排他的。


  QLineEdit 类代表编程框，它可以让用户输入一个单行文本。

        


        构造

        QLineEdit 类支持以下构造函数：

[plain] view plain copy print ?
  1. QLineEdit (QWidget *parent = 0);  
  2. QLineEdit(const QString &contents, QWidget *parent = 0);  
QLineEdit (QWidget *parent = 0);
QLineEdit(const QString &contents, QWidget *parent = 0);

        其中 contents 表示编辑框中显示的内容。



        属性

        alignment 属性表示显示文本的对齐方式，相关成员函数如下：

[plain] view plain copy print ?
  1. int maxLength() const;                                    // 获取最大输入长度  
  2. void setMaxLength(Qt::Alignment flag) const;      // 设置对齐方式  
int maxLength() const;                                    // 获取最大输入长度
void setMaxLength(Qt::Alignment flag) const;      // 设置对齐方式

        它的含义与 QLabel 类的 alignment 属性相同。

        maxLength 属性表示编辑框可以容许的最大输入长度，相关成员函数如下：

       

[plain] view plain copy print ?
  1. int maxLength() const;                                   // 获取最大输入长度  
  2. void setMaxLength(int len);                            // 设置最大输入长度  
int maxLength() const;                                   // 获取最大输入长度
void setMaxLength(int len);                            // 设置最大输入长度

        readOnly 属性表示编辑框的内容是否为只读的，即内容是否可以被用户修改，相关成员函数如下：
[plain] view plain copy print ?
  1. bool isReadOnly() const;                               // 判断是否为只读的  
  2. void setReadOnly(bool on);                             // 判断是否为只读的   
bool isReadOnly() const;                               // 判断是否为只读的
void setReadOnly(bool on);                             // 判断是否为只读的

        text 属性表示编辑框的内容，相关的成员函数如下：
[plain] view plain copy print ?
  1. QString text() const;                                    // 获取编辑框的内容  
  2. void setText(const QString &text);                 // 设置编辑框的内容，这是一个槽  
QString text() const;                                    // 获取编辑框的内容
void setText(const QString &text);                 // 设置编辑框的内容，这是一个槽
 
        其中 setText 函数同时也是一个槽。要注意编辑框的内容不一定就是编辑框显示的内容，比如一个密码输入编辑框，用户输入的密码是不显示出来的。如果要得到编辑框的内容，则需使用下民的成员函数：   
[plain] view plain copy print ?
  1. QString displayText() const;    // 得到显示的内容  
QString displayText() const;    // 得到显示的内容

       frame 属性控制编辑框有没有边框，相关成员函数如下：
[plain] view plain copy print ?
  1. bool hasFrame() const;    // 判断有没有边框  
  2. void setFrame(bool on);   // 设置有没有边框  
bool hasFrame() const;    // 判断有没有边框
void setFrame(bool on);   // 设置有没有边框

       下面两个成员函数虽然不是属性，但也与文本的显示有关：
[plain] view plain copy print ?
  1. void setTextMargins(int left, int top, int right,int bottom);    // 设置边距  
  2. void getTextMargins(int *left, int *top, int *right, int *botton);     // 获取边距  
void setTextMargins(int left, int top, int right,int bottom);    // 设置边距
void getTextMargins(int *left, int *top, int *right, int *botton);     // 获取边距

       这两个函数分别用于设置和获取文本显示的边距，上、下、左、右 4 个边距可以独立进行设置。



        信号

        当编辑框的内容发生变化时，将发射以下信号：

[plain] view plain copy print ?
  1. void textChanged(const QString &text);  
void textChanged(const QString &text);

        其中参数 text 是发生变化后的内容。

        当编辑框的内容被编辑时，将发射以下信号：

[plain] view plain copy print ?
  1. void textEdited(const QString &text);  
void textEdited(const QString &text);

        其中参数 text 是编辑后的内容。它与 textChanged 信号的主要区别在于，它只是在用户进行修改的时候发射，在程序中用 setText 修改时则不发射，而后者则在两种情况下都会发射。

         当在编辑框中按下回车键时，将发射以下信号：

[plain] view plain copy print ?
  1. void returnPressed();  
void returnPressed();

         这个信号将在按下回车键或者编辑框失去焦点时发射。

   

         

         槽

         调用下面的槽可以清空编辑框中的内容：

[plain] view plain copy print ?
  1. void clear(); 

你可能感兴趣的:(QT)

  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • esp32开发快速入门 8 : MQTT 的快速入门，基于esp32实现MQTT通信 z755924843 ESP32开发快速入门服务器网络运维
    MQTT介绍简介MQTT（MessageQueuingTelemetryTransport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的"轻量级"通讯协议，该协议构建于TCP/IP协议上，由IBM在1999年发布。MQTT最大优点在于，可以以极少的代码和有限的带宽，为连接远程设备提供实时可靠的消息服务。作为一种低开销、低带宽占用的即时通讯协议，使其在物联
  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程 极客小张 stm32qt机器人物联网人机交互毕业设计c语言
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
  • ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能 小康师兄 ESP32-C3入门教程https服务器esp32OTAMQTT
    文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
  • 漫谈QWidget及其派生类(二) Caiaolun
    原文地址:https://blog.csdn.net/dbzhang800/article/details/6741344上一部分漫谈QWidget及其派生类(一)介绍了QWidget及其派生类,分：窗口、普通控件两种类型(其实有个Qt::SubWindow没有提，不过本系列中也没有介绍它的打算，因为我不熟)。本文接下来试图看看QLayout与窗口的几何尺寸控制。注意：本文只是试图解释，QLayo
  • 【解决内存泄漏的问题】 Qt 框架中的父子对象关系会自动管理内存，父对象会在其销毁时自动销毁所有子对象。 课堂随想 QTqt
    修改前的代码这段代码可能会出现内存泄漏问题，主要原因是构造函数中创建的LoginDialog和RegisterDialog对象未在合适的地方被正确释放。具体分析如下：1.构造函数中的问题_login_dlg=newLoginDialog();setCentralWidget(_login_dlg);_login_dlg->show();connect(_login_dlg,&LoginDialog
  • MacOS Catalina 从源码构建Qt6.2开发库之01: 编译Qt6.2源代码 捕鲸叉 QTmacosc++QT
    安装xcode，cmake，ninjabrewinstallnodemac下安装OpenGL库并使之对各项目可见在macOS上安装OpenGL通常涉及到安装一些依赖库，如MGL、GLUT或者是GLEW等，同时确保LLVM的OpenGL框架和相关工具链的兼容性。以下是一个基本的安装步骤，你可以在终端中执行：安装Homebrew（如果还没有安装的话）：/bin/bash-c"$(curl-fsSLht
  • Linux删除监听端口进程,linux只端口监听及杀死进程 探旅 Linux删除监听端口进程
    itextpdf生成pdf文件一.简介itextpdf是一个开源的允许你去创建和操作PDF文档的库.它使的开发者可以提高web和其他应用来动态地生成或操作PDF文档.通过iText中的Document和PdfWriter类,...QtSizePolicy属性控件的sizePolicy说明控件在布局管理中的缩放方式.Qt提供的控件都有一个合理的缺省sizePolicy,但是这个缺省值有时不能适合所有
  • Pyqt5实现listwidget自定义右键菜单 Saudade957 pyqt5前端前端python编程语言
    Pyqt5实现listwidget自定义右键菜单基于网上搜到的各种教程失败以后（ps:可能有的可以成功，但是我都没成功），组合了一下一些代码最终成功实现相关内容。首先在ui文件生成的py文件中添加self.listWidget.setContextMenuPolicy(Qt.CustomContextMenu)self.listWidget.customContextMenuRequested.c
  • 【十八】【QT开发应用】标签页QTabWidget的常见用法 妖精七七_ QT开发应用qt开发语言
    #include"widget.h"//包含自定义的widget头文件#include//包含QHBoxLayout头文件，用于水平布局#include//包含QTabWidget头文件，用于创建标签页控件#include//包含QDebug头文件，用于调试输出widget::widget(QWidget*parent)//widget类的构造函数:QWidget(parent)//调用基类QWi
  • python做窗口软件界面绑定py程序_PyCharm GUI界面开发和exe文件生成的实现 weixin_39948442
    一、安装Python二、安装PyQt5推荐使用pip安装：win+R调出cmd命令窗口pipinstallPyQt5等待片刻，继续安装PyQt5-toolspipinstallPyQt5-tools如果直接pip不成功的话，建议在python库这个网站上搜索相关库，下载相应的.whl文件，然后用以下方法进行安装：①pipwhl文件所在路径whl文件名②在cmd命令窗口先执行cdwhl文件所在路径到
  • QT 自定义组件 界面跳转 子座 qt数据库开发语言
    一、引用组件需要的类（头文件）1、按钮类QPushButton:普通按钮;QToolButton:工具按钮;QRadioButton:单选按钮;QCheckBox:复选按钮;QCommandLinkButton:命令连接按钮;2、布局类QHBoxLayout水平QVBoxLayout垂直QGridLayout网格QFormLayout表单QSrackedLayout.堆栈3、输出类QLabel:标
  • 【QT教程】QT6硬件图形界面编程 QT硬件编程 QT性能优化QT原理源码QT界面美化 qtqt6.3qt5c++QT教程
    QT6硬件图形界面编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6硬件图形界面编程概述1.1QT6硬件图形界面编程简介1.1.1QT6硬件
  • 【Qt】之【Bug】LNK2019: 无法解析的外部符号 __imp_FindWindowW Htht111 Qtbugqtbug开发语言
    QTerror:LNK2019:无法解析的外部符号__imp__SendMessageW@类型的错误以及pragmacomment的作用（用法）添加头文件出错的cpp文件加入以下代码#pragmacomment(lib,"User32.lib")ps：尝试pro添加-lUser32，没用
  • Qt QTableWidget 触摸屏上滑动效果 hss2799 Qt
    要实现QTableWidget在触摸屏上，滑动记录，记录会跟着滑动，只需要加QScroller*pScroller=QScroller::scroller(tablewidget);pScroller->grabGesture(tablewidget,QScroller::LeftMouseButtonGesture);tablewidget->setVerticalScrollMode(QLis
  • QT与Python混合编程经验记录 weixin_30237281 python人工智能c/c++
    1、如何embeddingpython,Python文档中有专门一章阐述https://docs.python.org/3.5/extending/embedding.htm；1、库文件：在vs--c/c++--附加包含文件中添加目；链接中也要添加，：将python中的include,libs二个目录添加进来2、对于Python，没有调试库，可直接将运行库复制一份，名称后面加上_d，就可用，可不能
  • QMQTT在项目中的用法 好学松鼠 c++qt
    在一次项目实践中，需要使用MQTT协议向服务器发送数据，经过了解之后MQTT协议底层是基于TCP协议的。正好使用QT在开发项目，就在网上搜索了MQTT相关的开源三方库，因此就找到了基于QT的QMQTT的库。QMQTT库的源码可以再github或者gitee上获取到，具体的用法如下：1、初始化QMQTT#include"qmqtt.h"//服务器IP端口QMQTT::Client*client=ne
  • C# Linq语句用法大全以及Lambda表达式 一个小码码 c#linq开发语言.net
    C#Linq语句用法大全以及Lambda表达式Linq：是一种用于数据查询和操作的语言集成查询（LanguageIntegratedQuery）技术。通过Linq，我们可以使用类似于SQL查询的方式来查询、筛选和操作各种类型的数据集合，包括数组、列表、集合、XML文档、数据库表等等。常见的有：LinqtoObjects：用于操作对象集合，例如数组、列表等。LinqtoXML：用于操作XML数据，支
  • 4G MQTT网关在物联网应用中的优势-天拓四方 北京天拓四方 边缘计算iot物联网其他
    随着物联网（IoT）技术的飞速发展，各种设备和系统之间的互联互通变得日益重要。MQTT（MessageQueuingTelemetryTransport）作为一种轻量级的发布/订阅消息传输协议，因其高效、可靠、简单的特性，在物联网领域得到了广泛的应用。而4GMQTT网关，作为连接物联网设备和MQTT服务器的桥梁，其在物联网应用中的作用愈发凸显。本文将探讨4GMQTT网关在物联网应用中的优势。4GM
  • Linux 帧缓存 数据,嵌入式Linux通过帧缓存截图 – Framebuffer Screenshot in Embedded Linux... weixin_39578674 Linux帧缓存数据
    嵌入式Linux通过帧缓存截图–EmbeddedLinuxFramebufferScreenshot【目的】板子上已经可以运行Qtopia的demo和example了，想要将其qt的demo程序的画面截取下来，给其他人看。最原始的方法就是，找个相机，对着板子照几张即可。另外的办法，通过framebuffer去截图，截取运行中的qtdemo的画面，效果会更好，图片也更清晰。【解决过程】1.将fram
  • Qt控件编辑功能(二) 雨田哥工作号
    简述根据QtDesigner的控件选中，拉伸效果，用过Qt的盆友都很熟悉Qt的Designer，这个我就不多说了，我们先看看QtDesigner中的效果QtDesigner效果图图这里写图片描述模仿功能介绍1.支持选中效果；2.支持自由拉伸效果；3.支持双击鼠标左键编辑功能；4.支持键盘↑↓←→按键移动；5.支持按住ctrl+鼠标左键多选控件功能；6.支持键盘delete键，删除选中控件功能；模仿
  • Qt框架在跨平台应用开发中的优势 NewmanEdwarda2 qt开发语言
    随着软件技术的不断发展，跨平台应用开发已成为软件开发领域的一个重要趋势。在众多跨平台开发框架中，Qt因其强大的功能和灵活性而备受开发者的青睐。本文将从多个方面详细探讨Qt框架在跨平台应用开发中的优势。一、跨平台兼容性Qt框架最显著的优势之一就是其卓越的跨平台兼容性。Qt支持多种操作系统，包括Windows、Linux、macOS、Android、iOS等，使得开发者能够使用同一套代码库为不同平台开
  • EG边缘计算网关连接中移ONENET物联网平台（MQTT协议） 成都纵横智控科技官方账号 边缘计算网关物联网工业网关边缘计算物联网MQTT中移ONENET
    上文：EG边缘计算网关连接阿里云物联网平台（MQTT协议）需求概述本章节主要实现一个流程：EG8200mini采集ModbusRTU数据，通过MQTT协议连接中移ONENET物联网平台ModbusRTU采集此处不做过多赘述，可参考其他案例（串口读取Modbus传感器数据）介绍。下文默认已经采集到ModbusRTU数据。要采集的Modbus点位表：地址(Doc)数据类型属性名称00001Boolea
  • qt 创建随机数 入梦游 qt
    qt中有两种创建随机数的方法，一种是旧方法，一种是新方法目录旧方法：已过时intqrand（）voidqsrand（uintseed）Example新方法QRandomGenerator::global()->bouned(inthighest)QRandomGenerator::global()->generate()更多旧方法：已过时intqrand（）生成一个伪随机数，可以使用qsrand（
  • Qt控件提升为自定义类 虾米小小小 Qt
    今天在提升QLabel控件为自定义控件时，发现弹出的对话框里没有直接出现我的新Label类，后来手动填写自定义类名才添加上去，后边还出现“Notused”，吓我一跳，不过还好能识别。像QtCreator中UI界面中的奇葩问题也还遇到过几个，比如在UI界面拖拽控件调整位置时，有时控件会突然隐藏，不管怎么选都选不中，不过右侧列表中还有控件名称，直接剪切复制也就出来了，Crtl+Z都不行，你说气不气；还
  • 【项目实践】Pyside6+Qtdesigner：登录窗体设计 climber1121 Python项目实战QT数据库python
    代码功能：可实现应用程序用户管理，实现用户登录、注册、密码修改代码文档结构：user_database.db：数据库文件，用于存储用户数据，第一运行代码时自动生成login.ui：UI文件，由QT设计ui_login.py（由login.ui编译过来）在终端WindowsPowerShell运行如下代码即可生成pyside6-uiclogin.ui-oui_login.pytest_login.p
  • Ubuntu+Qt+SDL2+FFmpeg DarcyZhou
    此文档用于Ubuntu系统中搭建FFmpeg的开发环境。Qt作为开发软件，SDL2是一套开放源代码的跨平台多媒体开发库。1.安装Qt（1）下载版本：qt-opensource-linux-x64-5.9.8.runimage.png（2）安装给文件添加可执行权限：sudochmod-R777qt-opensource-linux-x64-5.9.8.run开始安装：安装过程中选择全部安装即可。（需
  • python pyqt5 设置控件随窗体拉伸 SkTj
    2#--coding:utf-8--'''【简介】布局中用到的addStretch函数例子'''fromPyQt5.QtWidgetsimportQApplication,QWidget,QVBoxLayout,QHBoxLayout,QPushButtonimportsysclassWindowDemo(QWidget):definit(self):super().init()btn1=QPus
  • QT进行音频录制 金博客 Qtqt音视频c++
    文章目录QT使用`AudioRecorder`进行音频录制首先，确保你的项目文件`.pro`包含多媒体模块：然后，在Qt应用程序中，创建Widget类：小结QT使用AudioRecorder进行音频录制使用Qt框架的AudioRecorder类进行音频录制，可以通过Qt的MultimediaWidgets模块实现。‌首先，确保你的Qt项目中包含了MultimediaWidgets模块‌。这通常在项
  • knob UI插件使用 换个号韩国红果果 JavaScriptjsonpknob
    图形是用canvas绘制的 js代码 var paras = { max:800, min:100, skin:'tron',//button type thickness:.3,//button width width:'200',//define canvas width.,canvas height displayInput:'tr
  • Android+Jquery Mobile学习系列(5)-SQLite数据库 白糖_ JQuery Mobile
    目录导航   SQLite是轻量级的、嵌入式的、关系型数据库，目前已经在iPhone、Android等手机系统中使用,SQLite可移植性好，很容易使用，很小，高效而且可靠。   因为Android已经集成了SQLite，所以开发人员无需引入任何JAR包，而且Android也针对SQLite封装了专属的API，调用起来非常快捷方便。   我也是第一次接触S
  • impala-2.1.2-CDH5.3.2 dayutianfei impala
    最近在整理impala编译的东西，简单记录几个要点： 根据官网的信息（https://github.com/cloudera/Impala/wiki/How-to-build-Impala）： 1. 首次编译impala，推荐使用命令： ${IMPALA_HOME}/buildall.sh -skiptests -build_shared_libs -format 2.仅编译BE ${I
  • 求二进制数中1的个数 周凡杨 java算法二进制
    解法一： 对于一个正整数如果是偶数，该数的二进制数的最后一位是 0 ，反之若是奇数，则该数的二进制数的最后一位是 1 。因此，可以考虑利用位移、判断奇偶来实现。   public int bitCount(int x){ int count = 0; while(x!=0){ if(x%2!=0){ /
  • spring中hibernate及事务配置 g21121 Hibernate
    hibernate的sessionFactory配置： <!-- hibernate sessionFactory配置 --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <
  • log4j.properties 使用 510888780 log4j
    log4j.properties 使用 一.参数意义说明 输出级别的种类 ERROR、WARN、INFO、DEBUG ERROR 为严重错误 主要是程序的错误 WARN 为一般警告，比如session丢失 INFO 为一般要显示的信息，比如登录登出 DEBUG 为程序的调试信息 配置日志信息输出目的地 log4j.appender.appenderName = fully.qua
  • Spring mvc-jfreeChart柱图（2） 布衣凌宇 jfreechart
    上一篇中生成的图是静态的，这篇将按条件进行搜索，并统计成图表，左面为统计图，右面显示搜索出的结果。 第一步：导包 第二步；配置web.xml(上一篇有代码) 建BarRenderer类用于柱子颜色 import java.awt.Color; import java.awt.Paint; import org.jfree.chart.renderer.category.BarR
  • 我的spring学习笔记14-容器扩展点之PropertyPlaceholderConfigurer aijuans Spring3
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。 PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java
  • maven 之 cobertura 简单使用 antlove maventestunitcoberturareport
    1. 创建一个maven项目 2. 创建com.CoberturaStart.java package com; public class CoberturaStart { public void helloEveryone(){ System.out.println("=================================================
  • 程序的执行顺序 百合不是茶 JAVA执行顺序
          刚在看java核心技术时发现对java的执行顺序不是很明白了,百度一下也没有找到适合自己的资料,所以就简单的回顾一下吧   代码如下;     经典的程序执行面试题 //关于程序执行的顺序 //例如： //定义一个基类 public class A(){ public A(
  • 设置session失效的几种方法 bijian1013 web.xmlsession失效监听器
    在系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session。具体设置很简单，方法有三种：（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);参数900单位是秒，即在没有活动15分钟后，session将失效。这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所
  • java jvm常用命令工具 bijian1013 javajvm
    一.概述         程序运行中经常会遇到各种问题，定位问题时通常需要综合各种信息，如系统日志、堆dump文件、线程dump文件、GC日志等。通过虚拟机监控和诊断工具可以帮忙我们快速获取、分析需要的数据，进而提高问题解决速度。 本文将介绍虚拟机常用监控和问题诊断命令工具的使用方法，主要包含以下工具:       &nbs
  • 【Spring框架一】Spring常用注解之Autowired和Resource注解 bit1129 Spring常用注解
    Spring自从2.0引入注解的方式取代XML配置的方式来做IOC之后，对Spring一些常用注解的含义行为一直处于比较模糊的状态，写几篇总结下Spring常用的注解。本篇包含的注解有如下几个： Autowired Resource Component Service Controller Transactional 根据它们的功能、目的，可以分为三组，Autow
  • mysql 操作遇到safe update mode问题 bitray update
        我并不知道出现这个问题的实际原理,只是通过其他朋友的博客,文章得知的一个解决方案,目前先记录一个解决方法,未来要是真了解以后,还会继续补全.     在mysql5中有一个safe update mode,这个模式让sql操作更加安全,据说要求有where条件,防止全表更新操作.如果必须要进行全表操作,我们可以执行 SET
  • nginx_perl试用 ronin47 nginx_perl试用
    因为空闲时间比较多，所以在CPAN上乱翻，看到了nginx_perl这个项目(原名Nginx::Engine)，现在托管在github.com上。地址见：https://github.com/zzzcpan/nginx-perl 这个模块的目的，是在nginx内置官方perl模块的基础上，实现一系列异步非阻塞的api。用connector/writer/reader完成类似proxy的功能（这里
  • java-63-在字符串中删除特定的字符 bylijinnan java
    public class DeleteSpecificChars { /** * Q 63 在字符串中删除特定的字符 * 输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。 * 例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.” */ public static voi
  • EffectiveJava--创建和销毁对象 ccii 创建和销毁对象
    本章内容： 1. 考虑用静态工厂方法代替构造器 2. 遇到多个构造器参数时要考虑用构建器（Builder模式） 3. 用私有构造器或者枚举类型强化Singleton属性 4. 通过私有构造器强化不可实例化的能力 5. 避免创建不必要的对象 6. 消除过期的对象引用 7. 避免使用终结方法 1. 考虑用静态工厂方法代替构造器     类可以通过
  • [宇宙时代]四边形理论与光速飞行 comsci
       从四边形理论来推论 为什么光子飞船必须获得星光信号才能够进行光速飞行？    一组星体组成星座  向空间辐射一组由复杂星光信号组成的辐射频带，按照四边形-频率假说  一组频率就代表一个时空的入口    那么这种由星光信号组成的辐射频带就代表由这些星体所控制的时空通道，该时空通道在三维空间的投影是一
  • ubuntu server下python脚本迁移数据 cywhoyi pythonKettlepymysqlcx_Oracleubuntu server
    因为是在Ubuntu下，所以安装python、pip、pymysql等都极其方便，sudo apt-get install pymysql， 但是在安装cx_Oracle（连接oracle的模块）出现许多问题，查阅相关资料，发现这边文章能够帮我解决，希望大家少走点弯路。http://www.tbdazhe.com/archives/602 1.安装python 2.安装pip、pymysql
  • Ajax正确但是请求不到值解决方案 dashuaifu Ajaxasync
    Ajax正确但是请求不到值解决方案   解决方案：1 .     async: false ,    2.     设置延时执行js里的ajax或者延时后台java方法！！！！！！！   例如：   $.ajax({     &
  • windows安装配置php+memcached dcj3sjt126com PHPInstallmemcache
    Windows下Memcached的安装配置方法 1、将第一个包解压放某个盘下面，比如在c:\memcached。 2、在终端（也即cmd命令界面）下输入 'c:\memcached\memcached.exe -d install' 安装。 3、再输入： 'c:\memcached\memcached.exe -d start' 启动。（需要注意的: 以后memcached将作为windo
  • iOS开发学习路径的一些建议 dcj3sjt126com ios
    iOS论坛里有朋友要求回答帖子，帖子的标题是： 想学IOS开发高阶一点的东西，从何开始，然后我吧啦吧啦回答写了很多。既然敲了那么多字，我就把我写的回复也贴到博客里来分享，希望能对大家有帮助。欢迎大家也到帖子里讨论和分享，地址：http://bbs.csdn.net/topics/390920759   下面是我回复的内容：   结合自己情况聊下iOS学习建议，
  • Javascript闭包概念 fanfanlovey JavaScript闭包
    1.参考资料 http://www.jb51.net/article/24101.htm http://blog.csdn.net/yn49782026/article/details/8549462 2.内容概述 要理解闭包，首先需要理解变量作用域问题 内部函数可以饮用外面全局变量 var n=999; 　　functio
  • yum安装mysql5.6 haisheng mysql
    1、安装http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm   2、yum install mysql   3、yum install mysql-server   4、vi /etc/my.cnf   添加character_set_server=utf8
  • po/bo/vo/dao/pojo的详介 IT_zhlp80 javaBOVODAOPOJOpo
        JAVA几种对象的解释 PO:persistant object持久对象,可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作. VO:value object值对象。通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可
  • java设计模式 kerryg java设计模式
    设计模式的分类：    一、 设计模式总体分为三大类： 1、创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。 2、结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。 3、行为型模式（11种）：策略模式，模版方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者
  • [1]CXF3.1整合Spring开发webservice——helloworld篇 木头.java springwebserviceCXF
    Spring 版本3.2.10 CXF 版本3.1.1 项目采用MAVEN组织依赖jar 我这里是有parent的pom，为了简洁明了，我直接把所有的依赖都列一起了，所以都没version，反正上面已经写了版本 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
  • Google 工程师亲授：菜鸟开发者一定要投资的十大目标 qindongliang1922 工作感悟人生
    身为软件开发者，有什么是一定得投资的？ Google 软件工程师 Emanuel Saringan 整理了十项他认为必要的投资，第一项就是身体健康，英文与数学也都是必备能力吗？来看看他怎么说。（以下文字以作者第一人称撰写）） 你的健康 无疑地，软件开发者是世界上最久坐不动的职业之一。 每天连坐八到十六小时，休息时间只有一点点，绝对会让你的鲔鱼肚肆无忌惮的生长。肥胖容易扩大罹患其他疾病的风险，
  • linux打开最大文件数量1,048,576 tianzhihehe clinux
    File descriptors are represented by the C int type. Not using a special type is often  considered odd, but is, historically, the Unix way. Each Linux process has a maximum number of files th
  • java语言中PO、VO、DAO、BO、POJO几种对象的解释 衞酆夼 javaVOBOPOJOpo
    PO:persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。 BO:business object业务对象 封装业务逻辑的java对象
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他