类

qt中的类：参考博文：https://blog.csdn.net/qq_36449541/article/details/79151764

使用Qt进行编程必须对 Qt 中常用的类有一定的了解。这些类可以分成两种：一种不是从 QObject 类派生出来的，用来表示各种基本的数据对象，如字符串、图像、字体等，这里将它们通称为基本类；另一种都是从 QWidget 类派生出来的，它们表示一个顶级窗口或者窗口部件，这里将它们统称为窗口类。      
        这里介绍的基本类包括 QChar， QString， QPoint， QSize， QRect， QFont， QPixmap， Qlcon。
        这里介绍的窗口类包括 QWidget，QDialog，QLabel，QAbstratacButton，QPushButton， QCheckBox，QRadioButton，QLineEdit
一、基本类

1、QChar
        QChar 类是 Qt 中用于表示一个字符的类，实现在 QtCore 共享库中。QChar 类内部用2个字节的Unicode编码来表示一个字符。      
    a.  构造
        QChar 类提供了多个不同原型的构造函数以方便使用，如：
查看文本打印
    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类作为参数的地方都可以安全地使用各种整数类型。
      b. 判断
       QChar 类提供了很多成员函数，可以对字符的类型进行判断，如：
    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;         // 判断是否是分隔符，包括空格等 
       c.转换
       QChar 类提供了一些成员函数进行数据的转换，如：
    char toAscii() const;           // 得到字符的ASCII码  
    QChar toLower() const;    // 转换成小写字母  
    QChar toUpper() const;    // 转换成大写字母  
    ushort unicode() const;    // 得到Unicode编码  
注意这几个函数都不会改变对象自身，转换的结果通过返回值反映出来。
      d.比较
      Qt 中定义了一些与 QChar 类相关的比较操作符， 如：
    bool operator !=& nbsp; (QChar c1, QChar c2);    // 判 断 c1 是否不等于 c2  
    bool operator <  (QChar c1, QChar c2);     //  判断  c1 是否小于 c2  
    bool operator <=& nbsp;(QChar c1, QChar c2);   // 判 断 c1 是否小于等于 c2  
    bool operator == (QChar c1, QChar c2);   // 判断 c1 是否等于c2  
    bool operator >  (QChar c1, QChar c2);    // 判 断 c1 是否大于 c2  
    bool operator >= (QChar c1, QChar c2);   // 判断  c1是否大于等于 c2  
2、QString

QString 类是 Qt 中用于表示字符串的类，实现在 QtCore 共享库中。QString 类在实现上有以下特征。
      1）字符串采用 Unicode 内部编码，可以表示世界上大多数语言的文字。
      2）字符串的存储有引用计数，当一个 QString 对象被复制为另一个 QString 对象时，它们实际上指向相同的存储空间，仅仅是增加一个引用计数。
      3）采用 “按需复制” 的技术，当指向相同存储空间的多个 QString 对象中的一个要被修改时，将真正复制一个新的字符串并进行修改。
       a.构造
       QString 类提供了很多不同原型的构造函数以方便使用。如：
    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 对象或普通的字符串。
       b.判断 
       可以用下面的成员函数判断 QString 对象是否为空字符串：
    bool isEmpty() const;    // 判断是否为空字符串  
       c.转换
       QString 类提供了很多函数用于将字符串转换为数值，如：
    double toDouble(bool *ok =& nbsp;0) const;                                     //  转换为高精度浮点数  
    float toFloat(bool *ok =& nbsp;0) cosnt;                                          //  转换为浮点数  
    int toInt(bool *ok, int base =& nbsp;10) const;                                 //  转换为整型数  
    long toLong(bool *ok, int base =& nbsp;10) cosnt;                            //  转换为长整型  
    short toShort(bool *ok, int base =& nbsp;10) const;                          //  转换为短整型  
    uint toUInt(bool *ok =& nbsp;0; int base = 10) const   & nbsp;                     //  转换为无符号整型数  
    ulong toLong(bool *ok =& nbsp;0, int base = 10) const;  & nbsp;                  //  转换为无符号长整型数   
    ushort toUShort(bool *ok =& nbsp;0, int base = 10) const;  & nbsp;              //  转换为无符号短整型数  
       这些函数能够解析 QString 对象的内容，将其转换为相应的数值。其中 ok 参数指向一个 bool 型变量， 这个参数用于输出转换是否成功的信息。base参数则是转换为整数类型时的基。这些函数都不会改变 QString 对象自身。 
注意： 当字符串以 0x开头时，转换的基自动转换为16， 当字符串以0开头时，转换的基自动为8。
       下面这些成员函数可以将一个数值转换为字符串并设为 QString 对象的值：
    QString &setNum(int n, int base =& nbsp;10);                                           //  整型数  
    QString &setNum(uint n, int base =& nbsp;10);                                         //  无符号整型数  
    QString &setNum(long n, int base =& nbsp;10);                                        //  长整型  
    QString &setNum(ulong n, int base =& nbsp;10);                                       //  无符号长整型数  
    QString &setNum(short n, int base =& nbsp;10);                                       //  短整型数  
    QString &setNum(ushort n, int base =& nbsp;10);                                      //  无符号短整型数  
    QString &setNum(double n, char format =& nbsp;'g', int precision = 6);   & nbsp;      // 高精度浮点数  
    QString &setNum(float n, char format =& nbsp;'g', int precision = 6);   & nbsp;        // 浮点 数  
       将浮点数转换为字符串时，format 参数指定转化格式，precision 参数指定转换结果的精度，既有效数组的个数。注意这些函数会改变 QString 对象本身的值，而以下的函数则采用了不同的做法，它们返回一个新的临时对象以供使用：
    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 类也提供了大小写转换的函数，如：
    QString toLower() const;    // 转换为小写  
    QString toUpper() const;    // 转换为大写  
       这些函数都不会改变 QString 对象本身，而是将转换后的结果作为返回值。

      d. 比较
       QString 类提供了一个函数用于两个 QString 对象的比较：
    int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive);  
这是一个静态成员函数，它可以比较 s1 和 s2 的大小，参数 cs 有以下两个取值。
    Qt::CaseInsensitive： 表示对大小写不敏感  
    Qt::Casesensitive ：    表示对大小写敏感  

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

       为了方便使用，QString 类还提供了以下重载函数用于比较：
    int compare(const QString &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  

      这个函数用于比较 QString 对象自身和 QString 对象 other。      实际上更为直观的是使用 QString 类的比较操作符，如：
    bool operator <  (StringType other) const;        //  比较是否小于 other人  
    bool operator <=& nbsp; (StringType other) const;      //  比较是否小于等于 other  
    bool operator ==& nbsp; (StringType other) const;      //  比较是否等于 other  
    bool operator >  (StringType other) constt;       //  比较是否大于 other  
    bool operator >=& nbsp; (StringType other) const;      //  比较是否大于等于 other  
    bool operator !=& nbsp; (StringType other) const;       //  比较是否不等于 other  
      这里的 StringType 指的是 （const QString &）或 （const char *），也就是说，这些操作既可以与 QString 对象比较，也可以与普通的字符串比较。它们的局限性是第一个操作数必须是 QString 对象，因此，Qt 中又定义了以下操作符：
    bool operator <  (const char *s1, const QString &s2);                 //  比较 s1 是否小于 s2  
    bool operator <=& nbsp; (const char *s1, const QString &s2);               //  比较 s1 是否小于等于 s2  
    bool operator ==& nbsp; (const char *s1, const QString &s2);               //  比较 s1 是否等于 s2  
    bool operator >  (const char *s1, const QString &s2);                 //  比较 s1 是否大于 s2  
    bool operator >=& nbsp; (const char *s1, const QString &s2);               //  比较 s1 是否大于等于 s2  
    bool operator !=& nbsp; (const char *s1, const QString &s2);                //  比较 s1 是否不等于 s2  
       这些操作符不是 QString 类的成员，它们的第一个参数是普通字符串
       e.查找
       用以下的成员函数可以判断 QString 对象是否包含指定的字符串或字符：
    bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;        
    bool contains(cosnt ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
        用以下的成员函数可以得到 QString 对象包含某个特定字符串或字符的个数：
    int count(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
    int count(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;  
        用以下的成员函数可以得到 QString 对象中某个特定字符串或字符出现的位置：
    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 类中还有与此功能相似的函数用于从后往前查找字符串或字符：
    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 ;
        f.字符串处理
 QString  类支持用赋值操作符进行对象的复制，其赋值操作符的声明如下：    
    QString &operator = (const QString &other);        // 复制另外一个 QString 对象  
    QString &operator = (const char *str);               // 复制普通字符串  
    QString &operator = (char ch);                         // 复制字符  
    QString &operator = (QChar ch);                       // 复制 QChar 类对象  
        以下的成员函数可以将另一个字符串或字符接在 QString 对象后面，形成一个整体的字符串：
    QString &append(const QString &str);                // 接续 QString 对象  
    QString &append(const char *str);                    // 接续普通字符串  
    QString &append(QChar ch);                            // 接续 QChar 对象   
        它们的返回值是 QString 对象自己的引用，也就是说，可以用在这个返回值再次调用成员函数，形成连续的字符串接续操作。
        为了让代码更直观， QString 类中还定义了一个操作符用于字符串的接续：
    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 对象连接起来，但是接在原字符串的前面：
    QString &prepend(const QString &str);          // 在前面接续 QString 对象  
    QString &prepend(const char *str);              // 在前面接续普通字符串  
    QString &prepend(QChar ch);                      // 在前面接续 QChar 对象  
       功能更一般化的是在 QString 对象的任意位置插入另一个字符串或字符，如：
    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 对象中的一部分，如：
    QString &remove(int position, int n);        
       这个函数可以移除 QString 对象中从位置 position 开始的 n 个字符，

下面两个成员函数则可以从 QString 对象中移除指定的字符串或字符：
    QString &remove(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive);  
    QString &remove(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive);  

       以下是 QString 对象的替换操作：
    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 对象表示。
      以下成员函数则可以搜索指定的字符串或字符并开始替换：
    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 对象的内容，使之成为空字符串。
    void clear();  
       而下面这个成员函数可以截断 QStrring 对象，也就是去掉指定位置后的所有内容：
    void truncate(int position);      // 从位置 position 截断，位置从0开始编号  
       下面这个成员函数可以截掉 QString 对象最后的若干个字符：
    void chop(int n);     // 截掉最后的 n个字符  
        以下几个成员函数可以得到 QString 对象的子字符串
    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 对象中头部和尾部的空白字符：
    QString trimmed() const;      
        空白字符包括空格、回车、换行、制表符等字符。

下面这个成员函数不仅能去掉 QString 对象头尾的空白字符，还能将中间的连续多个空白字符全部替换成一个空格：
    QString simlified() const;  
        加法操作符可以将两个字符串或字符连接起来并以 QString 临时对象的方式返回
    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 类的成员。     

g. 索引
        QString 类也像普通的字符串一样可以根据下标得到某个位置上的字符：
    const QChar at(int position) const;  

        这是一个成员函数，更直观的方法是用以下的操作符：
    const QChar operator[] (int position) const;  
    const QChar operator[] (uint position) const;  
         这样对 QString 对象的取字符操作就类似于对一个字符数组的操作。

事实上，通过【】操作符得到的字符还可以被修改，要用到另外两个重载的【】操作符：
    QCharRef operator[] (int position);  
    QCharRef operator[] (uint position);  
  返回的 QCharRef 类是一个辅助类，对它的修改将反映到原字符串中去。
         h.统计
         以下两个成员函数都可以得到 QString 对象中字符的个数：
    int size() const;  
    int length() const;  
         注意字符的个数并不一定等于字节数。

3、QPoint

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

   a.构造

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

    QPoint();    // a.构造横纵坐标均为 0 的 QPoint 对象 

    QPoint(int x, int y); // a.构造横纵坐标分别为 x 和 y 的 QPoint 对象 

    b.属性

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

    int &rx();    // 得到横坐标的引用 

    int &ry();    // 到到纵坐标的引用 

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

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

    void setX(int x);    // 设置横坐标为 x 

    void setY(int y);    // 设置纵坐标为 y 

     下面两个成员函数则是只读的，可以获得 QPoint 对象中的横纵坐标：

    int x() const;    // 获得横坐标 

    int y() const;    // 获得纵坐标 

     c.操作符

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

    QPoint &operator+=(const QPoint &point);    // 加赋值 

QPoint &operator-=(const QPoint &point);    // 减赋值 

这两个操作符是它的成员。而以下的操作符则不是它的成员：

cosnt QPoint operator+ (const QPoint &p1, const QPoint &p2);    //  加法 

const QPoint operator- (const QPoint &p1, const QPoint &p2);     //  减法 

const QPoint operator- (const QPoint &point);                          //  取负数 

    bool operator== (const QPoint &p1, const QPoint &p2);            //  判断是否相等 

    bool operator!= (const QPoint &p1, const QPoint);                   //  判断是否不等 

4、QSize

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

a.构造

    QSize();    // a.构造一个非法的 QSize 对象 

    QSize(int width, int height);    // a.构造宽度为 width、高度为 height 的 QSize  对象  

b.属性

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

    void setWidth(int width);    // 设置宽度 

    void setHeight(int height);    // 设置高度 

通过以下成员函数可以获得 QSize 对象的宽度和高度：

    int width() const;    // 获得宽度 

    int height() const;  // 获得高度 

c.操作符

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

5、QFont

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

a.构造

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

    QFont();    // 由应用程序的默认字体构造新字体对象 

    QFont(const QString &family, int pointSize = -1, int weight = -1, bool italic = false);   

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

       1) family: 字体的名称。

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

       3) weight: 字体的粗细。

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

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

b.属性

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 将自动选择最接近的字体。如果要显示的字符在字体中不存在，则字符会被显示为一个空心方框。     

6、QPixmap

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

a.构造

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

QPixmap();     // a.构造一个大小为 0 的空图像 

以下构造函数生成大小的 QPixmap 对象，但图像数据未初始化：

    QPixmap(const QSize &size);     // a.构造大小为 size 的图像，图像数据未初始化 

    QPixmap(int width, int height);    // 等价于 QPixmap(QSize(width, height)); 

以下构造函数能够从指定的文件中加载图像并生成 QPixmap 对象：

    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：单色模式。     

b.图像参数

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

    int depth() const;     // 颜色深度，既每像素所占的比特数 

    int width() const;     // 图像宽度，单位是像素 

    int height() const;   // 图像高度，单位是像素 

    QSize size() cosnt;  // 图像的大小，即 QSize(width(), height()); 

    QRect rect() const;   // 图像的矩形区域，即 QRect(QPoint(0,0),size()); 

c.加载和保存图像

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

    bool load(const QString &filename, const char *fornat = 0, Qt::ImageCoversionFlags flags = Qt::AutoColor); 

       这里各个参数的含义与构造函数中一样，返回值为 true 表示加载成功，false 表示加载失败。相反的操作是将 Qpixmap 代表的图像保存到文件，可用以下成员函数：

    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 表示保存失败。

d.判断

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

bool isNull() const;     // 判断是否为空图像 

7、QIcon 类

QIcon 类代表图标，实现在 QtGui 共享库中。QIcon 对象可以认为是一系列图像的组合，每个图像代表窗口在某种状态下应该1显示的图标。

a.构造

 QIcon 类支持以下构造函数：

    QIcon();                          // a.构造一个空图像构成的图标 

    QIcon(const QPixmap &pixmap);     // 从 Pixmap 对象a.构造函数 

    QIcon(const QString &filename);     // 从图像文件a.构造图标 

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

b.添加图像

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

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 对象中：

    void addPixmap(const QPixmap &pixmap, Mode mode = Normal, State state = Off); 

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

c.获取图像

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

   QPixmap pixmap(const QSize &size, Mode  mode = Normal, State state = Off) const; 

    其中参数 size 是指定的大小，参数 mode 和 state 则是使用模式和状态。这个函数还有以下重载版本：

    QPixmap pixmap(int w, int h, Mode mode = Normal, State state = Off) const; 

    QPixmap pixmap(int extent, Mode mode = Normal, State state = Off) const; 

它们分别等价于以下的函数调用：

    pixmap(QSize(w, h), mode, state); 

    pixmap(QSize(extent,, extent), mode, state); 

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

d.判断

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

    bool isNull() const;     // 判断是否为空图像构成的图标 

 

 

二、窗口类

QWidget 类代表一般的窗口，其他窗口类都是从 QWidget 类继承出来的。而 QWidget 类则同时继承了 QObject 类 和 QPaintDevice 类，也就是说，窗口类都是 Qt 对象类。这里的 QPaintDevice 类则是所有可绘制的对象的基类。

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

a.构造

QWidget 类的构造函数如下：

  QWidget(QWidget *parent = 0, Qt::WindowFlags f = 0); 

    其中参数 parent 指向父窗口，如果这个参数为 0，则窗口就成为一个顶级窗口

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

    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：显示关闭按钮。

b.独立窗口

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

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

  bool isWindow() const;     // 判断是否为独立窗口 

下面这个函数可以得到窗口部件所在的独立窗口。

QWidget *window() const;      // 所得所在的独立窗口 

当然，如果窗口本身就是独立窗口，那么得到的就是自己。

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

QWidget *parentWidget() const;    // 得到父窗口 

c.窗口标题

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

 QString windowTitle() const;    // 获得窗口标题 

 void setWindowTitle(const QString &text);    // 设置窗口标题为 text 

d.几何参数

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

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

   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 两个事件处理函数中设置几何参数，否则将导致无限循环。

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

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

    QPoint pos() const;     // 获得窗口左上角的坐标(外边框几何参数) 

    QSize size() const;      // 窗口大小 （客户区几何参数） 

    int x() const;          // 窗口左上角横坐标 （外边框几何参数） 

    int y() const;          // 窗口左上角纵坐标 （外边框几何参数） 

    int height() const;        // 窗口高度 （客户区几何参数） 

    int width() const;          // 窗口宽度 （客户区几何参数） 

    可以看出，坐标全部是外边框几何参数，而大小全部是客户区几何参数。要获得外边框的大小需要用下面这个成员函数：

    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 函数用的是客户区几何参数。

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

    QRect rect() const;     // 获取窗口区域 

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

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

e.可见性与隐藏

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

    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 同时也是槽，它们一般并不直接使用，而是使用以下几个槽：

    void show();     // 显示窗口，等价于 setVisible(true); 

    void hide();       // 隐藏窗口，等价于 setHidden(true); 

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

f.窗口状态

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

    bool isMinimized() const;     // 判断窗口是否为最小化 

    bool isMaximized() const;    // 判断窗口是否为最大化 

    bool isFullScreen() const;   // 判断窗口是否为全屏 

    void showMinimized();         // 以最小化方式显示窗口，这是一个槽 

    void showMaximized();        // 以最大化方式显示窗口，这是一个槽 

    void showFullScreen();        // 以全屏方式显示窗口，这是一个槽 

    void showNormal();           // 以正常方式显示窗口，这是一个槽 

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

    另外还有一个 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 函数将使窗口变为隐藏状态。

g.使能

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

bool isEnabled() const;     // 获得窗口的使能装态 

void setEnabled(bool enable);  // 设置窗口的使能状态，这是一个槽 

void setDisabled(bool disabled); // 等价于 setEnabled(!disable)，这是一个槽 

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

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

h.激活状态

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

    bool isActiveWindow() const;   // 判断窗口所在的独立窗口是否激活 

    void activateWindow();    //  设置窗口所在的独立窗口为激活状态 

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

i.焦点

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

   bool hasFocus() const;            // 判断窗口是否获得焦点 

   void setFocus();                 // 使窗口获得焦点，这是一个槽 

    void clearFocus();             // 使窗口失去焦点 

    QWidget *focusWidget() const;  // 得到窗口内获得焦点的子窗口  

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

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

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

 bool hasEditfocus() const;     // 判断窗口是否有 editFocus 属性 

 void QWidget::setEditFocus(bool enable);// 设置窗口的 editFocus 属性 

j.捕获键盘和鼠标事件

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

    void grabKeyboard();           // 捕获键盘事件 

    void releaseKeyboard();     // 释放键盘事件 

        类似的还有鼠标事件的捕获和释放，其成员函数如下：

    void grabMouse();          // 捕获鼠标事件 

    void releaseMouse();    // 释放鼠标事件 

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

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

    QWidget *keyboardGrabber();      // 得到正在捕获键盘事件的窗口 

    QWidget *mouseGrabber();        // 得到正在捕获鼠标事件的窗口 

这两个函数是静态函数。

k.布局

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

    QLayout *layout() const;                   // 获得顶级布局 

    void setLayout(QLayout *layout);        // 设置顶级布局 

l.字体

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

    const QFont &font() const;         // 获得字体 

    void setFont(const QFont &);    // 设置字体 

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

m.信号

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

    void destoryed(QObject *obj = 0); 

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

n.槽

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

下面的槽可以关闭窗口：

   bool close(); 

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

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

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

    void lower();         // 降低窗口到最下面 

    void raise();        // 提升窗口到最上面 

2、事件

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

a.窗口事件：

    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 类的以下成员函数可以获得窗口的旧坐标和新坐标：

    const QPoint &oldPos() const;     // 旧坐标 

    const QPoint &newPos() constl   // 新坐标 

通过 QResizeEvent 类的以下成员函数可以获得窗口的旧大小和新大小：

    const QSize &oldSize() const;     // 旧大小 

    const QSize &newSize() const;   // 新大小 

b.键盘事件：

    virtual void keyPressEvent(QKeyEvent *event);   // 键按下 

    virtual void keyReleaseEvent(QKeyEvent *event);  // 键松开     

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

int key() const;     // 得到键值

c.鼠标事件：        

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 事件的成员函数可获得关于鼠标的信息，如：

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 函数，多以下两个函数：

    int delta() const;    // 获得滚轮转动的角度 

    Qt::Orientation orientationI() const;    // 获得滚轮转动的方向 

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

1）Qt::Horizontal：横向。

2）Qt::Vertical：纵向。

d.焦点事件：

    virtual void focusInEvent(QFocusEvent *event);    // 获得焦点 

    virtual void focusOutEvent(QFocusEvent *event);  // 时取焦点 

这些事件处理函数都没有返回值，因此如果要接受或拒绝和一个事件要调用 QEvent 类的成员函数，如：

    event->accept();    // 接受事件 

    event->ignore();    // 拒绝事件 

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

 

3、QDialog 类代表对话框。

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

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

a.构造

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

    QDialog (QWidget *parent = 0, Qt::WindowFlags f = 0); 

b．模态性

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

   void setModal(bool modal);    // 设置对话框的模态性 

   当参数 model 为 true 时，对话框设为模态，否则设为非模态。如果设为模态，则默认是对整个应用程序模态的。要设为对窗口模态，则需要用以下函数：

   void setWindowModality(Qt::WindowModality windowModality); 

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

1）Qt::NonModal：非模态。

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

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

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

    Qt::WindowModality windowModality() const;    // 得到窗口的模态性 

    bool isModel() const;                    // 判断窗口是否为模态的 

c.执行与结果

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

    int exec();     // 这是一个槽 

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

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

 virtual void done(int r);    // 关闭对话框并返回结果 r，这是一个槽。 

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

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

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

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

    virtual void accept();    // 槽，等价于 done(QDialog::Accepted) 

    virtual void reject();      // 槽，等价于 done(QDialog::Rejected) 

d.打开

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

 void open();    // 这是一个槽 

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

 

4、QLabel 类代表标签

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

a.构造

QLabel 类支持以下构造函数：

 

QLabel(QWidget *parent = 0, Qt::WindowFlags f = 0); 

QLabel(const QString &text, QWidget *parent = 0, Qt::WindowFlags f= 0); 

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

b.属性

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

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 的字符串，这时一个槽 

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

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

void clear();    // 清空显示内容 

alignment 属性代表内容的对齐方式，相关函数成员如下：

    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 属性代表文本的缩进值，相关的成员函数如下：

  

 int indent() const;                     // 获取文本缩进值 

void setIndex(int indent);             //设置文本缩进值 

 

margin 属性代表显示内容的边距，相关的成员函数如下：

 

    int margin() const;                   // 获取边距 

void setMargin(int margin);          // 设置边距 

 

wordWrap 属性代表显示的文本是否允许换行，相关的成员函数如下：

 

    bool wordWrap() const;            // 判断是否允许换行 

void setWordWrap(bool on);       // 设置是否允许换行 

 

scaledContents 属性表示显示图像时是否允许缩放，相关的成员函数如下：

 

    bool hasScaledContenes() const;    // 判断是否允许图像缩放 

void setScaledContents(bool on);    // 设置是否允许图像缩放 

 

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

 

7、QAbstractButton 类

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

a.属性

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

 

    bool isCheckable() const;               // 判断是否支持开关状态 

    void setCheckable(bool on);            // 设置是否支持开关状态 

 

如果一个钮支持开关状态，则可以用 checked 属性设置它的开关状态，相关的成员函数如下：

 

    bool isChecked() const;                // 判断是否打开 

    void setChecked(bool on);            // 设置是否打开，这是一个槽 

 

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

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

 

    bool autoExclusive() const;         // 判断是否排他 

    void setAutoExclusive(bool on);    // 设置是否排他  

 

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

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

 

    bool isDown() const;        // 判断是否被按下 

    void setDown(bool on);    // 设置是否被按下 

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

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

    QIcon icon() const;                              // 获得图标 

    void setIcon(const QIcon &icon);            // 设置图标 

    QString text() const;                            // 获得文本 

    void setText(const QString &text);          // 设置文本 

 

shortcut 属性代表钮的快捷键，相关成员函数如下：

 

    QKeySequence shortcut() const;                     // 获得快捷键 

    void setShortcut(const QKeySequence &key);    // 设置快捷键 

 

    从键盘输入一个钮的快捷键等价于单击这个钮。设置快捷键所需的 QKeySequence 对象可用如下方式构造：

QKeySequence("Ctrl+P"); 

// a.构造表示 Ctrl+P 组合键的 QKeySequence 对象 

b.信号

在钮上用鼠标左键或者当钮得到焦点的时候用空格键都能操作这个钮。

当钮被按下和松开时，将发射以下信号：

    void pressed();     // 钮被按下 

    void released();    // 钮被松开 

当单击钮时，将发射以下信号：

    void clicked(bool checked = false); 

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

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

    void toggled(bool checked); 

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

c.槽

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

    void click();  

    void animateclick(int msec = 100); 

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

 

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

    void toggle(); 

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

 

8、QPushButton 类代表按钮

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

a.构造

QPushButton 类支持以下a.构造函数：

    QPushButton(QWidget *parent = 0); 

    QPushButton(const QString &text, QWidget *parent = 0); 

    QPushButton(const QIcon &icon, const QString &text, QWidget *parent = 0); 

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

b.属性

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

    bool isFlat() const;         // 判断外观是否为扁平状 

    void setFlat(bool flat);    // 设置外观是否为扁平状 

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

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

 

    bool isDefault() const;         // 判断按钮是否为默认按钮 

    void setDefault(bool on);     // 设置按钮是否为默认按钮 

    bool autoDefault() const;    // 判断按钮是否为自动默认按钮 

    void setAutoDefault(bool);   // 设置按钮是否为自动默认按钮 

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

 

9、QCheckBox 类代表复选钮

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

a.构造

QCheckBox 支持以下构造函数：

    QCheckBox(QWidget *parent= 0); 

    QCheckBox(const QString &text, QWidget *parent = 0); 

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

b.属性

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

    bool isTristate() const;     // 判断是否三态 

    void setTristate(bool y = true);    // 设置是否为三态的 

    三态的复选钮不只有打开和关闭两种状态，其状态由 checkState 属性来代表，相关的成员函数如下：

    Qt::CheckState checkState() const;    // 获得状态 

    void setCheckState(Qt::CheckState state);    // 设置是否为三态的 

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

        1）Qt::Unchecked：未选中。

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

        3）Qt::Checked：选中。

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

c.信号

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

void stateChanged(int state); 

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

 

9、QRadioButton 类表示单选钮

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

QRadioButton 类支持以下构造函数：

 

    QRadioButton(QWidget *parent = 0); 

    QRadioButton(const QString &text, QWidget *parent = 0); 

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

 

10、QLineEdit 类代表编程框

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

a.构造

QLineEdit 类支持以下构造函数：

 

    QLineEdit (QWidget *parent = 0); 

    QLineEdit(const QString &contents, QWidget *parent = 0); 

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

b.属性

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

    int maxLength() const;                        // 获取最大输入长度 

    void setMaxLength(Qt::Alignment flag) const;      // 设置对齐方式 

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

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

 

    int maxLength() const;                        // 获取最大输入长度 

    void setMaxLength(int len);                   // 设置最大输入长度 

readOnly 属性表示编辑框的内容是否为只读的，即内容是否可以被用户修改，相关成员函数如下：

    bool isReadOnly() const;                      // 判断是否为只读的 

    void setReadOnly(bool on);                    // 判断是否为只读的  

text 属性表示编辑框的内容，相关的成员函数如下：

    QString text() const;                         // 获取编辑框的内容 

    void setText(const QString &text); //设置编辑框的内容，这是一个槽 

查看文本打印

    QString text() const;                       // 获取编辑框的内容 

    void setText(const QString &text); //设置编辑框的内容，这是一个槽 

  其中 setText 函数同时也是一个槽。要注意编辑框的内容不一定就是编辑框显示的内容，比如一个密码输入编辑框，用户输入的密码是不显示出来的。如果要得到编辑框的内容， 则需使用下民的成员函数：  

    QString displayText() const;    // 得到显示的内容 

frame 属性控制编辑框有没有边框，相关成员函数如下：

    bool hasFrame() const;    // 判断有没有边框 

    void setFrame(bool on);   // 设置有没有边框 

下面两个成员函数虽然不是属性，但也与文本的显示有关：

void setTextMargins(int left, int top, int right,int bottom);

   // 设置边距 

void getTextMargins(int *left, int *top, int *right, int *botton);

    // 获取边距 

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

c.信号

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

    void textChanged(const QString &text); 

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

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

    void textEdited(const QString &text); 

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

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

    void returnPressed(); 

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

d.槽

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

[plain] view plaincopyprint?

void clear();