精华内容
下载资源
问答
  • 在A项目中定义基类Base,里面含有发送和接收的信号函数。在项目B中定义派生类ComA继承自Base,B中有一个按钮,点击按钮后调用Base中的sendMsg信号发送信息。 方式1中方法是可行的。但是方法2中函数却收不到...
  • Qt基类

    千次阅读 2017-02-24 14:55:58
    来源: ... ...Qt基类 QWidget类参考 QWidget类是所有用户界面对象的基类。 详情请见…… #include qwidget.h> 继承QObject和QPaintDevice。 被QButton、QFrame、QDialog


    来源: http://www.cnblogs.com/mhxy13867806343/p/3543271.html


    Qt基类


    QWidget类参考

    QWidget类是所有用户界面对象的基类。 详情请见……

    #include <qwidget.h>

    继承QObjectQPaintDevice

    QButtonQFrameQDialogQComboBoxQDataBrowserQDataViewQDateTimeEditQDesktopWidgetQDialQDockAreaQGLWidgetQHeaderQMainWindowQNPWidgetQScrollBarQSizeGripQSliderQSpinBoxQStatusBarQTabBarQTabWidgetQWorkspaceQXtWidget继承。

    所有成员函数的列表。

    公有成员

    公有槽

    静态公有成员

    属性

    • bool acceptDrops - 窗口部件中放下事件是否有效
    • bool autoMask - 窗口部件中自动面具特征是否有效
    • QBrush backgroundBrush - 窗口部件的背景画刷 (只读)
    • BackgroundMode backgroundMode - 绘制窗口部件背景所使用的颜色模式
    • BackgroundOrigin backgroundOrigin - 窗口部件的背景的原点
    • QSize baseSize - 窗口部件的基础大小
    • QString caption - 窗口标题
    • QRect childrenRect - 窗口部件的子对象的边界矩形 (只读)
    • QRegion childrenRegion - 窗口部件的子对象所占用的组合区域 (只读)
    • QColorGroup colorGroup - 窗口部件调色板的当前颜色组 (只读)
    • QCursor cursor - 窗口部件的光标外形
    • bool customWhatsThis - 窗口部件是否手动处理这是什么的帮助 (只读)
    • bool enabled - 窗口部件是否有效
    • bool focus - 窗口部件(或者它的焦点代理)是否得到键盘输入焦点 (只读)
    • bool focusEnabled - 窗口部件是否接收键盘焦点 (只读)
    • FocusPolicy focusPolicy - 窗口部件接收键盘焦点的策略
    • QFont font - 窗口部件当前的字体集
    • QRect frameGeometry - 相对于它的父对象包含任何窗口框架的窗口部件的几何形状 (只读)
    • QSize frameSize - 包含任何窗口框架的窗口部件的大小 (只读)
    • QRect geometry - 相对于它的父对象不包括窗口框架的窗口部件的几何形状
    • int height - 不包括窗口框架的窗口部件的高度 (只读)
    • bool hidden - 窗口部件是否明确地隐藏 (只读)
    • QPixmap icon - 窗口部件图标像素映射
    • QString iconText - 窗口部件图标文本
    • bool isActiveWindow - 窗口部件或者它的一个子对象是否是活动窗口 (只读)
    • bool isDesktop - 窗口部件是否是桌面窗口部件,比如,代表桌面 (只读)
    • bool isDialog - 窗口部件是否是对话框窗口部件 (只读)
    • bool isModal - 窗口部件是否是模式窗口部件 (只读)
    • bool isPopup - 窗口部件是否是弹出窗口部件 (只读)
    • bool isTopLevel - 窗口部件是否是顶级窗口部件 (只读)
    • int maximumHeight - 窗口部件的最大高度
    • QSize maximumSize - 窗口部件的最大大小
    • int maximumWidth - 窗口部件的最大宽度
    • QRect microFocusHint - 窗口部件的当前设置的微焦点提示 (只读)
    • bool minimized - 窗口部件是否是最小化的(变为图标了) (只读)
    • int minimumHeight - 窗口部件的最小高度
    • QSize minimumSize - 窗口部件的最小大小
    • QSize minimumSizeHint - 建议的窗口部件最小大小 (只读)
    • int minimumWidth - 窗口部件的最小宽度
    • bool mouseTracking - 窗口部件跟踪鼠标是否生效
    • bool ownCursor - 窗口部件是否使用它自己的光标 (只读)
    • bool ownFont - 窗口部件是否使用它自己的字体 (只读)
    • bool ownPalette - 窗口部件是否使用它自己的调色板 (只读)
    • QPalette palette - 窗口部件的调色板
    • QColor paletteBackgroundColor - 窗口部件的背景色
    • QPixmap paletteBackgroundPixmap - 窗口部件的背景像素映射
    • QColor paletteForegroundColor - 窗口部件的前景色
    • QPoint pos - 窗口部件在它的父窗口部件中的位置
    • QRect rect - 不包含任何窗口框架的窗口部件的内部几何形状 (只读)
    • QSize size - 不包含任何窗口框架的窗口部件的大小
    • QSize sizeHint - 建议的窗口部件大小 (只读)
    • QSize sizeIncrement - 窗口部件的大小增量
    • QSizePolicy sizePolicy - 窗口部件的默认布局行为
    • bool underMouse - 窗口部件是否在鼠标光标下 (只读)
    • bool updatesEnabled - 更新是否生效
    • bool visible - 窗口部件是否可视 (只读)
    • QRect visibleRect - 窗口部件的当前可视矩形 (只读)
    • int width - 不包含任何窗口框架的窗口部件宽度 (只读)
    • int x - 相对于它的父对象包含任何窗口框架的窗口部件的x坐标 (只读)
    • int y - 相对于它的父对象包含任何窗口框架的窗口部件的y坐标 (只读)

    保护成员

     

    详细描述

    QWidget类是所有用户界面对象的基类。

    窗口部件是用户界面的一个原子:它从窗口系统接收鼠标、键盘和其它事件,并且在屏幕上绘制自己的表现。每一个窗口部件都是矩形,并且它们按Z轴顺序排列的。一个窗口部件可以被它的父窗口部件或者它前面的窗口部件盖住一部分。

    QDialog是最普通的顶级窗口。不被嵌入到一个父窗口部件的窗口部件被叫做顶级窗口部件。通常情况下,顶级窗口部件是有框架和标题栏的窗口(尽管如果使用了一定的窗口部件标记,创建顶级窗口部件时也可能没有这些装饰。)在Qt中,QMainWindow和和不同的QDialog的子类是最普通的顶级窗口。

    一个没有父窗口部件的窗口部件一直是顶级窗口部件。

    非顶级窗口部件是子窗口部件。它们是它们的父窗口部件中的子窗口。你通常不能在视觉角度从它们的父窗口部件中辨别一个子窗口部件。在Qt中的绝大多数其它窗口部件仅仅作为子窗口部件才是有用的。(当然把一个按钮作为或者叫做顶级窗口部件也是可能的,但绝大多数人喜欢把他们的按钮放到其它按钮当中,比如QDialog。)

    QWidget有很多成员函数,但是它们中的一些有少量的直接功能:例如,QWidget有一个字体属性,但是它自己从来不用。有很多继承它的子类提供了实际的功能,比如QPushButtonQListBoxQTabDialog等等。

    函数分组:

    上下文

    函数

    窗口函数

    show()、hide()、raise()、lower()、close()。

    顶级窗口

    caption()、setCaption()、icon()、setIcon()、iconText()、setIconText()、isActiveWindow()、setActiveWindow()、showMinimized()、showMaximized()、showFullScreen()、showNormal()。

    窗口内容

    update()、repaint()、erase()、scroll()、updateMask()。

    几何形状

    pos()、size()、rect()、x()、y()、width()、height()、sizePolicy()、setSizePolicy()、sizeHint()、updateGeometry()、layout()、move()、resize()、setGeometry()、frameGeometry()、geometry()、childrenRect()、adjustSize()、mapFromGlobal()、mapFromParent()、mapToGlobal()、mapToParent()、maximumSize()、minimumSize()、sizeIncrement()、setMaximumSize()、setMinimumSize()、setSizeIncrement()、setBaseSize()、setFixedSize()。

    模式

    isVisible()、isVisibleTo()、visibleRect()、isMinimized()、isDesktop()、isEnabled()、isEnabledTo()、isModal()、isPopup()、isTopLevel()、setEnabled()、hasMouseTracking()、setMouseTracking()、isUpdatesEnabled()、setUpdatesEnabled()。

    观感

    style()、setStyle()、cursor()、setCursor()、font()、setFont()、palette()、setPalette()、backgroundMode()、setBackgroundMode()、colorGroup()、fontMetrics()、fontInfo()。

    键盘焦点函数

    isFocusEnabled()、setFocusPolicy()、focusPolicy()、hasFocus()、setFocus()、clearFocus()、setTabOrder()、setFocusProxy()。

    鼠标和键盘捕获

    grabMouse()、releaseMouse()、grabKeyboard()、releaseKeyboard()、mouseGrabber()、keyboardGrabber()。

    事件处理器

    event()、mousePressEvent()、mouseReleaseEvent()、mouseDoubleClickEvent()、mouseMoveEvent()、keyPressEvent()、keyReleaseEvent()、focusInEvent()、focusOutEvent()、wheelEvent()、enterEvent()、leaveEvent()、paintEvent()、moveEvent()、resizeEvent()、closeEvent()、dragEnterEvent()、dragMoveEvent()、dragLeaveEvent()、dropEvent()、childEvent()、showEvent()、hideEvent()、customEvent()。

    变化处理器

    enabledChange()、fontChange()、paletteChange()、styleChange()、windowActivationChange()。

    系统函数

    parentWidget()、topLevelWidget()、reparent()、polish()、winId()、find()、metric()。

    这是什么的帮助

    customWhatsThis()。

    内部核心函数

    focusNextPrevChild()、wmapper()、clearWFlags()、getWFlags()、setWFlags()、testWFlags()。

    每一个窗口部件构造函数接受两个或三个标准参数:

    1. QWidget *parent = 0是新窗口部件的父窗口部件。如果为0(默认),新的窗口部件将是一个顶级窗口部件。如果不是,它将会使parent的一个孩子,并且被parent的几何形状所强迫(除非你指定WType_TopLevel作为窗口部件标记)。
    2. const char *name = 0是新窗口部件的窗口部件名称。你可以使用name()来访问它。窗口部件名称很少被程序员用到,但是对于图形用户界面构造程序,比如Qt设计器,是相当重要的(你可以在Qt设计器中命名一个窗口部件,并且在你的代码中使用这个名字来连接它)。dumpObjectTree()调试函数也使用它。
    3. WFlags f = 0(在可用的情况下)设置窗口部件标记,默认设置对于几乎所有窗口部件都是适用的,但是,举例来说,一个没有窗口系统框架的顶级窗口部件,你必须使用特定的标记。

    tictac/tictac.cpp实例程序是一个简单窗口部件的好实例。它包含了一些的事件处理器(就像所有窗口部件所必须的那样)、一些被指定给它的定制处理(就像所有有用的窗口部件做的那样)并且还有一些孩子和联机。它所做的每一件事都响应对应的一个事件:这是到目前为止设计图形用户界面的最普通的方式。

    你自己将需要为你的窗口部件提供内容,但是这里是一些简要的运行事件,从最普通的开始:

    • paintEvent() - 只要窗口部件需要被重绘就被调用。每个要显示输出的窗口部件必须实现它并且不在paintEvent()之外在屏幕上绘制是明智的。
    • resizeEvent() - 当窗口部件被重新定义大小时被调用。
    • mousePressEvent() - 当鼠标键被按下时被调用。有六个鼠标相关事件,但是鼠标按下和鼠标释放事件是到目前为止最重要的。当鼠标在窗口部件内或者当它使用grabMouse()来捕获鼠标时,它接收鼠标按下事件。
    • mouseReleaseEvent() - 当鼠标键被释放时被调用。当窗口部件已经接收相应的鼠标按下事件时,它接收鼠标释放事件。这也就是说如果用户在你的窗口部件内按下鼠标,然后拖着鼠标到其它某个地方,然后释放,你的窗口部件接收这个释放事件。这里有一个例外:如果出现在弹出菜单中,当鼠标键被按下时,这个弹出菜单立即会偷掉这个鼠标事件。
    • mouseDoubleClickEvent() - 和它看起来也许不太一样。如果用户双击,窗口部件接收一个鼠标按下事件(如果他们没有拿牢鼠标,也许会出现一个或两个鼠标移动事件)、一个鼠标释放事件并且最终是这个事件。直到你看到第二次点击是否到来之前,不能从一个双击中辨别一个点击。(这是为什么绝大多数图形用户界面图书建议双击是单击的一个扩展,而不是一个不同行为的触发的一个原因。)

    如果你的窗口部件仅仅包含子窗口部件,你也许不需要实现任何一个事件处理器。如果你想检测在子窗口部件中的鼠标点击,请在父窗口部件的mousePressEvent()中调用子窗口部件的hasMouse()函数。

    接收键盘的窗口部件需要重新实现一些更多的事件处理器:

    • keyPressEvent() - 只要键被按下和当键已经被按下足够长的时间可以自动重复了就被调用。注意如果TabShift+Tab键被用在焦点变换机制中,它们仅仅被传递给窗口部件。为了强迫那些键被你的窗口部件处理,你必须重新实现QWidget::event()
    • focusInEvent() - 当窗口部件获得键盘焦点(假设你已经调用setFocusPolicy())时被调用。写得好的窗口部件意味着它们能按照一种清晰但谨慎的方式来获得键盘焦点。
    • focusOutEvent() - 当窗口部件失去键盘焦点时被调用。

    一些窗口部件也许需要实现一些不太普通的事件处理器:

    • mouseMoveEvent() - 只要当鼠标键被按下时鼠标移动就会被调用。举例来说,对于拖动,这个很有用。如果你调用setMouseTracking(TRUE),尽管没有鼠标键被按下,你也会获得鼠标移动事件。(注意这个使用鼠标跟踪的应用程序在低下的X连接下不是很有用。)(也可以参考拖放信息。)
    • keyReleaseEvent() - 只要键被释放和当如果这个键是自动重复的并且被按下一段时间时就被调用。在这种情况下窗口部件接收一个键释放事件并且对于每一个重复立即有一个键按下事件。注意如果TabShift+Tab键被用在焦点变换机制中,它们仅仅被传递给窗口部件。为了强迫那些键被你的窗口部件处理,你必须重新实现QWidget::event()
    • wheelEvent() -- 当窗口部件拥有焦点时,只要用户转动鼠标滚轮就被调用。
    • enterEvent() - 当鼠标进入这个窗口部件屏幕空间时被调用。(这不包括被这个窗口部件的子窗口部件所拥有的屏幕空间。)
    • leaveEvent() - 当鼠标离开这个窗口部件的屏幕空间时被调用。
    • moveEvent() - 当窗口部件相对于它的父窗口部件已经被移动时被调用。
    • closeEvent() - 当用户关闭窗口部件时(或这当close()被调用时)被调用。

    这里还有一些不太明显的事件。它们在qevent.h中被列出并且你需要重新实现event()来处理它们。event()的默认实现处理TabShift+Tab(移动键盘焦点)并且其它绝大多数事件给上面提到的一个或更多的特定处理器。

    当实现一个窗口部件时,还有一些更多的事情要考虑。

    • 在构造函数中,在你可能收到一个事件的任何机会之前,请确认尽早地设置你的成员变量。
    • 重新实现sizeHint()在绝大多数情况下都是很有用的并且使用setSizePolicy(),来设置正确的大小策略,这样你的同事可以更容易地设置布局管理器。一个大小策略可以让你为布局管理器提供好的默认情况,这样其它窗口部件可以很容易地包含和管理你的窗口部件。sizeHint()为这个窗口部件说明一个好的大小。
    • 如果你的窗口部件是一个顶级窗口部件,setCaption()setIcon()分别设置标题栏和图标。

    也可以参考QEventQPainterQGridLayoutQBoxLayout抽象窗口部件类

     

    成员类型文档

    QWidget::BackgroundOrigin

    这个枚举变量定义了用于绘制窗口部件背景像素映射的原点。

    被绘制的像素映射使用:

    • QWidget::WidgetOrigin - 窗口部件的坐标系统。
    • QWidget::ParentOrigin - 父窗口部件的坐标系统。
    • QWidget::WindowOrigin - 顶级窗口的坐标系统。

    QWidget::FocusPolicy

    这个枚举变量定义了一个窗口部件获得键盘焦点所依据的不同策略。

    policy可以是:

    • QWidget::TabFocus - 窗口部件通过Tab获得焦点。
    • QWidget::ClickFocus - 窗口部件通过点击获得焦点。
    • QWidget::StrongFocus - 窗口部件通过Tab和点击获得焦点。
    • QWidget::WheelFocus - StrongFocus那样加上窗口部件通过使用鼠标滚轮获得焦点。
    • QWidget::NoFocus - 窗口部件不接收焦点。

     

    成员函数文档

    QWidget::QWidget ( QWidget * parent = 0, const char * name = 0, WFlags f = 0 )

    构造一个是parent的孩子、名称为name并且窗口部件标记为f的窗口部件。

    如果parent为0,新的窗口部件变为顶级窗口。如果parent是另一个窗口部件,这个窗口部件变为parent中的一个子窗口。当它的parent被删除时,新的窗口部件被删除。

    name被发送给QObject的构造函数。

    窗口部件标记参数f通常为0,但它可以为顶级窗口部件设置自定义的窗口框架(比如,parent必须为0)。为了自定义框架,设置WStyle_Customize标记和任何一个Qt::WidgetFlags进行或运算。

    如果你向一个已经可见的窗口部件中添加一个子窗口部件,你必须明显地显示这个孩子来使它可视。

    注意QtX11版本也许不能在所有的系统上传递风格标记得所有组合。这是因为在X11上,Qt只能询问窗口管理器,并且窗口管理器会覆盖应用程序的设置。在Windows上,Qt可以是指你想要的任何标记。

    实例:

        QLabel *splashScreen = new QLabel( 0, "mySplashScreen",

                                    WStyle_Customize | WStyle_NoBorder |

                                    WStyle_Tool );

        

    QWidget::~QWidget ()

    销毁这个窗口部件。

    首先这个窗口部件的孩子都被删除。如果这个窗口部件是主窗口部件,应用程序退出。

    bool QWidget::acceptDrops () const

    如果对于这个窗口部件放下事件生效,返回真,否则返回假。详细情况请参考“acceptDrops”属性。

    void QWidget::adjustSize () [虚]

    调整窗口部件的大小来适合它的内容。

    如果sizeHint()有效(比如,如果大小提示的宽和高都大于等于0)就是用它,否则设置大小为子对象所占用的矩形(所有子窗口部件几何形状的合集)。

    也可以参考sizeHintchildrenRect

    实例:xform/xform.cpp

    QMessageBox中被重新实现。

    bool QWidget::autoMask () const

    如果对于这个窗口部件自动面具特征生效,返回真,否则返回假。详细情况请参考“autoMask”属性。

    const QBrush & QWidget::backgroundBrush () const

    返回这个窗口部件的背景画刷。详细情况请参考“backgroundBrush”属性。

    const QColor & QWidget::backgroundColor () const

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    作为替代请使用paletteBackgroundColor()eraseColor()

    BackgroundMode QWidget::backgroundMode () const

    返回绘制窗口部件的背景所使用的颜色功能。详细情况请参考“backgroundMode”属性。

    BackgroundOrigin QWidget::backgroundOrigin () const

    返回窗口部件的背景的原点。详细情况请参考“backgroundOrigin”属性。

    const QPixmap * QWidget::backgroundPixmap () const

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    作为替代请使用paletteBackgroundPixmap()或者erasePixmap()

    实例:themes/metal.cppthemes/wood.cpp

    QSize QWidget::baseSize () const

    返回窗口部件的继承大小。详细情况请参考“baseSize”属性。

    QString QWidget::caption () const

    返回窗口标题。详细情况请参考“caption”属性。

    QWidget * QWidget::childAt ( int x, int y, bool includeThis = FALSE ) const

    返回在窗口部件自己的坐标系统中像素位置(x, y)处的可视的子窗口部件。

    如果includeThis为真,并且在(x, y)没有可视的孩子,那么这个窗口部件本身被返回。

    QWidget * QWidget::childAt ( const QPoint & p, bool includeThis = FALSE ) const

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    返回在窗口部件自己的坐标系统中点p处的可视的子窗口部件。

    如果includeThis为真,并且在p没有可视的孩子,那么这个窗口部件本身被返回。

    QRect QWidget::childrenRect () const

    返回这个窗口部件的孩子的边界矩形。详细情况请参考“childrenRect”属性。

    QRegion QWidget::childrenRegion () const

    返回这个窗口部件的孩子所占用的组合区域。详细情况请参考“childrenRegion”属性。

    void QWidget::clearFocus () [槽]

    从窗口部件中拿走键盘输入焦点。

    如果这个窗口部件有激活的焦点,焦点移出事件被发送给这个窗口部件告诉它关于它失去了焦点。

    这个窗口部件必须已经为了获得键盘输入焦点使焦点设置生效,比如,它必须调用setFocusPolicy()

    也可以参考focussetFocus()focusInEvent()focusOutEvent()focusPolicyQApplication::focusWidget()

    void QWidget::clearMask ()

    通过setMask()移除任何面具设置。

    也可以参考setMask()

    void QWidget::clearWFlags ( WFlags f ) [保护]

    清空窗口部件标记f。

    窗口部件标记是Qt::WidgetFlags的组合。

    也可以参考testWFlags()getWFlags()setWFlags()

    bool QWidget::close () [槽]

    关闭这个窗口部件。如果窗口部件被关闭,返回真,否则返回假。

    首先它发送给这个窗口部件一个QCloseEvent。如果它接收这个关闭事件,它就被隐藏了QWidget::closeEvent()的默认实现是接收这个关闭事件。

    当最后一个可视的顶级窗口部件被关闭,QApplication::lastWindowClosed()信号被发射。

    实例:mdi/application.cpppopup/popup.cpp

    bool QWidget::close ( bool alsoDelete ) [虚]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    关闭这个窗口部件。如果窗口部件被关闭,返回真,否则返回假。

    如果alsoDelete为真或者这个窗口部件有WDestructiveClose窗口部件标记,这个窗口部件也被删除。这个窗口部件自己可以通过抵制它所收到的QCloseEvent来防止被关闭。

    当最后一个可视的顶级窗口部件被关闭,QApplication::lastWindowClosed()信号被发射。

    注意关闭QApplication::mainWidget()会终止应用程序。

    也可以参考closeEvent()QCloseEventhide()QApplication::quit()QApplication::setMainWidget()QApplication::lastWindowClosed()

    void QWidget::closeEvent ( QCloseEvent * e ) [虚 保护]

    这个对于事件e的事件处理器可以在子类中被重新实现来接收窗口部件关闭事件。

    默认实现是调用e->accept(),它隐藏这个窗口部件。详细情况请参考QCloseEvent文档。

    也可以参考event()hide(), close()QCloseEvent

    实例:action/application.cppapplication/application.cppi18n/mywidget.cpppopup/popup.cppqwerty/qwerty.cpp

    const QColorGroup & QWidget::colorGroup () const

    返回这个窗口部件调色板的当前颜色组。详细情况请参考“colorGroup”属性。

    void QWidget::constPolish () const [槽]

    确认这个窗口部件通过调用polish()被适当地初始化了。

    从像sizeHint()这样依赖于这个窗口部件被初始化的函数中调用constPolish(),并且也可以在show()之前被调用。

    警告:不要在窗口部件的构造函数中调用constPolish()

    也可以参考polish()

    void QWidget::contextMenuEvent ( QContextMenuEvent * e ) [虚 保护]

    这个对于事件e的事件处理器可以在子类中被重新实现来接收窗口部件上下文菜单事件。

    默认实现是调用e->accept(),它拒绝这个上下文事件。详细情况请参考QContextMenuEvent文档。

    也可以参考event()QContextMenuEvent

    void QWidget::create ( WId window = 0, bool initializeWindow = TRUE, bool destroyOldWindow = TRUE ) [虚 保护]

    如果window为零,创一个新的窗口部件窗口,否则设置窗口部件参考为window。

    如果initializeWindow为真,初始化窗口(设置几何形状等等)。如果initializeWindow为假,没有初始化被执行。这个参数只有在window是有效窗口时才有效。

    如果destroyOldWindow为真,销毁就的窗口。如果destroyOldWindow为假,你有责任自己销毁这个窗口(使用平台本地代码)。

    QWidget构造函数调用create(0,TRUE,TRUE)来为这个窗口部件创建窗口。

    const QCursor & QWidget::cursor () const

    返回这个窗口部件的光标外形。详细情况请参考“cursor”属性。

    bool QWidget::customWhatsThis () const [虚]

    如果这个窗口部件想手工地处理这是什么的帮助,返回真,否则返回假。详细情况请参考“customWhatsThis”属性。

    void QWidget::destroy ( bool destroyWindow = TRUE, bool destroySubWindows = TRUE ) [虚 保护]

    释放窗口系统资源。如果destroyWindow为真,销毁这个窗口部件窗口。

    对于所有的子窗口部件,destroy()循环地调用自己,传递给destroySubWindows一个destroyWindow参数。为了对子窗口部件地销毁进行控制,首先有选择地销毁子窗口部件。

    这个函数通常被QWidget析构函数调用。

    void QWidget::dragEnterEvent ( QDragEnterEvent * ) [虚 保护]

    当一个拖动正在进行并且鼠标进入这个窗口部件,这个事件处理器被调用。

    对于在你的应用程序中如何提供拖放的概述请参考拖放文档

    也可以参考QTextDragQImageDragQDragEnterEvent

    实例:iconview/simple_dd/main.cpp

    void QWidget::dragLeaveEvent ( QDragLeaveEvent * ) [虚 保护]

    当一个拖动正在进行并且鼠标离开这个窗口部件,这个事件处理器被调用。

    对于在你的应用程序中如何提供拖放的概述请参考拖放文档

    也可以参考QTextDragQImageDragQDragLeaveEvent

    void QWidget::dragMoveEvent ( QDragMoveEvent * ) [虚 保护]

    当一个拖动正在进行并且鼠标进入这个窗口部件,并且只要它在这个窗口部件中移动,这个事件处理器被调用。

    对于在你的应用程序中如何提供拖放的概述请参考拖放文档

    也可以参考QTextDragQImageDragQDragMoveEvent

    void QWidget::drawText ( int x, int y, const QString & str )

    在位置(x, y)绘制字符串str。

    y位置是文本的基线位置。使用默认字体和默认前景色绘制文本。

    这个函数的提供是为了方便。你使用painter替代它一般将会获得更灵活的结果和更快的速度。

    也可以参考fontforegroundColor()QPainter::drawText()

    void QWidget::drawText ( const QPoint & pos, const QString & str )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    在位置pos绘制字符串str。

    void QWidget::dropEvent ( QDropEvent * ) [虚 保护]

    当拖动在这个窗口部件上被放下,这个事件处理器被调用。

    对于在你的应用程序中如何提供拖放的概述请参考拖放文档

    也可以参考QTextDragQImageDragQDropEvent

    实例:iconview/simple_dd/main.cpp

    void QWidget::enabledChange ( bool oldEnabled ) [虚 保护]

    isEnabled(). 这个虚函数被setEnabled()调用。oldEnabled是以前的设置,你可以从isEnabled()中得到新的设置。

    如果你的窗口部件需要知道什么时候它变为有效或无效,请重新实现这个函数。你将几乎必然要使用update()来更新这个窗口部件。

    默认实现是重新绘制窗口部件的可见部分。

    也可以参考enabledenabledrepaint()update()visibleRect

    void QWidget::enterEvent ( QEvent * ) [虚 保护]

    这个事件处理器可以在子类中被重新实现用来接收窗口部件进入事件。

    当鼠标光标进入窗口部件,这个事件被发送给窗口部件。

    也可以参考leaveEvent()mouseMoveEvent()event()

    void QWidget::erase ( int x, int y, int w, int h )

    在窗口部件中擦除指定区域(x, y, w, h),并不产生绘制事件

    如果w为负数,它被width()-x替换。如果h为负数,它被height()-y替换。

    子窗口部件不被影响。

    也可以参考repaint()

    void QWidget::erase ()

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这个版本擦除整个窗口部件。

    void QWidget::erase ( const QRect & r )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    在窗口部件中擦除指定区域r,并不产生绘制事件

    void QWidget::erase ( const QRegion & reg )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    在窗口部件中擦除reg定义的区域,并不产生绘制事件

    子窗口部件不被影响。

    const QColor & QWidget::eraseColor () const

    返回这个窗口部件的擦除色。

    也可以参考setEraseColor()setErasePixmap()backgroundColor()

    const QPixmap * QWidget::erasePixmap () const

    返回这个窗口部件的擦除像素映射。

    也可以参考setErasePixmap()eraseColor()

    bool QWidget::event ( QEvent * e ) [虚 保护]

    这是主事件处理器,它处理事件e。你可以在子类中被重新实现整个函数,但是我们建议你使用一个特定的事件处理器来替代它。

    主事件首先把事件传递给所有已经被安装的事件过滤器。如果没有过滤器中途截取这个事件,它调用一个特定的事件处理器。

    键按下和释放事件被处理得和其它事件不同。event()检查TabShift+Tab并且试图适当地移动焦点。如果没有窗口部件被焦点移入(或者键按下不是TabShift+Tab),event()调用keyPressEvent()

    如果它能够把一个事件传递给没个东西,这个函数就返回真,否则如果没有任何东西想要这个事件,返回假。

    也可以参考closeEvent()focusInEvent()focusOutEvent()enterEvent()keyPressEvent()keyReleaseEvent()leaveEvent()mouseDoubleClickEvent()mouseMoveEvent()mousePressEvent()mouseReleaseEvent()moveEvent()paintEvent()resizeEvent()QObject::event()QObject::timerEvent()

    QObject中被重新实现。

    QWidget * QWidget::find ( WId id ) [静态]

    返回窗口标识符/句柄为id的窗口部件指针。

    窗口标识符类型依赖于底下的窗口系统,实际定义请参考qwindowdefs.h。如果没有具有这样的标识符的窗口部件,0被返回。

    QFocusData * QWidget::focusData () [保护]

    返回这个窗口部件的顶级窗口部件的焦点数据的指针。

    焦点数据总是属于顶级窗口部件。焦点数据列表包含这个可以接收焦点的顶级窗口部件中所有的窗口部件,按Tab顺序。一个迭代器指向当前焦点窗口部件(focusWidget()返回这个窗口部件的指针)。

    这个信息对于重新实现更先进版本的focusNextPrevChild()很有用。

    void QWidget::focusInEvent ( QFocusEvent * ) [虚 保护]

    这个事件处理器可以在子类中被重新实现用来接收这个窗口部件的键盘焦点事件(焦点进入)。

    一个窗口部件通常必须使用setFocusPolicy()来接收焦点事件,除了NoFocus的。(注意应用程序的程序员可以在任何一个窗口部件中调用setFocus(),即使是那些通常不接收焦点的。)

    如果它接收了焦点,默认实现是更新这个窗口部件(请参考focusPolicy())。它也调用setMicroFocusHint(),提示任何系统指定的输入工具关于用户注意的焦点。

    也可以参考focusOutEvent(), focusPolicykeyPressEvent()keyReleaseEvent()event()QFocusEvent

    QtMultiLineEdit中被重新实现。

    bool QWidget::focusNextPrevChild ( bool next ) [虚 保护]

    找到一个新的窗口部件并且把键盘焦点给它,适用于TabShift+Tab,并且如果它能找到新的窗口部件就返回真,并且如果不能就返回假。

    如果next为真,这个函数就向前搜索,如果next为假,它就向后搜索。

    有时,你想重新实现这个函数。例如,一个网页浏览器也许会重新实现它用来向前或向后移动当前激活链接,并且只有到达页面的最后一个或第一个链接时调用QWidget::focusNextPrevChild()

    子窗口部件在它们的父窗口部件上调用focusNextPrevChild(),但是只有顶级窗口部件可以重定向焦点。通过重载一个对象中的这个方法,你可以获得能够遍历所有子窗口部件的焦点控制。

    也可以参考focusData()

    void QWidget::focusOutEvent ( QFocusEvent * ) [虚 保护]

    这个事件处理器可以在子类中被重新实现用来接收这个窗口部件的键盘焦点事件(焦点丢失)。

    一个窗口部件通常必须使用setFocusPolicy()来接收焦点事件,除了NoFocus的。(注意应用程序的程序员可以在任何一个窗口部件中调用setFocus(),即使是那些通常不接收焦点的。)

    默认实现是调用repaint(),因为窗口部件的colorGroup()从激活变为通常,所以这个窗口部件也许需要重新绘制。它也调用setMicroFocusHint(),提示任何系统指定的输入工具关于用户注意的焦点。

    也可以参考focusInEvent()focusPolicykeyPressEvent()keyReleaseEvent()event()QFocusEvent.

    实例:qmag/qmag.cpp

    FocusPolicy QWidget::focusPolicy () const

    返回窗口部件接收键盘焦点的方式。详细情况请参考“focusPolicy”属性。

    QWidget * QWidget::focusProxy () const

    返回焦点代理的指针,或者如果没有焦点代理就返回0

    也可以参考setFocusProxy()

    QWidget * QWidget::focusWidget () const

    返回这个窗口部件窗口中的焦点窗口部件。这个和QApplication::focusWidget()是不一样的,后者返回当前激活窗口中的焦点窗口部件。

    QFont QWidget::font () const

    返回这个窗口部件的字体当前设置。详细情况请参考“font”属性。

    void QWidget::fontChange ( const QFont & oldFont ) [虚 保护]

    这个虚函数是从setFont()中被调用的。oldFont是以前的字体,你可以通过font()获得新的字体。

    如果你的窗口部件需要直到什么时候它的字体改变了,就重新实现这个函数。你将几乎毫无疑问的需要使用update()更新这个窗口部件。

    默认实现是更新包括它的几何形状的窗口部件。

    也可以参考fontfontupdate()updateGeometry()

    QFontInfo QWidget::fontInfo () const

    返回这个窗口部件当前字体的字体信息。等于QFontInto(widget->font())

    也可以参考fontfontMetrics()font

    QFontMetrics QWidget::fontMetrics () const

    返回这个窗口部件的当前字体的字体规格。等于 QFontMetrics(widget->font())

    也可以参考fontfontInfo()font

    实例:drawdemo/drawdemo.cppqmag/qmag.cpp

    const QColor & QWidget::foregroundColor () const

    paletteForegroundColor()相同。

    QRect QWidget::frameGeometry () const

    返回相对于它的父对象包含任何窗口框架的窗口部件的几何形状。详细情况请参考“frameGeometry”属性。

    QSize QWidget::frameSize () const

    返回包含任何窗口框架的窗口部件的大小。详细情况请参考“frameSize”属性。

    const QRect & QWidget::geometry () const

    返回相对于它的父对象不包括窗口框架的窗口部件的几何形状。详细情况请参考“geometry”属性。

    WFlags QWidget::getWFlags () const [保护]

    返回这个窗口部件的窗口部件标记。

    窗口部件就是Qt::WidgetFlags的一个组合。

    也可以参考testWFlags(), setWFlags()clearWFlags()

    void QWidget::grabKeyboard ()

    捕获键盘输入。

    这个窗口部件接收所有的键盘事件并且其它窗口部件将不会得到直到releaseKeyboard()被调用。鼠标事件不受影响。如果你想捕获鼠标事件,请使用grabMouse()

    焦点窗口部件不受影响,除非它不接收任何键盘事件。setFocus()像平常那样移动焦点,但是只有在releaseKeyboard()被调用之后,新的焦点窗口部件才能接收键盘事件。

    如果一个不同的窗口部件当前正在捕获键盘焦点,那么那个窗口部件的捕获首先被释放。

    也可以参考releaseKeyboard()grabMouse()releaseMouse()focusWidget()

    void QWidget::grabMouse ()

    捕获鼠标输入。

    这个窗口部件接收所有的鼠标事件并且其它窗口部件将不会得到直到releaseMouse()被调用。键盘事件不受影响。如果你想捕获键盘事件,请使用grabKeyboard()

    警告:捕获鼠标的应用程序的bug经常会锁定终端。请特别仔细地使用这个函数,并且在调试的时候考虑使用-nograb命令行参数。

    在使用Qt的时候,几乎不需要捕获鼠标,因为Qt非常聪明地捕获它、释放它。在特殊情况下,当鼠标按键被按下并且保持这种状态直到最后一个按键被释放时,Qt捕获鼠标。

    注意只有可视的窗口部件可以捕获鼠标输入。如果一个窗口部件的isVisible()返回假,这个窗口部件不能调用grabMouse()

    也可以参考releaseMouse()grabKeyboard()releaseKeyboard()grabKeyboard()focusWidget()

    void QWidget::grabMouse ( const QCursor & cursor )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    捕获鼠标输入并且改变光标形状。

    光标将被赋值为形状cursor(只要在鼠标焦点被捕获)并且这个窗口部件将变为唯一接收鼠标事件的窗口部件直到releaseMouse()被调用。

    警告:不过鼠标也许会锁定终端。

    也可以参考releaseMouse()grabKeyboard()releaseKeyboard()cursor

    bool QWidget::hasFocus () const

    如果这个窗口部件(或者它的焦点代理)拥有键盘输入焦点,返回真,否则返回假。详细情况请参考“focus”属性。

    bool QWidget::hasMouse () const

    如果窗口部件在鼠标光标之下,返回真,否则返回假。详细情况请参考“underMouse”属性。

    bool QWidget::hasMouseTracking () const

    如果这个窗口部件中鼠标跟踪生效,返回真,否则返回假。详细情况请参考“mouseTracking”属性。

    int QWidget::height () const

    返回不包括窗口框架的窗口部件的高度。详细情况请参考“height”属性。

    int QWidget::heightForWidth ( int w ) const [虚]

    返回对于给定宽度w这个窗口部件的最佳高度。默认实现是返回0,表明最佳高度不依赖于宽度。

    警告:不要考虑窗口部件的布局。

    QMenuBarQTextEdit中被重新实现。

    void QWidget::hide () [虚 槽]

    隐藏窗口部件。

    你几乎不需要重新实现这个函数。如果你需要在一个窗口部件被隐藏之后做些什么,请使用hideEvent()替代。

    也可以参考hideEvent()hiddenshow()showMinimized()visibleclose()

    实例:mdi/application.cppnetwork/ftpclient/ftpmainwindow.cpppopup/popup.cpp、 progress/progress.cppscrollview/scrollview.cppxform/xform.cpp

    QMenuBar中被重新实现。

    void QWidget::hideEvent ( QHideEvent * ) [虚 保护]

    这个事件处理器可以在子类中被重新实现来接收窗口部件隐藏事件。

    在窗口部件被隐藏之后,隐藏事件被立即发送给窗口部件。

    也可以参考event()QHideEvent

    QScrollBar中被重新实现。

    const QPixmap * QWidget::icon () const

    返回窗口部件图标像素映射。详细情况请参考“icon”属性。

    QString QWidget::iconText () const

    返回窗口部件图标文本。详细情况请参考“iconText”属性。

    void QWidget::iconify () [槽]

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    void QWidget::imComposeEvent ( QIMEvent * e ) [虚 保护]

    这个事件处理器可以在子类中被重新实现用来接收输入法写作事件。当用户通过输入法输入某些文本时,这个处理器将被调用。

    默认实现是调用e->ignore(),它拒绝输入法事件。详细情况请参考QIMEvent文档。

    也可以参考event()QIMEvent

    void QWidget::imEndEvent ( QIMEvent * e ) [虚 保护]

    这个事件处理器可以在子类中被重新实现用来接收输入法写作事件。当用户已经完成通过输入法输入某些文本时,这个处理器将被调用。

    默认实现是调用e->ignore(),它拒绝输入法事件。详细情况请参考QIMEvent文档。

    也可以参考event()QIMEvent

    void QWidget::imStartEvent ( QIMEvent * e ) [虚 保护]

    这个事件处理器可以在子类中被重新实现用来接收输入法写作事件。当用户开始通过输入法输入某些文本时,这个处理器将被调用。

    默认实现是调用e->ignore(),它拒绝输入法事件。详细情况请参考QIMEvent文档。

    也可以参考event()QIMEvent

    bool QWidget::isActiveWindow () const

    如果这个窗口部件是激活窗口或者它的一个孩子,返回真,否则返回假。详细情况请参考“isActiveWindow”属性。

    bool QWidget::isDesktop () const

    如果这个窗口部件是一个桌面窗口部件,比如,它代表着桌面,返回真,否则返回假。详细情况请参考“isDesktop”属性。

    bool QWidget::isDialog () const

    如果这个窗口部件是一个对话框窗口部件,返回真,否则返回假。详细情况请参考“isDialog”属性。

    bool QWidget::isEnabled () const

    如果这个窗口部件是生效的,返回真,否则返回假。详细情况请参考“enabled”属性。

    bool QWidget::isEnabledTo ( QWidget * ancestor ) const

    如果ancestor生效,这个窗口部件能够变为生效的,返回真,否则返回假。

    如果这个窗口部件自身或者它的每一个祖先,但是除了ancestor以外,已经被明确地指定为失效的时候,才是这样的情况。

    isEnabledTo(0)等于isEnabled()

    也可以参考enabledenabled

    bool QWidget::isEnabledToTLW () const

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    这个函数是被反对的。它等于isEnabled()

    bool QWidget::isFocusEnabled () const

    如果这个窗口部件接收键盘焦点,返回真,否则返回假。详细情况请参考“focusEnabled”属性。

    bool QWidget::isHidden () const

    如果这个窗口部件被明确地隐藏,返回真,否则返回假。详细情况请参考“hidden”属性。

    bool QWidget::isMaximized () const

    如果窗口部件是被最大化的顶级窗口部件,返回真,否则返回假。

    注意因为一些窗口系统的一些限制,这样做并不是总能得到所期望的结果(比如,如果在X11上的用户通过窗口管理器最大化这个窗口,Qt并不能把它与其它重定义大小区分开)。这有待于窗口管理器协议的进一步改进。

    也可以参考showMaximized()

    bool QWidget::isMinimized () const

    如果这个窗口部件最小化(变为图标了),返回真,否则返回假。详细情况请参考“minimized”属性。

    bool QWidget::isModal () const

    如果这个窗口部件是模式窗口部件,返回真,否则返回假。详细情况请参考“isModal”属性。

    bool QWidget::isPopup () const

    如果这个窗口部件是弹出窗口部件,返回真,否则返回假。详细情况请参考“isPopup”属性。

    bool QWidget::isTopLevel () const

    如果这个窗口部件是顶级窗口部件,返回真,否则返回假。详细情况请参考“isTopLevel”属性。

    bool QWidget::isUpdatesEnabled () const

    如果更新是生效的,返回真,否则返回假。详细情况请参考“updatesEnabled”属性。

    bool QWidget::isVisible () const

    如果这个窗口部件是可视的,返回真,否则返回假。详细情况请参考“visible”属性。

    bool QWidget::isVisibleTo ( QWidget * ancestor ) const

    如果ancestor被显示,这个窗口部件可以变为可视,返回真,否则返回假。

    如果这个窗口部件自身或者它的每一个祖先,但是除了ancestor以外,已经被明确地指定为隐藏的时候,才是这样的情况。

    如果这个窗口部件被屏幕上其它窗口弄得变暗,这个函数仍会返回真,但是如果它或者它们被移动了,它将被变为物理可视的。

    isVisibleTo(0)isVisible()很相似,除了它变为图标的情况或者这个窗口存在与其它虚拟桌面的情况。

    也可以参考show()hide()visible

    bool QWidget::isVisibleToTLW () const

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    这个函数是被反对的。它等于isVisible()

    void QWidget::keyPressEvent ( QKeyEvent * e ) [虚 保护]

    这个事件处理器可以在子类中被重新实现用来接收这个窗口部件的键盘按下事件。

    窗口部件最初必须调用setFocusPolicy()来接收焦点并且得到焦点用来接收键盘释放事件。

    如果你重新实现这个处理器,如果你不能理解这个事件,你就忽略(ignore()这个事件,这是很重要的,这样这个窗口部件的父对象就可以说明它。

    默认实现是如果用户按下Esc就关闭弹出窗口部件。否则这个事件就被忽略。

    也可以参考keyReleaseEvent()QKeyEvent::ignore()focusPolicyfocusInEvent()focusOutEvent()event()QKeyEvent

    实例:picture/picture.cpp

    QLineEditQTextEditQtMultiLineEdit中被重新实现。

    void QWidget::keyReleaseEvent ( QKeyEvent * e ) [虚 保护]

    这个事件处理器可以在子类中被重新实现用来接收这个窗口部件的键盘释放事件。

    窗口部件最初必须调用setFocusPolicy()来接收焦点并且得到焦点用来接收键盘释放事件。

    如果你重新实现这个处理器,如果你不能理解这个事件,你就忽略(ignore()这个事件,这是很重要的,这样这个窗口部件的父对象就可以说明它。

    默认实现就是忽略这个事件。

    也可以参考keyPressEvent()QKeyEvent::ignore()focusPolicyfocusInEvent()focusOutEvent()event()QKeyEvent

    QWidget * QWidget::keyboardGrabber () [静态]

    返回当前正在捕获键盘输入的窗口部件的指针。

    如果在这个应用程序中当前没有正在捕获键盘的窗口部件,0被返回。

    也可以参考grabMouse()mouseGrabber()

    QLayout * QWidget::layout () const

    返回管理窗口部件孩子的几何形状的布局引擎的指针。

    如果这个窗口部件没有布局,layout()返回一个零指针。

    也可以参考sizePolicy

    实例:chart/optionsform.cppfonts/simple-qfont-demo/viewer.cpp

    void QWidget::leaveEvent ( QEvent * ) [虚 保护]

    这个事件管理器可以在子类中被重新实现来接收窗口部件离开事件。

    当鼠标光标离开这个窗口部件时,离开事件被发送给这个窗口部件。

    也可以参考enterEvent()mouseMoveEvent()event()

    void QWidget::lower () [槽]

    把这个窗口部件降低到它的父窗口部件的栈的底部。

    如果在屏幕上有与这个窗口部件重叠的兄弟,这个窗口部件将被它后来的这些兄弟变暗。

    也可以参考raise()stackUnder()

    bool QWidget::macEvent ( MSG * ) [虚 保护]

    这个特定的事件处理器可以在子类中被重新实现用来接收本地Macintosh事件。

    在你重新实现的这个函数中,如果你想停止Qt对这个事件的处理,返回真。如果你返回假,这个本地事件被回传给Qt,它会把这个事件转换为一个Qt事件并且把它发送给这个窗口部件。

    警告:这个函数是不可以移植的。

    也可以参考QApplication::macEventFilter()

    QPoint QWidget::mapFrom ( QWidget * parent, const QPoint & pos ) const

    把parent的坐标系统中的这个窗口部件的坐标pos转换到这个窗口部件的坐标系统中。parent必须不能为0并且必须是这个调用窗口部件的父对象。

    也可以参考mapTo()mapFromParent()mapFromGlobal()underMouse

    QPoint QWidget::mapFromGlobal ( const QPoint & pos ) const

    把全局屏幕坐标pos转换为窗口部件坐标。

    也可以参考mapToGlobal()mapFrom()mapFromParent()

    QPoint QWidget::mapFromParent ( const QPoint & pos ) const

    把父窗口部件坐标pos转换为窗口部件坐标。

    如果窗口部件没有父对象,就和mapFromGlobal()一样。

    也可以参考mapToParent()mapFrom()mapFromGlobal()underMouse

    QPoint QWidget::mapTo ( QWidget * parent, const QPoint & pos ) const

    把窗口部件坐标pos转换到parent坐标系统。parent必须不能为0并且必须是这个调用窗口部件的父对象。

    也可以参考mapFrom()mapToParent()mapToGlobal()underMouse

    QPoint QWidget::mapToGlobal ( const QPoint & pos ) const

    把窗口部件坐标pos转换为全局屏幕坐标。例如,

    mapToGlobal(QPoint(0,0))

    将会给出这个窗口部件的左上角像素的全局坐标。

    也可以参考mapFromGlobal()mapTo()mapToParent()

    实例:scribble/scribble.cpp

    QPoint QWidget::mapToParent ( const QPoint & pos ) const

    把窗口部件坐标pos转换为父窗口部件中的一个坐标。

    如果窗口部件没有父对象,就和mapToGlobal()一样。

    也可以参考mapFromParent()mapTo()mapToGlobal()underMouse

    int QWidget::maximumHeight () const

    返回这个窗口部件的最大高度。详细情况请参考“maximumHeight”属性。

    QSize QWidget::maximumSize () const

    返回这个窗口部件的最大大小。详细情况请参考“maximumSize”属性。

    int QWidget::maximumWidth () const

    返回这个窗口部件的最大宽度。详细情况请参考“maximumWidth”属性。

    int QWidget::metric ( int m ) const [虚 保护]

    虚函数QPaintDevice::metric()的内部实现。

    使用QPaintDeviceMetrics来替代它。

    m是要获得的规格。

    QRect QWidget::microFocusHint () const

    返回这个窗口部件的当前设置的微焦点提示的当前设置。详细情况请参考“microFocusHint”属性。

    int QWidget::minimumHeight () const

    返回这个窗口部件的最小高度。详细情况请参考“minimumHeight”属性。

    QSize QWidget::minimumSize () const

    返回这个窗口部件的最小大小。详细情况请参考“minimumSize”属性。

    QSize QWidget::minimumSizeHint () const [虚]

    返回这个窗口部件的建议最小大小。详细情况请参考“minimumSizeHint”属性。

    QLineEditQtMultiLineEdit中被重新实现。

    int QWidget::minimumWidth () const

    返回这个窗口部件的最小宽度。详细情况请参考“minimumWidth”属性。

    void QWidget::mouseDoubleClickEvent ( QMouseEvent * e ) [虚 保护]

    这个事件处理器可以在子类中被重新实现来接收这个窗口部件的鼠标双击事件。

    默认实现产生一个普通的鼠标点击事件。

    注意在窗口部件得到mouseDoubleClickEvent()之前,它得到一个mousePressEvent()和一个mouseReleaseEvent()

    也可以参考mousePressEvent()mouseReleaseEvent() mouseMoveEvent()event()QMouseEvent

    QWidget * QWidget::mouseGrabber () [静态]

    返回当前捕获鼠标输入的窗口部件的指针。

    如果这个应用程序中当前没有捕获鼠标的窗口部件,0被返回。

    也可以参考grabMouse()keyboardGrabber()

    void QWidget::mouseMoveEvent ( QMouseEvent * e ) [虚 保护]

    这个窗口部件可以在子类中被重新实现来接收这个窗口部件中的鼠标移动事件。

    如果鼠标跟踪被切换为关闭,只有在鼠标被按下后移动的情况下,才会发生鼠标移动事件。如果鼠标跟踪被切换为开,即使鼠标没有被按下,只要移动就会发生鼠标移动事件。

    QMouseEvent::pos()报告鼠标光标相对于这个窗口部件的位置。对于按下和释放事件,这个位置通常和最后一次鼠标移动事件的位置相同,但是如果鼠标非常快地移动和按下,这也许是不同的。这依赖于底层的窗口系统,而不是Qt

    也可以参考mouseTrackingmousePressEvent() mouseReleaseEvent()mouseDoubleClickEvent()event()QMouseEvent

    实例:aclock/aclock.cppdrawlines/connect.cppiconview/simple_dd/main.cpplife/life.cpppopup/popup.cppqmag/qmag.cppscribble/scribble.cpp

    QSizeGrip中被重新实现。

    void QWidget::mousePressEvent ( QMouseEvent * e ) [虚 保护]

    这个事件处理器可以在子类中被重新实现来接收这个窗口部件中的鼠标按下事件。

    如果你在mousePressEvent()中创建新的窗口部件,mouseReleaseEvent()也许不会像你所期待的那样结束,这依赖于底层的窗口系统(或X11窗口管理器)、这个窗口部件的位置并且也许更多。

    当你再窗口外点击时,默认实现是关闭弹出窗口。对于其它窗口部件类型,它什么都不做。

    也可以参考mouseReleaseEvent()mouseDoubleClickEvent()mouseMoveEvent()event()QMouseEvent

    实例:biff/biff.cppdrawlines/connect.cppiconview/simple_dd/main.cpplife/life.cppqmag/qmag.cppscribble/scribble.cpptooltip/tooltip.cpp

    QSizeGrip中被重新实现。

    void QWidget::mouseReleaseEvent ( QMouseEvent * e ) [虚 保护]

    这个事件处理器可以在子类中被重新实现来接收鼠标释放事件。

    也可以参考mouseDoubleClickEvent()mouseMoveEvent()event()QMouseEvent

    实例:drawlines/connect.cpphello/hello.cpppopup/popup.cppqmag/qmag.cppscribble/scribble.cppshowimg/showimg.cppt14/cannon.cpp

    void QWidget::move ( const QPoint & ) [槽]

    设置窗口部件在它的父窗口部件中的位置。详细情况请参考“pos”属性。

    void QWidget::move ( int x, int y ) [虚 槽]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这个和moveQSize(x, y) )一致。

    void QWidget::moveEvent ( QMoveEvent * ) [虚 保护]

    这个事件处理器可以在子类中被重新实现来接收窗口部件移动事件。当窗口部件接收到这个事件时,它已经在新的位置上了。

    旧的位置可以通过QMoveEvent::oldPos()来访问。

    也可以参考resizeEvent()event()posQMoveEvent

    bool QWidget::ownCursor () const

    如果这个窗口部件使用它自己的光标,返回真,否则返回假。详细情况请参考“ownCursor”属性。

    bool QWidget::ownFont () const

    如果这个窗口部件使用它自己的字体,返回真,否则返回假。详细情况请参考“ownFont”属性。

    bool QWidget::ownPalette () const

    如果这个窗口部件使用它自己的调色板,返回真,否则返回假。详细情况请参考“ownPalette”属性。

    void QWidget::paintEvent ( QPaintEvent * ) [虚 保护]

    这个事件处理器可以在子类中被重新实现来接收绘制事件。

    绘制事件就是重新绘制这个窗口部件的所有部分的一个请求。它可以是repaint()update()的结果,或者因为这个窗口部件原来被变暗并且现在已经不再被覆盖了,或者其它很多原因。

    很多窗口部件在当它们被请求时,它们很简单地重新绘制整个界面,但是一些比较慢的窗口部件需要通过仅仅绘制被请求的区域QPaintEvent::region()进行优化。这个速度优化不会改变结果,在事件处理过程中,绘制仅仅发生在被改变的区域中。例如,QListViewQCanvas就是这样做的。

    Qt也试图通过把多个绘制事件合并为一个来加快绘制速度。当update()被调用几次或者窗口系统发送几次绘制事件,Qt把它们合并为一个比较大区域(请参考QRegion::unite())的一个事件中。repaint()不允许这样优化,所以只要可能我们建议使用update()

    当绘制事件发生,更新区域通常被擦除,所以你正在这个窗口部件的背景上绘制。这里有一些例外并且QPaintEvent::erased()告诉你这个窗口部件是否被擦除。

    背景可以通过使用setBackgroundMode()setPaletteBackgroundColor()setBackgroundPixmap()来设置。setBackgroundMode()的文档详细描述了背景,我们建议你去读一下。

    也可以参考event()repaint()update()QPainterQPixmapQPaintEvent

    实例:drawdemo/drawdemo.cppdrawlines/connect.cppqmag/qmag.cppscribble/scribble.cppsplitter/splitter.cppt8/cannon.cppt9/cannon.cpp

    QButtonQFrameQGLWidgetQSizeGripQStatusBarQTabBar中被重新实现。

    const QPalette & QWidget::palette () const

    返回这个窗口部件的调色板。详细情况请参考“palette”属性。

    const QColor & QWidget::paletteBackgroundColor () const

    返回这个窗口部件的背景色。详细情况请参考“paletteBackgroundColor”属性。

    const QPixmap * QWidget::paletteBackgroundPixmap () const

    返回这个窗口部件的背景像素映射。详细情况请参考“paletteBackgroundPixmap”属性。

    void QWidget::paletteChange ( const QPalette & oldPalette ) [虚 保护]

    这个虚函数是从setPalette()中被调用的。oldPalette是原来的调色板,你可以通过palette()得到新的调色板。

    如果你的窗口部件需要知道什么时候调色板发生变化了,请重新实现这个函数。

    也可以参考palettepalette

    const QColor & QWidget::paletteForegroundColor () const

    返回这个窗口部件的前景色。详细情况请参考“paletteForegroundColor”属性。

    QWidget * QWidget::parentWidget ( bool sameWindow = FALSE ) const

    返回这个窗口部件的父窗口部件的指针,如果它没有,就返回零指针。如果sameWindow为真并且这个窗口部件是顶级的,就返回0,否则返回它的父窗口部件。

    实例:mdi/application.cpp

    void QWidget::polish () [虚 槽]

    延时窗口部件的初始化。

    这个函数将在窗口部件完全创建完毕之后并且在它每一次被显示之前被调用。

    抛光对于依赖一个特定窗口部件的最终初始化是很有用的。有一些事情构造函数不能够决定,因为子类的初始化也许没有完成。

    在这个函数之后,窗口部件就有一个适当的字体和调色板并且QApplication::polish()已经被调用。

    当重新实现这个函数的时候,记得调用QWidget的实现。

    也可以参考constPolish()QApplication::polish()

    实例:menu/menu.cpp

    QPoint QWidget::pos () const

    返回这个窗口部件在它父窗口部件中的位置。详细情况请参考“pos”属性。

    bool QWidget::qwsEvent ( QWSEvent * ) [虚 保护]

    这个特定的事件处理器可以在子类中被重新实现来接收本地的Qt/Embedded事件。

    在你重新实现的这个函数中,如果你想停止Qt对这个事件的处理,返回真。如果你返回假,这个本地事件被回传给Qt,它会把这个事件转换为一个Qt事件并且把它发送给这个窗口部件。

    警告:这个函数是不可以移植的。

    也可以参考QApplication::qwsEventFilter()

    void QWidget::raise () [槽]

    把这个窗口部件升高到它的父窗口部件的栈的顶部。

    如果在屏幕上有与这个窗口部件重叠的兄弟,这个窗口部件将在它后来的这些兄弟之前变的可视了。

    也可以参考lower()stackUnder()

    实例:showimg/showimg.cpp

    void QWidget::recreate ( QWidget * parent, WFlags f, const QPoint & p, bool showIt = FALSE )

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    这个函数的提供是为了从Qt 1.0移植到2.0。在Qt 2.0中它已经被重新命名为reparent()

    QRect QWidget::rect () const

    返回不包含任何窗口框架的窗口部件的内部几何形状。详细情况请参考“rect”属性。

    void QWidget::releaseKeyboard ()

    释放键盘捕获。

    也可以参考grabKeyboard()grabMouse()releaseMouse()

    void QWidget::releaseMouse ()

    释放鼠标捕获。

    也可以参考grabMouse()grabKeyboard()releaseKeyboard()

    void QWidget::repaint ( int x, int y, int w, int h, bool erase = TRUE ) [槽]

    通过立即调用paintEvent()来直接重新绘制窗口部件,除非更新是失效的或者窗口部件被隐藏。

    如果erase为真,QtpaintEvent()调用之前擦除区域(x,y,w,h)。

    如果w是负数,它被width()-x替换,并且如果h是负数,它被height()-y替换。

    如果你需要立即重新绘制,我们建议使用repaint(),比如在动画期间。在绝大多数情况下,update()更好,因为它允许Qt来优化速度并且防止闪烁。

    警告:如果你在一个函数中调用repaint(),而它自己又被paintEvent()调用,你也许会看到无线循环。update()函数从来不会产生循环。

    也可以参考update()paintEvent()updatesEnablederase()

    实例:qwerty/qwerty.cpp

    void QWidget::repaint () [槽]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这个版本擦除并且重新绘制整个窗口部件。

    void QWidget::repaint ( bool erase ) [槽]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这个版本重新绘制整个窗口部件。

    void QWidget::repaint ( const QRect & r, bool erase = TRUE ) [槽]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    通过立即调用paintEvent()来直接重新绘制窗口部件,除非更新是失效的或者窗口部件被隐藏。

    如果erase为真,擦除窗口部件区域r。

    void QWidget::repaint ( const QRegion & reg, bool erase = TRUE ) [槽]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    通过立即调用paintEvent()来直接重新绘制窗口部件,除非更新是失效的或者窗口部件被隐藏。

    如果erase为真,擦除窗口部件区域reg。

    如果你需要立即重新绘制,我们建议使用repaint(),比如在动画期间。一连串的多次调用update()将产生一个单一的绘制事件。

    警告:如果你在一个函数中调用repaint(),而它自己又被paintEvent()调用,你也许会看到无线循环。update()函数从来不会产生循环。

    也可以参考update()paintEvent()updatesEnablederase()

    void QWidget::reparent ( QWidget * parent, WFlags f, const QPoint & p, bool showIt = FALSE ) [虚]

    重新定义这个窗口部件的父对象。这个窗口部件得到新的parent,新的窗口部件标记(f,但通常使用0)和在新的父对象中的新位置(p)。

    如果showIt为真,一旦窗口部件被重新定义父对象,show()就被调用。

    如果新的父窗口部件在一个不同的顶级窗口部件中,被重新定义父对象的窗口部件和它的孩子们将被添加到新窗口部件的tab的最后。如果被移动的窗口部件之一拥有键盘焦点reparent()为这个窗口部件调用clearFocus()

    如果新的父窗口部件和原来的父对象在同一个顶级窗口部件中,reparent()不会改变tab顺序或者键盘焦点。

    警告:你对这个函数的需要是绝对不必要的。如果你有一个窗口部件动态的改变它的内容,使用QWidgetStackQWizard会更容易的多。

    也可以参考getWFlags()

    void QWidget::reparent ( QWidget * parent, const QPoint & p, bool showIt = FALSE )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    一个方便的重新定义这个窗口部件的父对象的版本没有把窗口部件标记作为参数。

    调用reparent(parent, getWFlags() & ~WType_Mask, p, showIt)

    void QWidget::resetInputContext () [保护]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。比如,改变焦点到另一个窗口部件,移动光标,等等。

    void QWidget::resize ( const QSize & ) [槽]

    设置不包含任何窗口框架的窗口部件的大小。详细情况请参考“size”属性。

    void QWidget::resize ( int w, int h ) [虚 槽]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这个和resizeQSize(w, h) )一致。

    void QWidget::resizeEvent ( QResizeEvent * ) [虚 保护]

    这个事件处理器可以在子类中被重新实现来接收窗口部件重定义大小事件。当resizeEvent()被调用时,这个窗口部件已经有了新的几何形状。原来的大小可以通过QResizeEvent::oldSize()访问。

    这个窗口部件竟被擦除并且在处理重定义大小事件之后立即接收到一个绘制事件。在这个处理器中不需要(或者必须)绘制。

    WResizeNoErase创建的窗口部件将不会被擦除。不过,它们也将收到一个对于整个区域的绘制事件。再一次的,在这个处理器中不需要(或者必须)绘制。

    如果窗口部件的自动面具生效,默认实现调用updateMask()

    也可以参考moveEvent()event()sizeQResizeEventpaintEvent()

    实例:drawdemo/drawdemo.cppmainlyQt/editor.cppmainlyXt/editor.cpp 、menu/menu.cppqmag/qmag.cppscribble/scribble.cpptooltip/tooltip.cpp

    QFrameQGLWidget中被重新实现。

    void QWidget::scroll ( int dx, int dy )

    卷动包括它的孩子的窗口部件,向右dx像素并且向下dy像素。dx和dy都可以为负。

    在卷动后,scroll()发送绘制事件,只为了读的部分,但不写。例如,当向右卷动10像素,窗口部件的最左面10像素需要重新绘制。绘制事件也许立即或者稍后被交付,依赖于一些启发式。

    也可以参考QScrollViewerase()bitBlt()

    void QWidget::scroll ( int dx, int dy, const QRect & r )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这个版本仅卷动r并且不移动窗口部件的孩子。

    如果r为空或者无效,结果是未定义的。

    也可以参考QScrollViewerase()bitBlt()

    void QWidget::setAcceptDrops ( bool on ) [虚]

    设置对于这个窗口部件放下事件是否生效为on。详细情况请参考“acceptDrops”属性。

    void QWidget::setActiveWindow () [虚]

    设置包含这个窗口部件的顶级窗口部件为激活窗口。

    激活窗口就是拥有键盘输入焦点的可视的顶级窗口。

    这个函数执行的操作和在一个顶级窗口的标题栏点击鼠标是一样的。在X11上,结果依赖于窗口管理器。如果你想确认窗口也被堆在顶部,请另外调用raise()。注意这个窗口已经被变为可视,除非setActiveWindow()没有效果。

    Windows上,如果当应用程序不是当前激活的应用程序,如果你调用这个函数,然后它不会使它变为激活窗口。它将会在标题栏条目上闪烁蓝色标明这个窗口已经做了些什么。这是由于Microsoft不允许一个应用程序打断用户当前在另一个应用程序上所做的事情。

    也可以参考isActiveWindowtopLevelWidget()show()

    QXtWidget中被重新实现。

    void QWidget::setAutoMask ( bool ) [虚]

    设置这个窗口部件自动面具特征是否生效。详细情况请参考“autoMask”属性。

    void QWidget::setBackgroundColor ( const QColor & c ) [虚]

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。使用setPaletteBackgroundColor()setEraseColor()替代它。

    实例:customlayout/main.cppdesktop/desktop.cpphello/main.cppmovies/main.cppsplitter/splitter.cpp

    void QWidget::setBackgroundMode ( BackgroundMode ) [虚]

    设置绘制窗口部件背景所使用的颜色模式。详细情况请参考“backgroundMode”属性。

    void QWidget::setBackgroundMode ( BackgroundMode m, BackgroundMode visual )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    设置这个窗口部件自己的背景模式为m并且可视背景模式为visual。可视背景模式和可设计的属性backgroundColor、foregroundColor和backgroundPixmap一起使用。

    对于复杂的控制,合理的背景模式有时和窗口部件自己的背景模式不同。例如,微调框把PaletteBackground作为背景模式(通常是暗灰色),当它被嵌入到行编辑控件中使用PaletteBase(通常是白色)。因为行编辑控件覆盖微调框的绝大部分可视区域,它定义了PaletteBase为它的可视背景模式。改变backgroundColor属性会改变行编辑控件的背景,这正是用户在Qt设计器中所期待的。

    void QWidget::setBackgroundOrigin ( BackgroundOrigin ) [虚]

    设置这个窗口部件背景的原点。详细情况请参考“backgroundOrigin”属性。

    void QWidget::setBackgroundPixmap ( const QPixmap & pm ) [虚]

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。使用setPaletteBackgroundPixmap()setErasePixmap()替代它。

    实例:desktop/desktop.cpp

    void QWidget::setBaseSize ( const QSize & )

    设置这个窗口部件的基础大小。详细情况请参考“baseSize”属性。

    void QWidget::setBaseSize ( int basew, int baseh )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这个和setBaseSizeQSize(basew, baseh) )一致。设置窗口部件基础大小的宽为basew,高为baseh。

    void QWidget::setCaption ( const QString & ) [虚 槽]

    设置窗口标题。详细情况请参考“caption”属性。

    void QWidget::setCursor ( const QCursor & ) [虚]

    设置这个窗口部件的光标形状。详细情况请参考“cursor”属性。

    void QWidget::setDisabled ( bool disable ) [槽]

    如果disable为真,使窗口部件输入事件失效,否则使输入事件生效。

    更多信息请参考enabled文档。

    也可以参考isEnabledTo()QKeyEventQMouseEventenabledChange()

    void QWidget::setEnabled ( bool ) [虚 槽]

    设置这个窗口部件是否生效。详细情况请参考“enabled”属性。

    void QWidget::setEraseColor ( const QColor & color ) [虚]

    设置这个窗口部件的擦除颜色为color。

    擦除颜色就是在paintEvent()被调用之前这个窗口部件被清空的颜色。如果有擦除像素映射(使用setErasePixmap()设置),然后这个属性就会有不确定的值。

    也可以参考erasePixmap()backgroundColor()backgroundModepalette

    void QWidget::setErasePixmap ( const QPixmap & pixmap ) [虚]

    设置这个窗口部件的擦除像素映射为pixmap。

    这个像素映射就是在paintEvent()被调用之前用来清空这个窗口部件的。

    void QWidget::setFixedHeight ( int h )

    设置这个窗口部件的最小高度和最大高度都为h,而不改变宽度。为了方便而提供。

    也可以参考sizeHintminimumSizemaximumSizesetFixedSize()

    实例:fonts/simple-qfont-demo/viewer.cpplayout/layout.cppqdir/qdir.cppshowimg/showimg.cpp

    void QWidget::setFixedSize ( const QSize & s )

    设置这个窗口部件的最小大小和最大大小都为s,这样就可以防止它变大或者变小。

    也可以参考maximumSizeminimumSize

    void QWidget::setFixedSize ( int w, int h )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    设置窗口部件的宽度为w,高度为h。

    void QWidget::setFixedWidth ( int w )

    设置这个窗口部件的最小宽度和最大宽度都为h,而不改变高度。为了方便而提供。

    也可以参考sizeHintminimumSizemaximumSizesetFixedSize()

    实例:network/ftpclient/ftpmainwindow.cppprogressbar/progressbar.cppqdir/qdir.cpp

    void QWidget::setFocus () [虚 槽]

    把键盘输入焦点给这个窗口部件(或者它的焦点代理)。

    首先,一个焦点移出事件会被发送给焦点窗口部件(如果有的话)告诉它关于失去焦点的事情。然后一个焦点进入事件被发送给这个窗口部件告诉它刚刚接收到焦点。(如果焦点移出和进入的窗口部件是同一个的话,就什么都没有发生。)

    setFocus()会把焦点给一个窗口部件,而不管它的焦点策略,但是不会清空任何键盘捕获(请参考grabKeyboard())。

    请注意如果窗口部件是被隐藏的,它将不接收焦点。

    警告:如果你在一个函数中调用setFocus(),而这个函数自己被focusOutEvent()focusInEvent()调用,你也许会体验到无限循环。

    也可以参考focusclearFocus()focusInEvent()focusOutEvent()focusPolicyQApplication::focusWidget()grabKeyboard()grabMouse()

    实例:addressbook/centralwidget.cpplineedits/lineedits.cppmdi/application.cpppopup/popup.cpprot13/rot13.cppt8/main.cppwizard/wizard.cpp

    void QWidget::setFocusPolicy ( FocusPolicy ) [虚]

    设置这个窗口部件接收键盘焦点的方式。详细情况请参考“focusPolicy”属性。

    void QWidget::setFocusProxy ( QWidget * w ) [虚]

    设置这个窗口部件的焦点代理为窗口部件w。如果w为0,这个函数重置这个窗口部件没有焦点代理。

    一些窗口部件,比如QComboBox,能够拥有焦点,但创建一个子窗口部件来实际处理这个焦点。例如,QComboBox创建了一个QLineEdit来处理焦点。

    这个窗口部件获得焦点时,setFocusProxy()设置这个窗口部件实际获得焦点。如果有了一个焦点代理,focusPolicy()setFocusPolicy()setFocus()hasFocus()都在这个焦点代理上操作。

    也可以参考focusProxy()

    void QWidget::setFont ( const QFont & ) [虚]

    设置这个窗口部件的字体当前设置。详细情况请参考“font”属性。

    QComboBoxQLabelQTabDialog中被重新实现。

    void QWidget::setFont ( const QFont & f, bool )

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    使用setFont(const QFont& font)替代它。

    void QWidget::setGeometry ( const QRect & ) [虚 槽]

    设置相对于它的父对象不包括窗口框架的窗口部件的几何形状。详细情况请参考“geometry”属性。

    void QWidget::setGeometry ( int x, int y, int w, int h ) [虚 槽]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这相当于setGeometryQRect(x, y, w, h) )

    void QWidget::setIcon ( const QPixmap & ) [虚 槽]

    设置这个窗口部件图标像素映射。详细情况请参考“icon”属性。

    void QWidget::setIconText ( const QString & ) [虚 槽]

    设置这个窗口部件图标文本。详细情况请参考“iconText”属性。

    void QWidget::setKeyCompression ( bool compress ) [虚 保护]

    如果compress为真,使键盘事件压缩生效,并且如果compress为假,使键盘事件压缩失效。

    默认情况下,键盘压缩是关闭的,所以窗口部件对于每一个键盘按下(或者更多,因为自动重复通常是打开的)都接收到一个键盘按下事件。如果你把它打开并且你的应用程序更不上键盘输入,Qt也许会试图压缩键盘事件,这样每一个事件中就会处理多于一个字符的情况。

    例如,如果布局重新运算占用太长时间的CPU,一个字处理器窗口部件接收每一个QKeyEvent::text()中的2个、3个或更多字符。

    如果窗口部件支持多字符unicode输入,它对于这种压缩打开总是安全的。

    Qt只对可打印的字符执行键盘事件压缩。修正键、光标移动键、功能键和其它操作键(比如,EscapeReturnBackspacePrintScreen)将会停止键盘事件压缩,即使如果可以更多可压缩的键盘事件。

    并不是所有的平台都支持这种压缩,在这种情况下如果把这个选项打开将不会有任何效果。

    也可以参考QKeyEvent::text().

    void QWidget::setMask ( const QBitmap & bitmap ) [虚]

    导致只有和bitmap中为1的位对应的窗口部件的像素是可视的。如果包含像素的区域在窗口部件的rect()之外,在那个区域的窗口系统控制允许可视,也许不可视,依赖于平台。

    注意如果区域相当复杂,这种效果会很慢。

    也可以参考clearMask()

    void QWidget::setMask ( const QRegion & region ) [虚]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    导致只有和region重合的窗口部件的部分是可视的。如果包含像素的区域在窗口部件的rect()之外,在那个区域的窗口系统控制允许可视,也许不可视,依赖于平台。

    注意如果区域相当复杂,这种效果会很慢。

    也可以参考clearMask()

    void QWidget::setMaximumHeight ( int maxh )

    设置这个窗口部件的最大高度为maxh。详细情况请参考“maximumHeight”属性。

    void QWidget::setMaximumSize ( const QSize & )

    设置这个窗口部件的最大大小。详细情况请参考“maximumSize”属性。

    void QWidget::setMaximumSize ( int maxw, int maxh ) [虚]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这个函数相当于setMaximumSizeQSize(maxw, maxh) )。设置最大宽度为maxw,最大高度为maxh。

    void QWidget::setMaximumWidth ( int maxw )

    设置这个窗口部件的最大宽度为maxw。详细情况请参考“maximumWidth”属性。

    void QWidget::setMicroFocusHint ( int x, int y, int width, int height, bool text = TRUE, QFont * f = 0 ) [虚 保护]

    当窗口部件得到焦点,它应该为合适的大小和位置——x、y和width与em>height,调用setMicroFocusHint。这没有可视效果,它仅仅为任意系统指定的输入处理工具提供提示。

    如果这是一个文本输入位置,text参数应该为真。

    Windows版本的Qt中,这个方法设置系统插入符号,这用户用户可访问的焦点处理。如果text为真,在远东亚洲语言输入系统中,它也会设置输入法的。

    X11版本的Qt中,如果text为真,这个方法为复杂语言输入处理设置XIM“spot”点。

    字体参数f现在不使用了。

    也可以参考microFocusHint

    void QWidget::setMinimumHeight ( int minh )

    设置这个窗口部件的最小高度为minh。详细情况请参考“minimumHeight”属性。

    void QWidget::setMinimumSize ( const QSize & )

    设置这个窗口部件的最小大小。详细情况请参考“minimumSize”属性。

    void QWidget::setMinimumSize ( int minw, int minh ) [虚]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    这个函数相当于setMinimumSizeQSize(minw, minh) )。设置最小宽度为minw,最小高度为minh。

    void QWidget::setMinimumWidth ( int minw )

    设置这个窗口部件的最小宽度为minw。详细情况请参考“minimumWidth”属性。

    void QWidget::setMouseTracking ( bool enable ) [虚 槽]

    设置对于这个窗口部件鼠标跟踪是否生效为enable。详细情况请参考“mouseTracking”属性。

    void QWidget::setPalette ( const QPalette & ) [虚]

    设置这个窗口部件的调色板。详细情况请参考“palette”属性。

    QComboBoxQScrollBarQSlider中被重新实现。

    void QWidget::setPalette ( const QPalette & p, bool )

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    使用setPalette( const QPalette& p )替代它。

    void QWidget::setPaletteBackgroundColor ( const QColor & ) [虚]

    设置这个窗口部件的背景色。详细情况请参考“paletteBackgroundColor”属性。

    void QWidget::setPaletteBackgroundPixmap ( const QPixmap & ) [虚]

    设置这个窗口部件的背景像素映射。详细情况请参考“paletteBackgroundPixmap”属性。

    void QWidget::setPaletteForegroundColor ( const QColor & )

    设置这个窗口部件的前景色。详细情况请参考“paletteForegroundColor”属性。

    void QWidget::setSizeIncrement ( const QSize & )

    设置这个窗口部件的大小增量。详细情况请参考“sizeIncrement”属性。

    void QWidget::setSizeIncrement ( int w, int h ) [虚]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    设置x(宽度)大小增量为w,y(高度)大小增量为h。

    void QWidget::setSizePolicy ( QSizePolicy ) [虚]

    设置这个窗口部件的默认布局方式。详细情况请参考“sizePolicy”属性。

    void QWidget::setStyle ( QStyle * style )

    设置这个窗口部件的图形用户界面风格为style。风格对象的所有权不能被转让。

    如果没有风格被设置,这个窗口部件使用应用程序的风格QApplication::style()替代它。

    设置窗口部件的风格对于已经存在或未来的子窗口部件没有效果。

    警告:当你想显示Qt的风格的能力时,这个函数对于演示目的很有用。真正的应用程序应该避免它并且使用一个一致的图形用户界面风格来替代它。

    也可以参考style()QStyleQApplication::style()QApplication::setStyle()

    实例:grapher/grapher.cppprogressbar/progressbar.cpp

    QStyle * QWidget::setStyle ( const QString & style )

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    使用QStyleFactory设置这个窗口部件的图形用户界面风格为style。

    void QWidget::setTabOrder ( QWidget * first, QWidget * second ) [静态]

    在焦点窗口部件的环中移动second窗口部件,这样当Tab被按下时,键盘焦点从first窗口部件移动到second窗口部件。

    注意因为second窗口部件的tab顺序被改变,你应该用链的方式安排顺序:

        setTabOrder( a, b ); // a到b

        setTabOrder( b, c ); // a到b到c

        setTabOrder( c, d ); // a到b到c到d

      

    不能像这样:

        setTabOrder( c, d ); // c到d,错误

        setTabOrder( a, b ); // a到b并且c到d

        setTabOrder( b, c ); // a到b到c,而不是c到d

      

    如果first或second有焦点代理,setTabOrder()替代它/它们的代理。

    也可以参考focusPolicysetFocusProxy()

    实例:customlayout/main.cpp.

    void QWidget::setUpdatesEnabled ( bool enable ) [虚 槽]

    设置更新是否生效为enable。详细情况请参考“updatesEnabled”属性。

    void QWidget::setWFlags ( WFlags f ) [虚 保护]

    设置窗口部件标记为f。

    窗口部件标记为Qt::WidgetFlags的组合。

    也可以参考testWFlags()getWFlags()clearWFlags()

    void QWidget::show () [虚 槽]

    显示这个窗口部件和它的子窗口部件。

    如果它的大小或位置已经发生改变,Qt保证窗口部件正好在被显示之前得到移动和重定义大小事件。

    你几乎不用重新实现这个函数。如果你需要在一个窗口部件被显示之前改变一些东西,请使用showEvent()替代它。如果你需要对初始化延时,请使用polish()

    也可以参考showEvent()hide()showMinimized()showMaximized()showNormal()visiblepolish()

    实例:canvas/main.cppfonts/simple-qfont-demo/simple-qfont-demo.cpplife/main.cpppopup/popup.cppt1/main.cppt3/main.cppt4/main.cpp

    QDialogQMenuBar中被重新实现。

    void QWidget::showEvent ( QShowEvent * ) [虚 保护]

    这个事件处理器可以在子类中被重新实现来接收窗口部件显示事件。

    在窗口部件被显示之前,非自发显示事件立即被发送给窗口部件。顶级窗口部件的自发显示事件在这之后被交付。

    也可以参考event()QShowEvent

    实例:qdir/qdir.cpp

    void QWidget::showFullScreen () [槽]

    用全屏模式显示这个窗口部件。

    调用这个函数只有对顶级窗口部件有效。

    为了从全屏模式返回,请调用showNormal()

    全屏模式在Windows下工作的非常好,但是在X下却有些问题。这些问题是由于指定X11客户端和窗口管理器之间通讯的ICCCM协议的限制。ICCCM很简单地不能理解无装饰的全屏模式窗口这一概念。因此,我们所能做的最好方式是请求一个无边框窗口并且放置和重定以它的大小为整个屏幕。依赖窗口管理器,这也许能工作,也许不能。无边框窗口使用MOTIF提示被请求,至少可以被实际存在地所有现代窗口管理器能够部分支持。

    另一个方法是绕过整个窗口管理器并且使用WX11BypassWM标记创建一个窗口。尽管这样还会有其它一些问题,比如完全地破坏键盘焦点和当桌面变化时或用户升起其它窗口时会有非常奇怪的效果。

    遵循现代的后ICCCM规范的未来X11窗口管理器也许能够完全地支持全屏模式。

    也可以参考showNormal()showMaximized()show()hide()visible

    void QWidget::showMaximized () [虚 槽]

    最大化显示这个窗口部件。

    对不是顶级窗口部件的,调用这个函数没有任何效果。

    X11下,这个函数在特定窗口管理器下允许不能正常工作。关于为什么的详细情况请参考窗口几何形状文档

    也可以参考showNormal()showMinimized()show()hide()visible

    实例:canvas/main.cpphelpviewer/main.cppmdi/application.cppqwerty/main.cppqwerty/qwerty.cppscribble/main.cpp

    void QWidget::showMinimized () [虚 槽]

    最小化显示这个窗口为一个图标。

    对不是顶级窗口部件的,调用这个函数没有任何效果。

    也可以参考showNormal()showMaximized()show()hide(), visibleminimized

    void QWidget::showNormal () [虚 槽]

    在窗口部件被最大化或最小化之后,恢复它。

    对不是顶级窗口部件的,调用这个函数没有任何效果。

    也可以参考showMinimized()showMaximized()show()hide()visible

    实例:mdi/application.cpp

    QSize QWidget::size () const

    返回不包含任何窗口框架的窗口部件的大小。详细情况请参考“size”属性。

    QSize QWidget::sizeHint () const [虚]

    返回建议的窗口部件大小。详细情况请参考“sizeHint”属性。

    QSizeGrip中被重新实现。

    QSize QWidget::sizeIncrement () const

    返回窗口部件的大小增量。详细情况请参考“sizeIncrement”属性。

    QSizePolicy QWidget::sizePolicy () const [虚]

    返回窗口部件的默认布局行为。详细情况请参考“sizePolicy”属性。

    void QWidget::stackUnder ( QWidget * w ) [槽]

    把窗口部件放在父窗口部件栈中w的下面。

    为了保证这个能工作,这个窗口部件自己和w必须是兄弟。

    也可以参考raise()lower()

    QStyle & QWidget::style () const

    返回这个窗口部件的图形用户界面的风格。

    也可以参考QWidget::setStyle()QApplication::setStyle()QApplication::style()

    void QWidget::styleChange ( QStyle & oldStyle ) [虚 保护]

    当窗口部件的风格发生变化时,这个虚函数被调用。oldStyle是原来的图形用户界面风格,你可以通过style()得到新的风格。

    如果你的窗口部件需要知道什么时候它的图形用户界面发生变化,请重新实现这个函数。你几乎必然需要使用update()来更新窗口部件。

    默认实现是更新包括几何形状的窗口部件。

    也可以参考QApplication::setStyle()style()update()updateGeometry()

    void QWidget::tabletEvent ( QTabletEvent * e ) [虚 保护]

    这个事件处理器可以在子类中被重新实现来接收这个窗口部件的写字板事件。

    如果你重新实现这个处理器,如果你不处理它的话,你忽略(ignore()这个事件是非常重要的,这样这个窗口部件的父对象就可以解释它。

    默认实现是忽略这个事件。

    也可以参考QTabletEvent::ignore()QTabletEvent::accept()event()QTabletEvent

    WFlags QWidget::testWFlags ( WFlags f ) const

    返回这个窗口部件的标记和f的位与(AND)运算结果。

    窗口部件标记是Qt::WidgetFlags的组合。

    也可以参考getWFlags()setWFlags()clearWFlags()

    QWidget * QWidget::topLevelWidget () const

    返回这个窗口部件的顶级窗口部件,比如,有(或者能够有)窗口系统框架的上一级祖先。

    如果这个窗口部件是顶级的,它自己被返回。

    通常的使用方法是改变窗口标题:

            aWidget->topLevelWidget()->setCaption( "New Caption" );

        

    也可以参考isTopLevel

    void QWidget::unsetCursor () [虚]

    重置这个窗口部件的光标形状。详细情况请参考“cursor”属性。

    void QWidget::unsetFont ()

    重置这个窗口部件的字体当前设置。详细情况请参考“font”属性。

    void QWidget::unsetPalette ()

    重置这个窗口部件的调色板。详细情况请参考“palette”属性。

    void QWidget::update () [槽]

    更新窗口部件,除非更新已经失效或者窗口部件被隐藏。

    这个函数不会导致一个立刻的重新绘制——更正确的是,当Qt回到主事件回路中时,它规划了所要处理的绘制事件。这样允许Qt来优化得到比调用repaint()更快的速度和更少的闪烁。

    几次调用update()的结果通常仅仅是一次paintEvent()调用。

    Qt通常在paintEvent()调用之前擦除这个窗口部件的区域。仅仅只有在WRepaintNoErase窗口部件标记被设置的时候,窗口部件本身对绘制它所有的像素负有责任。

    也可以参考repaint()paintEvent()updatesEnablederase()setWFlags()

    实例:desktop/desktop.cppscrollview/scrollview.cpp

    void QWidget::update ( int x, int y, int w, int h ) [槽]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    更新窗口部件中的矩形(x, y, w, h),除非更新已经失效或者窗口部件被隐藏。

    这个函数不会导致一个立刻的重新绘制——更正确的是,当Qt回到主事件回路中时,它规划了所要处理的绘制事件。这样允许Qt来优化得到比调用repaint()更快的速度和更少的闪烁。

    几次调用update()的结果通常仅仅是一次paintEvent()调用。

    如果w为负数,它被width()-x替换。如果h为负数,它被height()-y替换。

    Qt通常在paintEvent()调用之前擦除这个窗口部件的区域。仅仅只有在WRepaintNoErase窗口部件标记被设置的时候,窗口部件本身对绘制它所有的像素负有责任。

    也可以参考repaint(), paintEvent(), updatesEnabled and erase().

    void QWidget::update ( const QRect & r ) [槽]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    更新窗口部件中的矩形r,除非更新已经失效或者窗口部件被隐藏。

    这个函数不会导致一个立刻的重新绘制——更正确的是,当Qt回到主事件回路中时,它规划了所要处理的绘制事件。这样允许Qt来优化得到比调用repaint()更快的速度和更少的闪烁。

    几次调用update()的结果通常仅仅是一次paintEvent()调用。

    void QWidget::updateGeometry ()

    把这个窗口部件已经改变并且也许需要改变几何形状通告给布局系统。

    如果sizeHint()sizePolicy()已经发生变化,请调用这个函数。

    对于明确隐藏的窗口部件,updateGeometry()是没有操作的。只要这个窗口部件一显示出来,布局系统就将被通告。

    void QWidget::updateMask () [虚 保护]

    这个函数可以在子类中被重新实现来支持透明窗口部件。只要窗口部件改变状态,形状面具不得不被重新计算,它就会被调用。

    也可以参考autoMasksetMask()clearMask()

    QRect QWidget::visibleRect () const

    返回窗口部件的当前可见矩形。详细情况请参考“visibleRect”属性。

    void QWidget::wheelEvent ( QWheelEvent * e ) [虚 保护]

    这个事件处理器可以在子类中被重新实现来接收这个窗口部件的滚轮事件。

    如果你重新实现这个处理器,如果你不处理它的话,你忽略(ignore()这个事件是非常重要的,这样这个窗口部件的父对象就可以解释它。

    默认实现是忽略这个事件。

    也可以参考QWheelEvent::ignore()QWheelEvent::accept()event()QWheelEvent

    int QWidget::width () const

    返回不包含任何窗口框架的窗口部件宽度。详细情况请参考“width”属性。

    bool QWidget::winEvent ( MSG * ) [虚 保护]

    这个特定事件处理器可以在子类中被重新实现来接收本地Windows事件。

    在重新实现的这个函数中,如果你想停止Qt对这个事件的处理,请返回真。如果你返回假,这个本地事件被回传给Qt,它会把这个事件转化为一个Qt事件并且把它发送给这个窗口部件。

    警告:这个函数不能移植。

    也可以参考QApplication::winEventFilter()

    WId QWidget::winId () const

    返回窗口部件的窗口系统标识符。

    原则上是可以移植的,但是如果使用了它,一定是做了一些不可移植的事情。请留心。

    也可以参考find()

    实例:mainlyXt/editor.cpp.

    void QWidget::windowActivationChange ( bool oldActive ) [虚 保护]

    当窗口部件的窗口被窗口系统激活或者停用,这个虚函数被调用。oldActive是原来的状态,你可以通过isActiveWindow()得到新的设置。

    如果你的窗口部件需要知道什么时候它的窗口变为激活或停用,请重新实现这个函数。

    如果停止和激活颜色组不同与高亮和连接颜色,默认实现更新这个窗口部件的可视部分。

    也可以参考setActiveWindow()isActiveWindowupdate()palette

    int QWidget::x () const

    返回包括任何窗口框架的相对于它的父窗口部件的这个窗口部件的x坐标。详细情况请参考“x”属性。

    bool QWidget::x11Event ( XEvent * ) [虚 保护]

    这个特定事件处理器可以在子类中被重新实现来接收本地X11事件。

    在重新实现的这个函数中,如果你想停止Qt对这个事件的处理,请返回真。如果你返回假,这个本地事件被回传给Qt,它会把这个事件转化为一个Qt事件并且把它发送给这个窗口部件。

    警告:这个函数不能移植。

    也可以参考QApplication::x11EventFilter()

    QXtWidget中被重新实现。

    int QWidget::y () const

    返回包括任何窗口框架的相对于它的父窗口部件的这个窗口部件的y坐标。详细情况请参考“y”属性。

     

    属性文档

    bool acceptDrops

    这个属性保存的是窗口部件中放下事件是否有效。

    设置这个属性为真告诉系统这个窗口部件可以能够接收放下事件。

    如果窗口部件是桌面(QWidget::isDesktop()),如果其它应用程序正在使用桌面,这也许会失败,你可以调用acceptDrops()来测试这种情况是否发生。

    通过setAcceptDrops()可以设置属性值并且通过acceptDrops()来获得属性值。

    bool autoMask

    这个属性保存的是窗口部件中自动面具特征是否有效。

    透明窗口部件使用面具来定义它们的可视区域。QWidget有一些内置的支持可以使重新计算面具的任务更容易。当设置自动面具为真,只要窗口部件改变大小或者改变它的焦点状态updateMask()就将会被调用。注意你必须重新实现updateMask()(其中应该包含一个setMask()的调用)或者什么都不会发生。

    注意:当你在你的自定义窗口部件中被重新实现resizeEvent()focusInEvent()focusOutEvent()时并且还想确认自动面具计算工作,你应该在你的事件处理函数的后面添加:

        if ( autoMask() )

            updateMask();

      

    对于所有改变窗口部件的外观,都需要一个重新计算的面具,这都是真的。

    虽然面具是一个技术上很吸引人的概念,但是他有一个很大的缺点:当使用复杂的不能被很容易地使用相对简单的区域表达的面具时,它们在一些窗口系统中很慢。经典的实例就是透明的标签。它的内容的复杂形状使它需要用一个位图重新描述它的面具,这将会消耗内存和事件。如果你想让几个临近的窗口部件的背景没有缝隙的融合在一起,你也许想使用的是setBackgroundOrigin(),而不是面具。

    也可以参考updateMask()setMask()clearMask()backgroundOrigin

    通过setAutoMask()可以设置属性值并且通过autoMask()来获得属性值。

    QBrush backgroundBrush

    这个属性保存的是窗口部件的背景画刷。

    背景画刷依赖于窗口部件的调色板和它的背景模式。

    也可以参考backgroundColor()backgroundPixmap()eraseColor()paletteQApplication::setPalette()

    通过backgroundBrush()来获得属性值。

    BackgroundMode backgroundMode

    这个属性保存的是绘制窗口部件背景所使用的颜色模式。

    setPaletteBackgroundColor()读取这个属性来决定palette中的哪一个被设置。

    对于绝大多数出口部,默认的就足够了(PaletteBackground,通常是灰色),但是一些需要使用PaletteBase(文本输出的背景,通常是白色)或者其它模式。

    凹陷的QListBox并且为了和它的环境形成对照使用基本色,在构造函数中这样做:

        setBackgroundModePaletteBase );

        

    对于Qt内置的窗口部件,你永远都不需要为它们设置背景模式,但是你也许需要在你的自定义窗口部件中考虑设置一下,这样setPaletteBackgroundColor()就可以像被期待地那样工作。

    注意对于setBackgroundMode()中的两个背景模式值,名为FixedPixmapFixedColor,没有什么意义。你必须调用setBackgroundPixmap()setPaletteBackgroundColor()来替代。

    通过setBackgroundMode()可以设置属性值并且通过backgroundMode()来获得属性值。

    BackgroundOrigin backgroundOrigin

    这个属性保存的是窗口部件的背景的原点。

    这个原点是WidgetOrigin(默认)、ParentOriginWindowOrigin其中之一。

    只有在窗口部件有一个背景像素映射,对于定位有所不同。使用WindowOrigin,临近的几个窗口部件的背景会融合的很好好像没有缝隙一样。

    也可以参考backgroundPixmap()backgroundMode

    通过setBackgroundOrigin()设置属性值并且通过backgroundOrigin()来获得属性值。

    QSize baseSize

    这个属性保存的是窗口部件的基础大小。

    如果窗口部件定义了sizeIncrement(),基础大小就被用来计算一个确切的窗口部件大小。

    也可以参考sizeIncrement

    通过setBaseSize()设置属性值并且通过baseSize()来获得属性值。

    QString caption

    This property holds the window caption (title). 这个属性保存的是窗口标题。

    这个属性只对顶级窗口部件有用。如果没有标题被设置,标题就为QString::null

    也可以参考icon and iconText

    通过setCaption()可以设置属性值并且通过caption()来获得属性值。

    QRect childrenRect

    这个属性保存的是窗口部件的子对象的边界矩形。

    隐藏的子对象除外。

    也可以参考childrenRegiongeometry

    通过childrenRect()来获得属性值。

    QRegion childrenRegion

    这个属性保存的是窗口部件的子对象所占用的组合区域。

    隐藏的子对象除外。

    也可以参考childrenRectgeometry

    通过childrenRegion()来获得属性值。

    QColorGroup colorGroup

    This property holds the current color group of the widget palette. 这个属性保存的是窗口部件调色板的当前颜色组。

    颜色组由窗口部件的状态决定。一个失效的窗口部件是QPalette::disabled()颜色组,一个有键盘焦点的窗口部件是QPalette::active()颜色组,一个停止的窗口部件是QPalette::inactive()颜色组。

    也可以参考palette

    通过colorGroup()来获得属性值。

    QCursor cursor

    这个属性保存的是窗口部件的光标外形。

    当鼠标在窗口部件之上时,鼠标光标将采用这个外形。对于可以使用的外形的范围请参考预定义的光标对象列表

    一个编辑器窗口部件也许使用I形光标:

            setCursorIbeamCursor );

        

    如果没有光标被设置,或者在调用unsetCursor()之后,父对象的光标被使用。函数unsetCursor()对于顶级窗口部件没有效果。

    也可以参考QApplication::setOverrideCursor()

    通过setCursor()设置属性值,通过cursor()来获得属性值并且通过unsetCursor()重置属性值。

    bool customWhatsThis

    这个属性保存的是窗口部件是否手动处理这是什么的帮助。

    customWhatsThis()的默认实现返回假,这也就是说窗口部件在这是什么状态将不接受任何事件。

    通过调用QWhatsThis::leaveWhatsThisMode(),不管有没有任何实际显示的帮助文本,窗口部件会离开这是什么模式。

    如果你的窗口部件是一个被动的内部行动者,假设在所有环境下工作时,你也许要重新实现customWhatsThis()

    也可以参考QWhatsThis::inWhatsThisMode()QWhatsThis::leaveWhatsThisMode()

    通过customWhatsThis()来获得属性值。

    bool enabled

    这个属性保存的是窗口部件是否有效。

    一个有效的窗口部件接收键盘和鼠标事件,一个失效的窗口部件不能。实际上,有效的窗口部件只有在它处于焦点时才接收键盘事件。

    一些窗口部件当它们被失效的时候,显示得不同。例如,一个按钮也许把它的标签变灰。如果你的窗口部件需要知道它什么时候生效或失效,你可以重新实现enabledChange()函数。

    使一个窗口部件失效就隐含地使它所有的子对象失效。使一个窗口部件生效就会逐个把它的子窗口部件生效,除非它们被明确地失效。

    也可以参考enabledisEnabledTo()QKeyEventQMouseEventenabledChange()

    通过setEnabled()设置属性值并且通过isEnabled()来获得属性值。

    bool focus

    这个属性保存的是窗口部件(或者它的焦点代理)是否得到键盘输入焦点。

    实际上等价于qApp->focusWidget() == this。

    也可以参考setFocus()a href="#clearFocus">clearFocus()focusPolicyQApplication::focusWidget()

    通过hasFocus()来获得属性值。

    bool focusEnabled

    这个属性保存的是窗口部件是否接收键盘焦点

    键盘焦点初始状态是失效的(比如,focusPolicy() == QWidget::NoFocus)。

    如果一个窗口部件处理键盘事件,你必须为它使键盘焦点生效。这通常在窗口部件的构造函数中完成。例如,QLineEdit的构造函数调用setFocusPolicy(QWidget::StrongFocus)

    也可以参考focusPolicyfocusInEvent()focusOutEvent()keyPressEvent()keyReleaseEvent()enabled

    通过isFocusEnabled()来获得属性值。

    FocusPolicy focusPolicy

    这个属性保存的是窗口部件接收键盘焦点的策略。

    如果窗口部件通过tab来接收键盘焦点,这个策略就是QWidget::TabFocus;如果窗口部件通过点击来接收键盘焦点,这个策略就是QWidget::ClickFocus;如果窗口部件上述两种方式都使用,是QWidget::StrongFocus;并且如果它不接收焦点(QWidget的默认值),是QWidget::NoFocus

    如果一个窗口部件处理键盘事件,你必须为它使键盘焦点生效。这通常在窗口部件的构造函数中完成。例如,QLineEdit的构造函数调用setFocusPolicy(QWidget::StrongFocus)

    也可以参考focusEnabledfocusInEvent()focusOutEvent()keyPressEvent()keyReleaseEvent()enabled

    通过setFocusPolicy()设置属性值并且通过focusPolicy()来获得属性值。

    QFont font

    这个属性保存的是窗口部件当前的字体集。

    fontInfo()函数报告这个窗口部件所用的实际字体。

    只要没有特定字体被设置,或者在unsetFont()被调用之后,那么这个窗口部件类使用父窗口部件的字体或者(如果这个窗口部件是顶级窗口部件)使用默认应用程序字体。

    这段代码设置12点的helvetica粗字体:

        QFont f( "Helvetica", 12, QFont::Bold );

        setFont( f );

        

    另外设置字体时,setFont()通知所有子对象关于这个变化。

    也可以参考fontChange()fontInfo()fontMetrics()ownFont

    通过setFont()设置属性值,通过font()来获得属性值并且通过unsetFont()重置属性值。

    QRect frameGeometry

    这个属性保存的是相对于它的父对象包含任何窗口框架的窗口部件的几何形状。

    对于顶级窗口部件的几何形状的概述请参考窗口几何形状文档

    也可以参考geometryxa href="#y-prop">ypos

    通过frameGeometry()来获得属性值。

    QSize frameSize

    这个属性保存的是包含任何窗口框架的窗口部件的大小。

    通过frameSize()来获得属性值。

    QRect geometry

    这个属性保存的是相对于它的父对象不包括窗口框架的窗口部件的几何形状。

    当窗口部件改变几何形状时,如果它是可视的,它立即接收到一个移动事件(moveEvent())和/或一个重定义大小(resizeEvent())。如果它当前不是可视的,它被保证会在被显示之前接收到适当的事件。

    如果它在由minimumSize()maximumSize()定义的范围之外,大小组件被调整。

    setGeometry()是虚的,并且所有Qt中其它重载setGeometry()的重新实现调用它。

    警告:在resizeEvent()moveEvent()中调用setGeometry()会导致无限循环。

    对于顶级窗口部件的几何形状的概述请参考窗口几何形状文档

    也可以参考frameGeometryrectpossizemoveEvent()resizeEvent()minimumSizemaximumSize

    通过setGeometry()设置属性值并且通过geometry()来获得属性值。

    int height

    这个属性保存的是不包括窗口框架的窗口部件的高度。

    对于顶级窗口部件的几何形状的概述请参考窗口几何形状文档

    也可以参考geometrywidthsize

    通过height()来获得属性值。

    bool hidden

    这个属性保存的是窗口部件是否明确地隐藏。

    如果为假,这个窗口部件是可视的或者如果它的所有祖先变为可视,它将变为可视的。

    也可以参考hide()show()visibleisVisibleTo()

    通过isHidden()来获得属性值。

    QPixmap icon

    这个属性保存的是窗口部件图标像素映射。

    这个属性只对顶级窗口部件有效。如果没有图标被设置,icon()返回0

    也可以参考iconTextcaption设置应用程序图标

    通过setIcon()设置属性值并且通过icon()来获得属性值。

    QString iconText

    这个属性保存的是窗口部件图标文本。

    这个属性只对顶级窗口部件有效。如果没有图标文本被设置,这个函数返回QString::null

    也可以参考iconcaption

    通过setIconText()设置属性值并且通过iconText()来获得属性值。

    bool isActiveWindow

    这个属性保存的是窗口部件或者它的一个子对象是否是活动窗口。

    活动窗口是有键盘焦点的窗口

    当弹出窗口是可视的,这个属性对于活动窗口和这个弹出窗口都是真。

    也可以参考setActiveWindow()QApplication::activeWindow()

    通过isActiveWindow()来获得属性值。

    bool isDesktop

    这个属性保存的是窗口部件是否是桌面窗口部件,比如,代表桌面。

    一个桌面窗口部件也是顶级窗口部件。

    也可以参考isTopLevelQApplication::desktop()

    通过isDesktop()来获得属性值。

    bool isDialog

    这个属性保存的是窗口部件是否是对话框窗口部件。

    对话框窗口部件是次要的顶级窗口部件,比如一个有父对象的顶级窗口部件。

    也可以参考isTopLevelQDialog

    通过isDialog()来获得属性值。

    bool isModal

    这个属性保存的是窗口部件是否是模式窗口部件。

    这个属性只对顶级窗口部件有效。一个模式窗口部件防止对其它所有顶级窗口部件得到任何输入。

    也可以参考isTopLevelisDialogQDialog

    通过isModal()来获得属性值。

    bool isPopup

    这个属性保存的是窗口部件是否是弹出窗口部件。

    一个弹出窗口部件是在窗口部件的构造函数中使用窗口部件标记WType_Popup创建的。一个弹出窗口部件也是一个顶级窗口部件。

    也可以参考isTopLevel

    通过isPopup()来获得属性值。

    bool isTopLevel

    This property holds whether the widget is a top-level widget. 这个属性保存的是窗口部件是否是顶级窗口部件。

    顶级窗口部件通常有框架和标题弹出桌面窗口部件也是顶级窗口部件。

    顶级窗口部件可以有父窗口部件。然后它和它的父窗口部件就形成一个组并且当它的父对象被删除或最小化等等时,它也被删除或最小化等等。如果被窗口部件支持的话,它和它的父对象一样也有一个普通任务栏条目。

    QDialogQMainWindow窗口部件默认是顶级的,尽管在构造函数中被指定一个父窗口部件。这个行为是由WType_TopLevel窗口部件标记指定的。

    也可以参考topLevelWidget()isDialogisModalisPopupisDesktopparentWidget()

    通过isTopLevel()来获得属性值。

    int maximumHeight

    这个属性保存的是窗口部件的最大高度。

    这个属性和maximumSize().height()一致。

    也可以参考maximumSizemaximumWidth

    通过setMaximumHeight()设置属性值并且通过maximumHeight().来获得属性值。

    QSize maximumSize

    这个属性保存的是窗口部件的最大大小。

    这个窗口部件不能被重定义为比这个最大大小更大的大小了。

    也可以参考maximumWidthmaximumHeightmaximumSizeminimumSizesizeIncrement

    通过setMaximumSize()设置属性值并且通过maximumSize()来获得属性值。

    int maximumWidth

    这个属性保存的是窗口部件的最大宽度。

    这个属性和maximumSize().width()一致。

    也可以参考maximumSizemaximumHeight

    通过setMaximumWidth()设置属性值并且通过maximumWidth()来获得属性值。

    QRect microFocusHint

    这个属性保存的是窗口部件的当前设置的微焦点提示。

    更多信息请参考setMicroFocusHint()的文档。

    通过microFocusHint()来获得属性值。

    bool minimized

    这个属性保存的是窗口部件是否是最小化的(变为图标了)。

    这个属性和顶级窗口部件相关。

    也可以参考showMinimized()visibleshow()hide()showNormal()

    通过isMinimized()来获得属性值。

    int minimumHeight

    这个属性保存的是窗口部件的最小高度。

    这个属性和minimumSize().height()一致。

    也可以参考minimumSizeminimumWidth

    通过setMinimumHeight()设置属性值并且通过minimumHeight()来获得属性值。

    QSize minimumSize

    这个属性保存的是窗口部件的最小大小。

    这个窗口部件不能被重定义比这个最小大小更小的大笑了。如果当前大小更小的话,窗口部件的大小被强制为最小大小。

    如果你在这个窗口部件中使用了布局,最小大小将会被这个布局设置,而不是setMinimumSize(),除非你设置布局的重定义大小模式为QLayout::FreeResize

    也可以参考minimumWidthminimumHeightmaximumSizesizeIncrementQLayout::resizeMode

    通过setMinimumSize()设置属性值并且通过minimumSize()来获得属性值。

    QSize minimumSizeHint

    这个属性保存的是建议的窗口部件最小大小。

    如果这个属性值是无效的大小,那么就没有被建议的最小大小了。

    如果这个窗口部件中没有布局,minimumSizeHint()默认实现返回无效大小并且否则的话返回布局的最小大小。绝大多数内置窗口部件重新实现了minimumSizeHint()

    QLayout从来不会重定义窗口部件大小小于minimumSizeHint

    也可以参考QSize::isValid()sizeminimumSizesizePolicy

    通过minimumSizeHint()来获得属性值。

    int minimumWidth

    这个属性保存的是窗口部件的最小宽度。

    这个属性和minimumSize().width()一致。

    也可以参考minimumSizeminimumHeight

    通过setMinimumWidth()设置属性值并且通过minimumWidth()来得到属性值。

    bool mouseTracking

    这个属性保存的是窗口部件跟踪鼠标是否生效。

    如果鼠标跟踪失效(默认),当鼠标被移动的时候只有在至少一个鼠标按键被按下时,这个窗口部件才会接收鼠标移动事件。

    如果鼠标跟踪生效,如果没有按键被按下,这个窗口部件也会接收鼠标移动事件。

    也可以参考mouseMoveEvent()QApplication::setGlobalMouseTracking()

    通过setMouseTracking()设置属性值并且通过hasMouseTracking()来获得属性值。

    bool ownCursor

    这个属性保存的是窗口部件是否使用它自己的光标。

    如果为假,这个窗口部件使用它父窗口部件的光标。

    也可以参考cursor

    通过ownCursor()来获得属性值。

    bool ownFont

    这个属性保存的是窗口部件是否使用它自己的字体。

    如果为假,这个窗口部件使用它父窗口部件的字体。

    也可以参考font

    通过ownFont()来获得属性值。

    bool ownPalette

    这个属性保存的是窗口部件是否使用它自己的调色板。

    如果为假,这个窗口部件使用它父窗口部件的调色板。

    也可以参考palette

    通过ownPalette()来获得属性值。

    QPalette palette

    这个属性保存的是窗口部件的调色板。

    只要没有特定的调色板被设置,或者在unsetPalette()被调用之后,这个窗口部件的特定调色板就是父窗口部件的调色板或者(如果这个窗口部件是顶级窗口部件)默认的应用程序调色板。

    可以替代定义整个新的调色板的,你也可以使用paletteBackgroundColorpaletteBackgroundPixmappaletteForegroundColor方便的属性来只改变窗口部件的背景和前景外观。

    也可以参考ownPalettecolorGroupQApplication::palette()

    通过setPalette()设置属性值,通过palette()来获得属性值并且通过unsetPalette()重置属性值。

    QColor paletteBackgroundColor

    这个属性保存的是窗口部件的背景色。

    这个调色板背景色通常被setBackgroundMode()隐含地设置,尽管它也可以由setPaletteBackgroundColor()明显地设置。setPaletteBackgroundColor()是一个创建和设置通过setPalette()修改过的QPalette方便函数。这个调色板根据窗口部件的背景模式被修改。例如,如果背景模式是PaletteButton,调色板的QColorGroup::Button颜色条目所用的颜色被设置。

    如果有一个背景像素映射(使用setPaletteBackgroundPixmap()设置的),那么这个函数的返回值是不确定的。

    也可以参考paletteBackgroundPixmappaletteForegroundColorpalettecolorGroup

    通过setPaletteBackgroundColor()设置属性值,通过paletteBackgroundColor()来获得属性值并且通过unsetPalette()重置属性值。

    QPixmap paletteBackgroundPixmap

    这个属性保存的是窗口部件的背景像素映射。

    这个调色板背景像素映射通常被setBackgroundMode()隐含地设置,尽管它也可以由setPaletteBackgroundPixmap()明显地设置。setPaletteBackgroundPixmap()是一个创建和设置通过setPalette()修改过的QPalette方便函数。这个调色板根据窗口部件的背景模式被修改。例如,如果背景模式是PaletteButton,调色板的QColorGroup::Button颜色条目所用的像素映射被设置。

    如果有一个简单的背景颜色(使用setPaletteBackgroundColor()设置的),那么这个函数返回0

    也可以参考paletteBackgroundColorpaletteForegroundColorpalettecolorGroup

    通过setPaletteBackgroundPixmap()设置属性值,通过paletteBackgroundPixmap()来获得属性值并且通过unsetPalette()重置属性值。

    QColor paletteForegroundColor

    这个属性保存的是窗口部件的前景色。

    setPaletteForegroundColor()是一个创建和设置通过setPalette()修改过的QPalette方便函数。这个调色板根据窗口部件的背景模式被修改。例如,如果背景模式是PaletteButton,调色板的QColorGroup::ButtonText颜色条目所用的颜色被设置。

    也可以参考paletteQApplication::setPalette()backgroundModeforegroundColor()backgroundModesetEraseColor()

    通过setPaletteForegroundColor()设置属性值,通过paletteForegroundColor()来获得属性值并且通过unsetPalette().重置属性值。

    QPoint pos

    这个属性保存的是窗口部件在它的父窗口部件中的位置。

    如果这个窗口部件是顶级窗口部件,那它的位置就是在桌面上包括它的框架的窗口部件的位置。

    当改变位置时,这个窗口部件如果可视,会立即接收一个移动事件(moveEvent())。如果这个窗口部件当前不是可视的,它被保证会在它被显示之前收到这个事件。

    move()是虚函数,并且Qt中所有其它重载move()的重新实现都调用它。

    警告:在moveEvent()调用move()setGeometry()会导致无限循环。

    对于顶级窗口部件的几何形状的概述请参考窗口几何形状文档

    也可以参考frameGeometrysizexy

    通过move()设置属性值并且通过pos()来获得属性值。

    QRect rect

    这个属性保存的是不包含任何窗口框架的窗口部件的内部几何形状。

    这个矩形属性等于QRect(0, 0, width(), height())

    对于顶级窗口部件的几何形状的概述请参考窗口几何形状文档

    也可以参考size

    通过rect()来获得属性值。

    QSize size

    这个属性保存的是不包含任何窗口框架的窗口部件的大小。

    当重新定义大小时,这个窗口部件如果可视,会立即收到一个重新定义大小事件(resizeEvent())。如果这个窗口部件当前不是可视的,它被保证会在它被显示之前收到这个事件。

    如果这个大小在minimumSize()a href="#maximumSize">maximumSize()定义的范围之外,它被调整。此外,这个大小总是至少为QSize(1, 1)

    resize()是虚函数,并且Qt中所有其它重载resize()的重新实现都调用它。

    警告:在resizeEvent()调用resize()setGeometry()会导致无限循环。

    也可以参考posgeometryminimumSizemaximumSizeresizeEvent()

    通过resize()设置属性值并且通过size()来获得属性值。

    QSize sizeHint

    这个属性保存的是建议的窗口部件大小。

    如果这个属性值是无效的大小,那么就没有大小被建议。

    如果这个窗口部件没有布局,sizeHint()的默认实现返回一个无效大小,并且否则的话就返回布局的首选大小。

    也可以参考QSize::isValid()minimumSizeHintsizePolicyminimumSizeupdateGeometry()

    通过sizeHint()来获得属性值。

    QSize sizeIncrement

    这个属性保存的是窗口部件的大小增量。

    当用户重新定义窗口的大小时,大小会在水平方向上按sizeIncrement().width()像素和垂直方向上按sizeIncrement.height()像素来逐步变化,基础大小为baseSize() 。首选的窗口部件大小为非负整数i和j:

            width = baseSize().width() + i * sizeIncrement().width();

            height = baseSize().height() + j * sizeIncrement().height();

        

    注意,当你为所有的窗口部件设置大小增量时,它只对顶级窗口部件有效。

    警告:大小增量在Windows下没有效果,并且也许会被X上的窗口管理器忽视。

    也可以参考sizeminimumSizemaximumSize

    通过setSizeIncrement()设置属性值并且通过sizeIncrement()来获得属性值。

    QSizePolicy sizePolicy

    这个属性保存的是窗口部件的默认布局行为。

    如果有一个QLayout管理这个窗口部件的子对象,这个大小策略由布局使用的大小策略指定。如果没有这样的QLayout,那么这个函数的结果被使用。

    默认策略是首选/首选,也就是说窗口部件可以被自由地重新定义大小,但是首选的是sizeHint()返回的大小。具有按钮特征的窗口部件设置它们的大小策略为水平方向可以伸展,但垂直方向固定。这同样适用于行编辑控件(比如QLineEditQSpinBox或可编辑的QComboBox)和其它水平方向的窗口部件(比如QProgressBar)。QToolButton的大小策略通常是允许两个方向都可以变化。支持不同方向的窗口部件(比如QSliderQScrollBarQHeader)仅仅按被指定的方向变化。可以提供滚动条的窗口部件(通常是QScrollView的子类)趋向于指定它们可以使用额外的空间,并且它们可以在小于sizeHint()时正常工作。

    也可以参考sizeHintQLayoutQSizePolicyupdateGeometry()

    通过setSizePolicy()设置属性值并且通过sizePolicy()来获得属性值。

    bool underMouse

    这个属性保存的是窗口部件是否在鼠标光标下。

    这个值在拖放操作期间不会被完全地更新。

    也可以参考QEvent::EnterQEvent::Leave

    通过hasMouse()来获得属性值。

    bool updatesEnabled

    这个属性保存的是更新是否生效。

    如果更新失效,调用update()repaint()是没有效果的。如果更新失效,来自窗口系统的绘制事件会被正常处理。

    setUpdatesEnabled()通常被用于在一小段事件内使更新失效,例如为了避免在大的变化期间发生屏幕闪烁。

    实例:

        setUpdatesEnabled( FALSE );

        bigVisualChanges();

        setUpdatesEnabled( TRUE );

        repaint();

      

    也可以参考update()repaint()paintEvent()

    通过setUpdatesEnabled()设置属性值并且通过isUpdatesEnabled()来获得属性值。

    bool visible

    这个属性保存的是窗口部件是否可视。

    如果窗口部件的父窗口部件直到顶级窗口部件是可视的,调用show()设置它为可视的。如果有一个祖先是不可视的,直到它的所有祖先被显示时,这个窗口部件才会变为可视。

    调用hide()明显地隐藏一个窗口部件。一个明显地被隐藏的窗口部件永远不会被变为可视,尽管它的所有祖先都变为可视,除非你显示它。

    图标化的顶级窗口部件也处在隐藏状态,也就是isMinimized()返回真。存在于另一个虚拟桌面上的窗口(在一些支持这个概念的平台上)也处在隐藏状态。

    一个窗口部件会因为屏幕上其它可视的窗口部件而变暗。

    当窗口部件的可视状态发生变化时,它接收显示和隐藏事件。隐藏和显示事件都不需要浪费CPU在准备或显示信息给用户。例如,一个视频应用程序也许只是简单地停止产生新的帧。

    也可以参考show(), hide()hiddenisVisibleTo()minimizedshowEvent()hideEvent()

    通过isVisible()来获得属性值。

    QRect visibleRect

    这个属性保存的是窗口部件的当前可视矩形。

    这个属性对于优化窗口部件的立即重新绘制很有用。典型用法是:

        repaint( w->visibleRect() );

      

        repaint( w->visibleRect(), FALSE );

      

    如果没有什么是可视的,这个返回的矩形为空。

    通过visibleRect()来获得属性值。

    int width

    这个属性保存的是不包含任何窗口框架的窗口部件宽度。

    对于顶级窗口部件的几何形状的概述请参考窗口几何形状文档

    也可以参考geometryheightsize

    通过width()来获得属性值。

    int x

    这个属性保存的是相对于它的父对象包含任何窗口框架的窗口部件的x坐标。

    对于顶级窗口部件的几何形状的概述请参考窗口几何形状文档

    也可以参考frameGeometryypos

    通过x()来获得属性值。

    int y

    这个属性保存的是相对于它的父对象包含任何窗口框架的窗口部件的y坐标。

    对于顶级窗口部件的几何形状的概述请参考窗口几何形状文档

    也可以参考frameGeometryxpos

    通过y()来获得属性值。

     

    QDialog类参考

    QDialog类是对话框窗口的基类。 详情请见……

    #include <qdialog.h>

    继承了QWidget

    QColorDialogQErrorMessageQFileDialogQFontDialogQInputDialogQMessageBoxQProgressDialogQTabDialogQWizard继承。

    所有成员函数的列表。

    公有成员

    公有槽

    属性

    保护成员

    保护槽

     

    详细描述

    QDialog类是对话框窗口的基类。

    对话框窗口是主要用于短期任务以及和用户进行简要通讯的顶级窗口。QDialog可以是模式的也可以是非模式的。QDialog支持扩展性并且可以提供返回值。它们可以有默认按钮QDialog也可以有一个QSizeGrip在它的右下角,使用setSizeGripEnabled()

    注意QDialog使用父窗口部件的方法和Qt中其它类稍微不同。对话框总是顶级窗口部件,但是如果它有一个父对象,它的默认位置就是父对象的中间。它也将和父对象共享工具条条目。

    这里有三种有用的对话框:

    1. 模式对话框就是阻塞同一应用程序中其它可视窗口的输入的对话框:用户必须完成这个对话框中的交互操作并且关闭了它之后才能访问应用程序中的其它任何窗口。模式对话框有它们自己的本地事件循环。用来让用户选择一个文件或者用来设置应用程序参数的对话框通常是模式的。调用exec()来显示模式对话框。当用户关闭这个对话框,exec()将提供一个可用的返回值并且这时流程控制继续从调用exec()的地方进行。通常,我们连接默认按钮,例如“OK”accept()槽并且把“Cancel”连接到reject()槽,来使对话框关闭并且返回适当的值。另外我们也可以连接done()槽,传递给它AcceptedRejected
    2. 非模式对话框是和同一个程序中其它窗口操作无关的对话框。在字处理软件中查找和替换对话框通常是非模式的来允许同时与应用程序主窗口和对话框进行交互。调用show()来显示非模式对话框。show()立即返回,这样调用代码中的控制流将会继续。在实践中你将会经常调用show()并且在调用show()的函数最后,控制返回主事件循环。
    3. “半模式”对话框是立即把控制返回给调用者的模式对话框。半模式对话框没有它们自己的事件循环,所以你将需要周期性地调用QApplication::processEvents()来让这个半模式对话框有处理它的事件的机会。进程对话框(例如QProgressDialog)就是一个实例,在你想让用户能够和进程对话框交互的地方那个,例如撤销一个长期运行的操作,但是需要实际上执行这个操作。半模式对话框模式标记被设置为真并且调用show()函数来被显示。

    默认按钮

    对话框的默认按钮适当用户按下回车键或者换行键时被按下的按钮。这个按钮用来表示用户接受对话框的设置并且希望关闭这个对话框。使用QPushButton::setDefault()QPushButton::isDefault()QPushButton::autoDefault()来设置并且控制对话框的默认按钮。

    扩展性

    扩展性是可以用两种方式来显示对话框:一个局部对话框用来显示通常最常用的选项,和一个显示所有选项的完全对话框。通常可扩展的对话框将初始化为一个局部对话框,但是有一个更多按钮。如果用户点击这个更多按钮,完全对话框将会出现。扩展性是由setExtension()setOrientation()showExtension()

    返回值(模式对话框)

    模式对话框通常用在需要返回值的地方,例如需要分清用户按下“OK”还是“Cancel”。对话框可以通过调用accept()reject()槽来被关闭,并且exec()将返回适当的AcceptedRejectedexec()返回这个对话框的结果。如果窗口还没有被销毁,这个结果也可以通过result()得到。如果WDestructiveClose标记被设置,那么当exec()返回时,对话框被删除。

    实例

    模式对话框。

            QFileDialog *dlg = new QFileDialog( workingDirectory,

                    QString::null, 0, 0, TRUE );

            dlg->setCaption( QFileDialog::tr( "Open" ) );

            dlg->setMode( QFileDialog::ExistingFile );

            QString result;

            if ( dlg->exec() == QDialog::Accepted ) {

                result = dlg->selectedFile();

                workingDirectory = dlg->url();

            }

            delete dlg;

            return result;

    非模式对话框。在show()调用之后,控制返回到主事件循环中。

        int main( int argc, char **argv )

        {

            QApplication a( argc, argv );

            int scale = 10;

            LifeDialog *life = new LifeDialog( scale );

            a.setMainWidget( life );

            life->setCaption("Qt Example - Life");

            life->show();

            return a.exec();

        }

    半模式对话框的实例请参考QProgressDialog文档。

    请参考QTabDialogQWidgetQProgressDialogGUI Design Handbook: Dialogs, Standard抽象窗口部件类对话框类

     

    成员类型文档

    QDialog::DialogCode

    模式对话框返回的值。

    • QDialog::Accepted
    • QDialog::Rejected

     

    成员函数文档

    QDialog::QDialog ( QWidget * parent = 0, const char * name = 0, bool modal = FALSE, WFlags f = 0 )

    构造一个父对象为parent、名称为name的对话框。

    如果modal为假(默认),这个对话框是非模式的并且应该使用show()来被显示。如果modal为真,这个对话框使用exec()来被显示,则它是模式的,也就是说会阻塞这个应用程序中其它窗口的输入。如果modal为真并且使用show()来被显示,则它是半模式的。

    窗口部件f将被传递给QWidget的构造函数。

    如果,例如,我们不想要对话框的标题栏中这是什么按钮,在f中传递WStyle_Customize | WStyle_NormalBorder | WStyle_Title | WStyle_SysMenu

    我们建议你传递一个非空的父对象。

    请参考QWidget::setWFlags()Qt::WidgetFlags

    QDialog::~QDialog ()

    销毁这个对话框,删除它所有的子对象。

    void QDialog::accept () [虚 保护 槽]

    隐藏模式对话框并且设置结果代码为Accepted

    请参考reject()done()

    实例:chart/setdataform.cpp

    void QDialog::done ( int r ) [虚 保护 槽]

    隐藏模式对话框并且设置结果代码为r。这将使用本地事件循环来完成,并且exec()返回r。

    如果对话框使用WDestructiveClose来被设置,done()也会销毁这个对话框。如果对话框是应用程序的主窗口部件,那么应用程序终止。

    请参考accept()reject()QApplication::mainWidget()QApplication::quit()

    int QDialog::exec () [槽]

    执行模式对话框。控制传递给这个对话框一直到用户关闭它,在本地事件循环完成的点并且函数返回DialogCode结果。在用户关闭这个对话框之前,不能和同一应用程序中的其它窗口交互。对于非模式或半模式对话框请使用show()

    请参考show()result()

    实例:chart/chartform.cppi18n/main.cppnetwork/networkprotocol/view.cppa href="qdir-example.html#x1805">qdir/qdir.cppshowimg/showimg.cppwizard/main.cpp

    QWidget * QDialog::extension () const

    返回对话框的扩展或者如果没有扩展被定义返回0

    请参考setExtension()

    bool QDialog::isSizeGripEnabled () const

    如果大小控制生效,返回真,否则返回假。详细情况请参考“sizeGripEnabled”属性。

    Orientation QDialog::orientation () const

    返回对话框的扩展方向。

    请参考setOrientation()

    void QDialog::reject () [虚 保护 槽]

    隐藏模式对话框并且设置结果代码为Rejected

    请参考accept()done()

    int QDialog::result () const

    返回模式对话框的结果代码,AcceptedRejected

    如果对话框使用WDestructiveClose标记构造,不要调用这个函数。(无论如何,exec()返回结果代码。)

    void QDialog::setExtension ( QWidget * extension )

    设置窗口部件extension为对话框的扩展,删除任何以前的扩展。对话框拥有扩展的所有权。注意如果传递0,则任何存在的扩展都将被删除。

    只有当对话框被隐藏时,这个函数才能被调用。

    请参考showExtension()setOrientation()extension()

    void QDialog::setOrientation ( Orientation orientation )

    如果orientation是Horizontal,扩展将会显示在对话框主区域的右面。如果orientation是Vertical,扩展将会显示在对话框主区域的下面。

    请参考orientation()setExtension()

    void QDialog::setResult ( int i ) [保护]

    设置模式对话框的结果代码为i。

    void QDialog::setSizeGripEnabled ( bool )

    设置大小控制是否生效。详细情况请参考“sizeGripEnabled”属性。

    void QDialog::show () [虚]

    显示非模式或半模式对话框。控制立即返回到调用代码中。

    对话框没有一个本地事件循环,所以你必须定时地调用QApplication::processEvents()来使对话框能够得到处理它的事件的机会。

    如果在构造函数中,模式标记被设置为真,对话框将为半模式

    警告:

    Qt 2.x中,在一个模式对话框中调用show()进入一个本地事件循环并且像exec()一样工作,但是不返回exec()所返回的结果代码。Trolltech已经一直警告这样做是不被建议的。

    请参考exec()

    实例:movies/main.cppshowimg/showimg.cppsql/overview/form1/main.cpp

    QWidget中重新实现的。

    void QDialog::showExtension ( bool showIt ) [保护 槽]

    如果showIt为真,对话框的扩展被显示,否则扩展被隐藏。

    这个槽通常被连接到QPushButtonQButton::toggled()信号上。

    如果对话框不是可视的,或者没有扩展,则什么都不会发生。

    请参考show()setExtension()setOrientation()

     

    属性文档

    bool sizeGripEnabled

    这个属性保存的是大小控制是否生效。

    当这个属性生效时,QSizeGrip被放置到对话框的右下角。默认情况下,大小控制失效。

    通过setSizeGripEnabled()设置属性值并且通过isSizeGripEnabled()来获得属性值。

     

    QMainWindow类参考

    QMainWindow类提供一个有菜单条、锚接窗口(例如工具条)和一个状态条的主应用程序窗口。 详情请见……

    #include <qmainwindow.h>

    继承了QWidget

    所有成员函数的列表。

    公有成员

    • QMainWindow ( QWidget * parent = 0, const char * name = 0, WFlags f = WType_TopLevel )
    • ~QMainWindow ()
    • QMenuBar * menuBar () const
    • QStatusBar * statusBar () const
    • QToolTipGroup * toolTipGroup () const
    • virtual void setCentralWidget ( QWidget * w )
    • QWidget * centralWidget () const
    • virtual void setDockEnabled ( Dock dock, bool enable )
    • bool isDockEnabled ( Dock dock ) const
    • bool isDockEnabled ( QDockArea * area ) const
    • virtual void setDockEnabled ( QDockWindow * dw, Dock dock, bool enable )
    • bool isDockEnabled ( QDockWindow * tb, Dock dock ) const
    • bool isDockEnabled ( QDockWindow * dw, QDockArea * area ) const
    • virtual void addDockWindow ( QDockWindow * dockWindow, Dock edge = DockTop, bool newLine = FALSE )
    • virtual void addDockWindow ( QDockWindow * dockWindow, const QString & label, Dock edge = DockTop, bool newLine = FALSE )
    • virtual void moveDockWindow ( QDockWindow * dockWindow, Dock edge = DockTop )
    • virtual void moveDockWindow ( QDockWindow * dockWindow, Dock edge, bool nl, int index, int extraOffset = -1 )
    • virtual void removeDockWindow ( QDockWindow * dockWindow )
    • bool rightJustification () const
    • bool usesBigPixmaps () const
    • bool usesTextLabel () const
    • bool dockWindowsMovable () const
    • bool opaqueMoving () const
    • bool getLocation ( QDockWindow * dw, Dock & dock, int & index, bool & nl, int & extraOffset ) const
    • QPtrList<QDockWindow> dockWindows ( Dock dock ) const
    • QPtrList<QDockWindow> dockWindows () const
    • void lineUpDockWindows ( bool keepNewLines = FALSE )
    • bool isDockMenuEnabled () const
    • bool hasDockWindow ( QDockWindow * dw )
    • void addToolBar ( QDockWindow *, Dock = DockTop, bool newLine = FALSE )  (废弃)
    • void addToolBar ( QDockWindow *, const QString & label, Dock = DockTop, bool newLine = FALSE )  (废弃)
    • void moveToolBar ( QDockWindow *, Dock = DockTop )  (废弃)
    • void moveToolBar ( QDockWindow *, Dock, bool nl, int index, int extraOffset = -1 )  (废弃)
    • void removeToolBar ( QDockWindow * )  (废弃)
    • bool toolBarsMovable () const  (废弃)
    • QPtrList<QToolBar> toolBars ( Dock dock ) const
    • void lineUpToolBars ( bool keepNewLines = FALSE )  (废弃)
    • QDockArea * leftDock () const
    • QDockArea * rightDock () const
    • QDockArea * topDock () const
    • QDockArea * bottomDock () const
    • virtual bool isCustomizable () const
    • bool appropriate ( QDockWindow * dw ) const
    • enum DockWindows { OnlyToolBars, NoToolBars, AllDockWindows }
    • QPopupMenu * createDockWindowMenu ( DockWindows dockWindows = AllDockWindows ) const

    公有槽

    信号

    属性

    保护成员

    • virtual void childEvent ( QChildEvent * e )

    保护槽

    相关函数

    • QTextStream & operator<< ( QTextStream & ts, const QMainWindow & mainWindow )
    • QTextStream & operator>> ( QTextStream & ts, QMainWindow & mainWindow )

     

    详细描述

    QMainWindow类提供一个有菜单条、锚接窗口(例如工具条)和一个状态条的主应用程序窗口。

    主窗口通常用在提供一个大的中央窗口部件(例如文本编辑或者绘制画布)以及周围菜单、工具条和一个状态条。QMainWindow常常被继承,因为这使得封装中央部件、菜单和工具条以及窗口状态变得更容易。继承使创建当用户点击菜单项或者工具条按钮时被调用的槽成为可能。你也可以使用Qt设计器来创建主窗口。我们将简要地回顾一下有关添加菜单项和工具条按钮,然后描述QMainWindow自己的便捷。

        QMainWindow *mw = new QMainWindow;

        QTextEdit *edit = new QTextEdit( mw, "editor" );

        edit->setFocus();

        mw->setCaption( "Main Window" );

        mw->setCentralWidget( edit );

        mw->show();

        

    QMainWindow可以像上面那样显示地来被创建。中央窗口部件是通过setCentralWidget()设置地。弹出菜单可以被添加到默认工具条,窗口部件可以被添加到状态条,工具条和锚接窗口可以被添加到任何一个锚接区域。

            ApplicationWindow * mw = new ApplicationWindow();

            mw->setCaption( "Qt Example - Application" );

            mw->show();

    上面代码中的ApplicationWindow是我们自己写的QMainWindow的子类,这是一个使用QMainWindow的常用方法。(源代码取自application/main.cppapplication/application.cppaction/main.cppaction/application.cpp。)

    在继承的时候,我们在子类的构造函数中添加菜单项和工具条。如果我们已经直接创建了一个QMainWindow实例,我们可以很容易地通过传递QMainWindow实例代替作为父对象的this指针来添加菜单项和工具条。

            QPopupMenu * help = new QPopupMenu( this );

            menuBar()->insertItem( "&Help", help );

     

            help->insertItem( "&About", this, SLOT(about()), Key_F1 );

    这里我们添加了有一个菜单项的新菜单。这个菜单已经被插入QMainWindow默认提供的并且可以通过menuBar()函数访问的菜单条。当这个菜单项被点击时,这个槽被调用。

            QToolBar * fileTools = new QToolBar( this, "file operations" );

            fileTools->setLabel( "File Operations" );

            QToolButton * fileOpen

                = new QToolButton( openIcon, "Open File", QString::null,

                                   this, SLOT(choose()), fileTools, "open file" );

    这部分提取显示的是有一个工具条按钮的工具条的创建。QMainWindow为工具条提供了四个锚接区域。当一个工具条被作为QMainWindow(或者继承类)实例 的子对象被创建时,它将会被放置到一个锚接区域中(默认是Top锚接区域)。当这个工具条按钮被点击时,这个槽被调用。任何锚接窗口可以使用addDockWindow(),或者通过把QMainWindow作为父对象来创建的方法来被添加到一个锚接区域中。

            e = new QTextEdit( this, "editor" );

            e->setFocus();

            setCentralWidget( e );

            statusBar()->message( "Ready", 2000 );

    创建完菜单和工具条,我们创建一个大的中央窗口部件的实例,给它焦点并且把它设置为主窗口的中央窗口部件。在这个实例中,我们也已经通过statusBar()函数设置好了状态条,显示初始信息两秒。注意你可以添加其它的窗口部件到状态条重,例如标签,来显示更多的状态信息。详细情况请参考QStatusBar文档,特别是addWidget()函数。

    通常我们想让一个工具条按钮和一个菜单项同步。例如,如果用户点击加粗工具条按钮,我们希望加粗菜单项被选中。这种同步可以通过创建操作并且把它们添加到工具条和菜单上来自动实现。

            QAction * fileOpenAction;

            fileOpenAction = new QAction( "Open File", QPixmap( fileopen ), "&Open",

                                          CTRL+Key_O, this, "open" );

            connect( fileOpenAction, SIGNAL( activated() ) , this, SLOT( choose() ) );

    这里我们创建了一个有图标的操作,这个图标要用在这个操作所被添加到的菜单和工具条中。我们也给定这个操作一个菜单名称“&Open”和一个键盘快捷键。我们已经建立的这个连接在用户点击这个菜单项或者这个工具条按钮时将会被使用。

            QPopupMenu * file = new QPopupMenu( this );

            menuBar()->insertItem( "&File", file );

            fileOpenAction->addTo( file );

    上面这部分提取显示一个弹出菜单的创建。我们把这个菜单添加到QMainWindow的菜单条中并且添加我们的操作。

            QToolBar * fileTools = new QToolBar( this, "file operations" );

            fileTools->setLabel( "File Operations" );

            fileOpenAction->addTo( fileTools );

    这里我们创建一个作为QMainWindow的子对象的工具条并且把我们的操作添加到这个工具条中。

    现在我们来探险QMainWindow提供的功能。

    主窗口将会注意锚接区域和中央窗口部件的几何形状,但是中央窗口部件的其它所有方面都留给你了。如果你指定QMainWindow作为父对象来创建菜单条或者状态条,QMainWindow会自动检测它们,或者你可以使用提供的menuBar()statusBar()函数。如果一个窗口部件也没有,menuBar()statusBar()函数创建一个合适的窗口部件,并且更新窗口的布局来得到空间。

    QMainWindow提供了一个连接到状态条的QToolTipGrouptoolTipGroup()函数提供了对默认QToolTipGroup的访问。它不能设置一个不同的工具提示组。

    新的锚接窗口和工具条可以通过使用addDockWindow()来被添加到QMainWindow中。锚接窗口可以使用moveDockWindow()来移动并且使用removeDockWindow()来移除。QMainWindow允许默认锚接窗口(工具条)锚接在所有它的锚接区域中(上、下、左、右)。你可以使用setDockEnabled()为锚接窗口而使锚接区域生效/失效。当添加或者移动锚接窗口时,你可以指定它们的边缘(锚接区域)。当前可用的边缘有:TopLeftRightBottomMinimized (有效地一个隐藏锚接区域)和TornOff(浮动)。关于这些区域的解释请参考Qt::Dock。注意*ToolBar函数被考虑向后兼容,所有的新代码都应该使用*DockWindow函数。QToolBarQDockWindow的子类,所以所有对于锚接窗口能工作地函数对于工具条也一样可以工作。如果用户通过点击锚接窗口地窗口句柄来最小化一个锚接窗口,那么锚接窗口将会被移到Minimized锚接区域。如果用户点击关闭按钮,那么锚接窗口被隐藏并且只能再次通过使用锚接窗口菜单来再次被显示。

    一些函数会全局地改变QMainWindow的外观:

    • QDockWindow::setHorizontalStretchable()QDockWindow::setVerticalStretchable()被用于指定锚接窗口和工具条是可延伸的。
    • setUsesBigPixmaps()被用于设置工具按钮是应该用小像素映射还是大像素映射(更多信息请参考QIconSet)。
    • setUsesTextLabel()被用于设置工具按钮是否应该在显示像素映射之外还显示文本标签(更多信息请参考QToolButton)。

    用户可以把锚接窗口拖入任何生效的锚接区域中。锚接窗口也可以在一个锚接区域中被拖动,例如重新排列一些工具条的顺序。锚接窗口也可以被拖动出任何锚接区域(取消锚接或者浮动)。你可以使用setDockWindowsMovable()把锚接窗口设置为生效的(默认)和失效的。如果用户点击浮动锚接窗口的关闭按钮,然后锚接窗口将会消失。为了重新得到锚接窗口,用户必须右键点击一个锚接区域,弹出一个锚接窗口菜单,然后点击我们要恢复的锚接窗口的名字。可视的锚接窗口在菜单中它们的名字之前有一个勾。锚接窗口菜单会根据createDockWindowMenu()的需要自动被创建。因为它可能不总是适合把一个锚接窗口显示到这个菜单中,setAppropriate()函数被用来告知主窗口这个锚接窗口菜单是否应该包含一个特定的锚接窗口。双击锚接窗口句柄(通常在锚接窗口的左侧)会使这个锚接窗口取消锚接(浮动)。双击浮动锚接窗口的标题栏将会锚接这个浮动的锚接窗口。

    Minimized边缘是一个隐藏的锚接区域。如果这个锚接区域是生效的,用户可以隐藏(最小化)锚接窗口或者通过点击锚接窗口句柄显示(恢复)一个最小化的锚接窗口。如果用户在一个句柄上方悬浮鼠标光标,锚接窗口的标题会被作为工具提示显示(请参考QDockWindow::caption()QToolBar::label()),所以如果你使Minimized锚接区域生效,最好为每一个锚接窗口指定一个有意义的标题或者标签。为了能够程序化地最小化一个锚接窗口,请使用一个带有Minimized边缘的moveDockWindow()

    锚接窗口默认是被透明地移动,也就是在拖动期间,一个边框矩形会在屏幕上被绘制出来呈现锚接窗口在移动时的位置。如果你想让锚接窗口在移动时被正常显示,请使用setOpaqueMoving()

    锚接窗口的定位,也就是它的锚接区域和在锚接区域中的位置,可以通过调用getLocation()来被决定。可移动的锚接窗口可以通过lineUpDockWindows()被排列成一行来使浪费的空间最小化。锚接区域的指针可以由topDock()leftDock()rightDock()bottomDock()提供。如果isCustomizable()返回真(它默认返回假),一个自定义的菜单项会被添加入弹出的锚接窗口菜单。如果你想提供这个额外的菜单项,重新实现isCustomizable()customize(),例如,允许用户改变和主窗口以及它的工具条和锚接窗口相关的设置。

    主窗口的菜单条默认是固定的(在上面)。如果你想有一个可移动的菜单条,创建一个QMenuBar作为一个在它自己可移动的锚接窗口中可伸展的窗口部件并且限制这个锚接窗口只在TopBottom锚接区域存在:

        QToolBar *tb = new QToolBar( this );

        addDockWindow( tb, tr( "Menubar" ), Top, FALSE );

        QMenuBar *mb = new QMenuBar( tb );

        mb->setFrameStyle( QFrame::NoFrame );

        tb->setStretchableWidget( mb );

        setDockEnabled( tb, Left, FALSE );

        setDockEnabled( tb, Right, FALSE );

        

    有多个锚接窗口的应用程序可以选择为了以后(例如,在下个对话中)恢复当前的锚接窗口布局来把它们保存起来。你可以通过使用QMainWindow的流操作符来做到这点。

    为了保存所有锚接窗口的布局和位置,请这样做:

      QFile f( filename );

      if ( f.openIO_WriteOnly ) ) {

          QTextStream ts( &f );

          ts << *mainWindow;

          f.close();

      }

      

    为了恢复锚接窗口的位置和大小(通常是当这个应用程序再次开始),请这样做:

      QFile f( filename );

      if ( f.openIO_ReadOnly ) ) {

          QTextStream ts( &f );

          ts >> *mainWindow;

          f.close();

      }

      

    QSettings类可以和这些流操作符联合使用来存放这个应用程序的设置。

    QMainWindow对锚接窗口和工具条的管理很明显地是由QDockArea在后面完成的。

    对于多文档界面(MDI),使用QWorkspace作为中央窗口部件。

    把锚接窗口(例如工具条)添加到QMainWindow的锚接区域是很简单的。如果被提供的锚接区域对于你的应用程序是不够的,我们建议你创建一个QWidget的子类并且把你自己的锚接区域(请参考QDockArea)添加到这个子类中,因为QMainWindow只提供了由它提供的标准锚接区域的特定功能。

     

    也可以参考QToolBarQDockWindowQStatusBarQActionQMenuBarQPopupMenuQToolTipGroupQDialog主窗口和相关类

     

    成员类型文档

    QMainWindow::DockWindows

    右键点击锚接区域会弹出锚接窗口菜单(createDockWindowMenu()被自动调用)。当被调用时,在代码中你可以通过这个枚举变量指定哪些项应该出现在菜单中。

    • QMainWindow::OnlyToolBars - 菜单将会列出所有的工具条,但没有任何其它锚接窗口。
    • QMainWindow::NoToolBars - 菜单将会列出除工具条之外的所有的锚接窗口。
    • QMainWindow::AllDockWindows - 菜单将会列出所有的工具条和其它锚接窗口。(这是默认值。)

     

    成员函数文档

    QMainWindow::QMainWindow ( QWidget * parent = 0, const char * name = 0, WFlags f = WType_TopLevel )

    构造一个空的主窗口。parent、name和窗口部件标记f被传递给QWidget构造函数。

    默认情况下,窗口部件标记被设置为WType_TopLevel而不是只把它作为QWidget0。如果你不想让你的QMainWindow为一个顶级窗口部件,你将需要把f设置为0

    QMainWindow::~QMainWindow ()

    销毁这个对象并且释放所有已经分配的资源。

    void QMainWindow::addDockWindow ( QDockWindow * dockWindow, Dock edge = DockTop, bool newLine = FALSE ) [虚]

    把dockWindow添加到edge锚接区域。

    如果newLine为假(默认),那么dockWindow被添加到edge的末尾。对于垂直边缘,末尾在下面,对于水平边缘(包含Minimized),末尾在右面。如果newLine为真,会为锚接窗口开始新的一行,并且dockWindow作为第一个(最左面或者最上面)锚接窗口。

    如果dockWindow被另一个主窗口管理,它首先从那一个窗口中被移除。

    void QMainWindow::addDockWindow ( QDockWindow * dockWindow, const QString & label, Dock edge = DockTop, bool newLine = FALSE ) [虚]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    把标签为label的dockWindow添加到edge锚接区域。

    如果newLine为假(默认),那么dockWindow被添加到edge的末尾。对于垂直边缘,末尾在下面,对于水平边缘(包含Minimized),末尾在右面。如果newLine为真,会为锚接窗口开始新的一行,并且dockWindow作为第一个(最左面或者最上面)锚接窗口。

    如果dockWindow被另一个主窗口管理,它首先从那一个窗口中被移除。

    void QMainWindow::addToolBar ( QDockWindow *, Dock = DockTop, bool newLine = FALSE )

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    void QMainWindow::addToolBar ( QDockWindow *, const QString & label, Dock = DockTop, bool newLine = FALSE )

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    bool QMainWindow::appropriate ( QDockWindow * dw ) const

    如果适合在锚接窗口菜单中包含一个可以列出dw锚接窗口的菜单项,返回真,否则返回假。

    用户可以通过点击菜单项来改变有菜单项的锚接窗口的状态(显示或者隐藏)。

    调用setAppropriate()来指出一个特定锚接窗口是否应该显示在弹出菜单中。

    也可以参考setAppropriate()

    QDockArea * QMainWindow::bottomDock () const

    返回Bottom锚接区域的指针。

    也可以参考topDock()leftDock()rightDock()

    QWidget * QMainWindow::centralWidget () const

    返回主窗口的中央窗口部件的指针。

    中央窗口部件就是被上、下、左、右锚接区域环绕的。菜单条在上锚接区域的上面。

    也可以参考setCentralWidget()

    实例:qfd/qfd.cpp

    void QMainWindow::childEvent ( QChildEvent * e ) [虚 保护]

    监视事件,从e中接收,来保证布局被更新。

    QObject中重新实现。

    QPopupMenu * QMainWindow::createDockWindowMenu ( DockWindows dockWindows = AllDockWindows ) const

    创建一个包含所有工具条(如果dockWindows为OnlyToolBars)、所有锚接窗口(如果dockWindows为NoToolBars)或者所有工具条和锚接窗口(如果dockWindows为AllDockWindows——默认)的锚接窗口菜单。

    当需要的时候,例如当用户右键点击一个锚接区域(假如isDockMenuEnabled()返回真)时,这个函数被内部调用。如果你想自定义这个行为,你可以重新实现这个函数。

    呈现工具条和锚接窗口的菜单项是可选择的。可视的锚接窗口被选择的并且隐藏的锚接窗口是被取消选择的。用户点击一个菜单项来改变它的状态(显示或者隐藏这个锚接窗口)。

    这个列表和状态总是保持最新。

    在当前上下文(请参考setAppropriate())中是不适合的工具条和锚接窗口不会在这个菜单中被列出来。

    这个菜单也有一个把锚接窗口排成一行的菜单选项。

    如果isCustomizable()返回真,一个Customize的菜单项被添加到菜单中,如果它被点击,就会调用customize()。我们提供的isCustomizable()函数返回假并且customize()什么也不做,所以它们必须在子类中被重新实现才能有用。

    void QMainWindow::customize () [虚 槽]

    当用户点击在锚接窗口菜单中的Customize菜单项时,这个函数被调用。

    只有在isCustomizable()返回真(默认为假)时,Customize菜单项才会出现。

    这个函数是有意图的,例如,提供给用户来告诉应用程序他们要自定义主窗口、锚接窗口或者锚接区域的一个手段。

    默认实现是什么也不做,但是这可能在以后的Qt版本中发生改变。现在默认情况下,Customize菜单项不会显示在右键菜单中。如果你想让这项出现,那么请重新实现isCustomizable()来返回真。

    也可以参考isCustomizable()

    void QMainWindow::dockWindowPositionChanged ( QDockWindow * dockWindow ) [信号]

    当dockWindow已经改变位置时,这个信号被发射。当锚接窗口被移入它的锚接区域或者移到另一个锚接区域(包括Minimized和TearOff锚接区域)时,位置的变化发生。

    也可以参考getLocation()

    QPtrList<QDockWindow> QMainWindow::dockWindows ( Dock dock ) const

    返回在dock锚接区域的所有锚接窗口的列表,而不管它们的状态。

    例如,TornOff锚接区域可能包含关闭的锚接窗口,但它们会和可视锚接窗口一起被返回。

    QPtrList<QDockWindow> QMainWindow::dockWindows () const

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    返回属于主窗口的所有锚接窗口的列表,而不管它们的状态(也就是不考虑它们是否可视)。

    bool QMainWindow::dockWindowsMovable () const

    如果锚接窗口是可移动的,返回真,否则返回假。详细情况请参考“dockWindowsMovable”属性。

    bool QMainWindow::getLocation ( QDockWindow * dw, Dock & dock, int & index, bool & nl, int & extraOffset ) const

    找到锚接窗口dw的定位。

    如果锚接窗口dw在主窗口中被找到,函数返回真并且dock变量为dw所在的锚接区域并且index为dw在锚接区域中的位置索引。如果dw开始一个新行,它也设置nl为真(否则为假),并且extraOffset为dw的位移。

    如果dw在主窗口中没有被找到,那么这个函数返回真并且dock、index、nl和extraOffset的状态都是不确定的。

    如果你想保存并且恢复锚接窗口的位置,那么请使用operator>>()operator<<()

    也可以参考operator>>()operator<<()

    bool QMainWindow::hasDockWindow ( QDockWindow * dw )

    如果dw是被主窗口知道的锚接窗口,返回真,否则返回假。

    bool QMainWindow::isCustomizable () const [虚]

    如果锚接区域的锚接窗口菜单包含Customize菜单项(当它被点击时,会调用customize()),返回真。默认返回假,也就是弹出菜单不包含Customize菜单选项。如果你希望用户能在锚接窗口菜单中看到它时,你将需要重新实现这个函数并且把它设置为返回真。

    也可以参考customize()

    bool QMainWindow::isDockEnabled ( Dock dock ) const

    如果dock锚接区域是生效的,返回真,也就是它可以接收用户拖动的锚接窗口,否则返回假。

    也可以参考setDockEnabled()

    bool QMainWindow::isDockEnabled ( QDockArea * area ) const

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    如果area是生效的,返回真,也就是它可以接收用户拖动的锚接窗口,否则返回假。

    也可以参考setDockEnabled()

    bool QMainWindow::isDockEnabled ( QDockWindow * tb, Dock dock ) const

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    如果dock对于锚接窗口tb是生效的,返回真,否则返回假。

    也可以参考setDockEnabled()

    bool QMainWindow::isDockEnabled ( QDockWindow * dw, QDockArea * area ) const

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    如果area对于锚接窗口tb是生效的,返回真,否则返回假。

    也可以参考setDockEnabled()

    bool QMainWindow::isDockMenuEnabled () const

    如果锚接窗口菜单是生效的,返回真,否则返回假。

    这个菜单会列出(appropriate())锚接窗口(它们会被显示或者隐藏)并且有一个“Line Up Dock Windows”菜单项。如果isCustomizable()返回真,它也将会有一个“Customize”菜单项。

    也可以参考setDockEnabled()lineUpDockWindows()appropriate()setAppropriate()

    QDockArea * QMainWindow::leftDock () const

    返回Left锚接区域。

    也可以参考rightDock()topDock()bottomDock()

    void QMainWindow::lineUpDockWindows ( bool keepNewLines = FALSE )

    这个函数将会尽量紧凑地排列在可视的锚接区域(TopLeftRightBottom)中的锚接窗口。

    如果keepNewLines为真,所有锚接窗口保持在它们的原有行中。如果keepNewLines为假,那么新行将别移除来达到最可能紧凑的布局。

    这个方法只有在dockWindowsMovable()返回真的情况下才能够工作。

    void QMainWindow::lineUpToolBars ( bool keepNewLines = FALSE )

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    void QMainWindow::menuAboutToShow () [保护 槽]

    这个槽会从主窗口的默认铆接菜单中地aboutToShow()信号调用。默认实现是在这个槽中用所有锚接窗口和菜单条来初始化这个菜单。

    如果你想对这个菜单做小的调节,你可以在这个槽中做到这一点。另外要重新实现createDockWindowMenu()

    QMenuBar * QMainWindow::menuBar () const

    返回这个窗口的菜单条。

    如果这里一个也没有,那么menuBar()会创建一个空的菜单条。

    也可以参考statusBar()

    void QMainWindow::moveDockWindow ( QDockWindow * dockWindow, Dock edge = DockTop ) [虚]

    把dockWindow移动到edge的末尾。

    对于垂直边缘,末尾是下面,对于水平边缘(包括Minimized),末尾是右面。

    如果dockWindow被另一个主窗口管理,它首先被从那个窗口移除。

    void QMainWindow::moveDockWindow ( QDockWindow * dockWindow, Dock edge, bool nl, int index, int extraOffset = -1 ) [虚]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    把dockWindow移动到edge的index位置。

    任何在index或者更高位置的锚接窗口的位置数都被增加并且同一行的空间都被向右移(垂直区域的向下移)。

    如果nl为真,一个新的锚接窗口行会在被移动的锚接窗口所在行下面创建新行,任何和被移动的锚接窗口在一行的并且位置更高的都被移到新行中。

    extraOffset是放在这个锚接窗口和锚接区域的最左面(对于垂直锚接区域是最上面)的距离。(它通常用于恢复锚接窗口的位置为用于曾经拖到的位置。)

    如果dockWindow被另一个主窗口管理,它首先被从那个窗口移除。

    void QMainWindow::moveToolBar ( QDockWindow *, Dock = DockTop )

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    void QMainWindow::moveToolBar ( QDockWindow *, Dock, bool nl, int index, int extraOffset = -1 )

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    bool QMainWindow::opaqueMoving () const

    如果锚接窗口被不透明地移动,返回真,否则返回假。详细情况请参考“opaqueMoving”属性。

    void QMainWindow::pixmapSizeChanged ( bool ) [信号]

    只要setUsesBigPixmaps()被使用和当前设置不同地值调用时,这个信号就被调用。所有窗口部件都应该对这个变化做出回应,例如工具条按钮必须连接到这个信号。

    void QMainWindow::removeDockWindow ( QDockWindow * dockWindow ) [虚]

    假如dockWindow为非零并且被这个主窗口管理,那么从主窗口的锚接区域移除dockWindow。

    void QMainWindow::removeToolBar ( QDockWindow * )

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    QDockArea * QMainWindow::rightDock () const

    返回Right锚接区域。

    也可以参考leftDock()topDock()bottomDock()

    bool QMainWindow::rightJustification () const

    如果主窗口正确对齐它的锚接窗口,返回真,否则返回假。详细情况请参考“rightJustification”属性。

    void QMainWindow::setAppropriate ( QDockWindow * dw, bool a ) [虚 槽]

    使用这个函数来控制dw锚接窗口的标题是否应该作为一个菜单项显示在列出锚接窗口的锚接窗口菜单中。

    如果a为真,那么dw将会作为一个菜单项显示在锚接窗口菜单中。用户能够通过点击这个菜单项来改变锚接窗口的状态(显示或者隐藏),根据你的应用程序的状态,这可能是也可能不是适合的。如果a为假,dw将会被显示在弹出菜单中。

    也可以参考showDockMenu()isCustomizable()customize()

    void QMainWindow::setCentralWidget ( QWidget * w ) [虚]

    设置这个窗口的中央窗口部件为w。

    这个中央窗口部件被上、下、左、右锚接区域环绕。菜单条在上锚接区域的上面。

    也可以参考centralWidget()

    void QMainWindow::setDockEnabled ( Dock dock, bool enable ) [虚]

    如果enable为真,那么用户可以在dock区域中锚接窗口。如果enable为假,那么用户不可以在dock区域中锚接窗口。

    用户可以把锚接窗口锚接(拖动)进入任何生效锚接区域。

    void QMainWindow::setDockEnabled ( QDockWindow * dw, Dock dock, bool enable ) [虚]

    这是一个重载成员函数,提供了方便。它的行为基本上和上面的函数相同。

    如果enable为真,那么用户可以在dock区域中锚接窗口。如果enable为假,那么用户不可以在dock区域中锚接窗口。

    通常用户可以把锚接窗口锚接(拖动)进入任何生效锚接区域。使用这个函数特定的锚接区域能够对特定地锚接窗口生效(或者失效)。

    void QMainWindow::setDockMenuEnabled ( bool b ) [虚 槽]

    如果b为真,那么在一个锚接窗口或者锚接区域上右键单击将会弹出锚接窗口菜单。如果b为假,那么在一个锚接窗口或者锚接区域上右键单击将不会弹出锚接窗口菜单。

    这个菜单会列出(appropriate())锚接窗口(它们会被显示或者隐藏)并且有一个“Line Up Dock Windows”菜单项。如果isCustomizable()返回真,它也将会有一个“Customize”菜单项。

    也可以参考lineUpDockWindows()isDockMenuEnabled()

    void QMainWindow::setDockWindowsMovable ( bool ) [虚 槽]

    设置锚接窗口是否可以移动。详细情况请参考“dockWindowsMovable”属性。

    void QMainWindow::setOpaqueMoving ( bool ) [虚 槽]

    设置锚接窗口是否是被不透明地移动。详细情况请参考“opaqueMoving”属性。

    void QMainWindow::setRightJustification ( bool ) [虚 槽]

    设置主窗口是否右对齐它的锚接窗口。详细情况请参考“rightJustification”属性。

    void QMainWindow::setToolBarsMovable ( bool ) [slot]

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    void QMainWindow::setUpLayout () [虚 保护 槽]

    设置窗口的几何形状管理。当需要的时候,它会被自动调用,所以你不需要调用它。

    void QMainWindow::setUsesBigPixmaps ( bool ) [虚 槽]

    设置大像素映射是否生效。详细情况请参考“usesBigPixmaps”属性。

    void QMainWindow::setUsesTextLabel ( bool ) [虚 槽]

    设置工具条按钮的文本标签是否生效。详细情况请参考“usesTextLabel”属性。

    bool QMainWindow::showDockMenu ( const QPoint & globalPos ) [虚 保护 槽]

    在globalPos位置显示锚接窗口菜单。这个菜单来出锚接窗口,所以它们可以被显示(或者隐藏)、排列并且可能会被定制。如果这个菜单被显示,返回真,否则返回假。

    默认实现是使用得到由createDockWindowMenu()创建的锚接窗口。如果你想使用你自己特定的弹出菜单,你可以重新实现createDockWindowMenu()

    QStatusBar * QMainWindow::statusBar () const

    返回这个窗口的状态条。如果没有的话,statusBar()会创建一个空的状态条,并且如果需要也创建一个工具提示组。

    也可以参考menuBar()toolTipGroup()

    实例:qfd/qfd.cpp

    void QMainWindow::toolBarPositionChanged ( QToolBar * ) [信号]

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    QPtrList<QToolBar> QMainWindow::toolBars ( Dock dock ) const

    返回在dock锚接区域的所有工具条的列表,而不管它们的状态。

    例如,TornOff锚接区域可能包含关闭的工具条,但是它们会和可视的工具条一起被返回。

    也可以参考dockWindows()

    bool QMainWindow::toolBarsMovable () const

    这个函数是废弃的。它的提供只是为了保证旧代码能够工作。我们强烈建议在新代码中不要使用它。

    QToolTipGroup * QMainWindow::toolTipGroup () const

    返回这个窗口的工具提示组。如果没有的话,toolTipGroup()会自动创建一个空的工具提示组。

    也可以参考menuBar()statusBar()

    QDockArea * QMainWindow::topDock () const

    返回Top锚接区域。

    也可以参考bottomDock()leftDock()rightDock()

    bool QMainWindow::usesBigPixmaps () const

    如果大像素映射生效,返回真,否则返回假。详细情况请参考“usesBigPixmaps”属性。

    bool QMainWindow::usesTextLabel () const

    如果工具条按钮的文本标签生效,返回真,否则返回假。详细情况请参考“usesTextLabel”属性。

    void QMainWindow::usesTextLabelChanged ( bool ) [信号]

    只要setUsesTextLabel()使用与当前设置不同的值被调用,这个信号被调用。所有窗口部件应该对这个变化做出回应,例如工具条按钮必须连接到这个信号。

    void QMainWindow::whatsThis () [虚 槽]

    进入这是什么?问题模式并且立即返回。

    这和QWhatsThis::enterWhatsThisMode()是相同的,但是作为主窗口对象的槽而被重新实现。这个方式可以很容易地用于弹出菜单,例如:

        QPopupMenu * help = new QPopupMenu( this );

        help->insertItem( "What's &This", this , SLOT(whatsThis()), SHIFT+Key_F1);

      

    也可以参考QWhatsThis::enterWhatsThisMode()

     

    属性文档

    bool dockWindowsMovable

    This property holds whether the dock windows are movable. 这个属性保存的是锚接窗口是否可以移动。

    如果为真(默认),用户可以把可移动的锚接窗口从一个QMainWindow锚接区域移动到另一个,包括浮动(TearOff)区域(也就是,锚接窗口就其自身而言作为一个窗口自由地移动)和Minimized区域(就是锚接窗口的句柄被显示在菜单条下面的地方)。可移动锚接窗口也可以在QMainWindow的锚接区域内被移动,也就是说在一个锚接区域中重新整理它们。

    如果为假,用户就不能移动任何锚接窗口。

    默认情况下,锚接窗口是被透明地移动(也就是在拖动的时候,只显示一个边框矩形),但是这个设置可以通过setOpaqueMoving()改变。

    也可以参考setDockEnabled()opaqueMoving

    通过setDockWindowsMovable()设置属性值并且通过dockWindowsMovable()来获得属性值。

    bool opaqueMoving

    这个属性保存的是锚接窗口是否是被不透明地移动。

    如果为真,当主窗口的锚接窗口被移动时,它显示为不透明地。如果为假(默认),它们被透明地显示(也就是一个边框矩形)。

    工具条和锚接窗口的不透明移动已经被知道有一些问题。我们建议不要在这时使用这一点。我们将在稍后的发布中修改这个行为问题。

    通过setOpaqueMoving()设置属性值并且通过opaqueMoving()来获得属性值。

    bool rightJustification

    这个属性保存的是主窗口是否右对齐它的锚接窗口。

    如果失效(默认),可延伸的锚接窗口被延伸,并且不能延伸的锚接窗口被按它们需要的最小空间进行分配。因为绝大多数锚接窗口是不可延伸的,这通常会导致不对齐的右边缘结果(或者对于垂直的锚接区域是不对齐的下边缘)。如果生效,主窗口将会右对齐它的锚接窗口。

    也可以参考QDockWindow::setVerticalStretchable()QDockWindow::setHorizontalStretchable()

    通过setRightJustification()设置属性值并且通过rightJustification()来获得属性值。

    bool usesBigPixmaps

    这个属性保存的是大像素映射是否生效。

    如果为假(默认),工具按钮将会使用小像素映射,否则大像素映射将被使用。

    希望对这个设置做出反应的工具按钮和其它窗口部件要对在开始的时候读取正确的状态并且连接到主窗口部件的pixmapSizeChanged()信号连接起来负责。

    通过setUsesBigPixmaps()设置属性值并且通过usesBigPixmaps()来获得属性值。

    bool usesTextLabel

    这个属性保存的是工具条按钮的文本标签是否生效。

    如果失效(默认),工具按钮将不使用文本标签。如果生效,文本标签将被使用。

    希望对这个设置做出反应的工具按钮和其它窗口部件要对在开始的时候读取正确的状态并且连接到主窗口部件的usesTextLabelChanged()信号连接起来负责。

    也可以参考QToolButton::usesTextLabel

    通过setUsesTextLabel()设置属性值并且通过usesTextLabel()来获得属性值。

     

    相关函数

    QTextStream & operator<< ( QTextStream & ts, const QMainWindow & mainWindow )

    QMainWindow mainWindow的锚接区域中的锚接窗口,以及MinimizedTornOff锚接窗口的布局(大小和位置)都写到文本流ts中。

    例如,这可以被用于和QSettings联合使用来保存用户的布局。

    也可以参考operator>>()

    QTextStream & operator>> ( QTextStream & ts, QMainWindow & mainWindow )

    从文本流ts中读入QMainWindow mainWindow的锚接区域中的锚接窗口,以及MinimizedTornOff锚接窗口的布局(大小和位置)。恢复锚接窗口和锚接区域的大小和位置。布局信息必须是由operator<<()生成的。

    例如,这可以被用于和QSettings联合使用来恢复用户的布局。

    也可以参考operator<<()

     



    展开全文
  • Qt使用信号槽模拟全局广播

    千次阅读 2019-05-04 17:55:56
    Qt信号槽很好用,可以轻松的对代码解耦,现在我不想在类里面声明信号槽,也不想写Q_OBJECT,因此有了以下的方式模拟一个全局广播,通过一个全局的实例(单例)发送接收数据 //CGlobalBroadcast.h #pragma once ...

    Qt的信号槽很好用,可以轻松的对代码解耦,现在我不想在类里面声明信号槽,也不想写Q_OBJECT,因此有了以下的方式模拟一个全局广播,通过一个全局的实例(单例)发送接收数据

    //CGlobalBroadcast.h
    #pragma once
    
    #include <qobject.h>
    #include <qvariant.h>
    #include <qhash.h>
    
    //添加消息Id
    namespace BroadcastEvent {
    	enum Event_Void {
    		CUSTOM_EVENT_VOID = 0,
    		
    	};
    	
    	enum Event_Variant {
    		CUSTOM_EVENT_VARIANT = 0,
    		
    	};
    
    	enum Event_Variant_List {
    		CUSTOM_EVENT_VARIANT_LIST = 0,
    		
    	};
    };
    
    class CGlobalBroadcast : public QObject {
    	Q_OBJECT
    
    private:
    	CGlobalBroadcast(QObject* parent);
    
    public:
    	static void Install(QObject* parent);
    
    	//connect direct
    	template<typename F>
    	static void RegisterEvent(BroadcastEvent::Event_Void id, F f);
    
    	template<typename F>
    	static void RegisterEvent(BroadcastEvent::Event_Variant id, F f);
    
    	template<typename F>
    	static void RegisterEvent(BroadcastEvent::Event_Variant_List id, F f);
    
    	//connect auto
    	template<typename F>
    	static void RegisterEvent(BroadcastEvent::Event_Void id, const QObject* context, F f);
    
    	template<typename F>
    	static void RegisterEvent(BroadcastEvent::Event_Variant id, const QObject* context, F f);
    
    	template<typename F>
    	static void RegisterEvent(BroadcastEvent::Event_Variant_List id, const QObject* context, F f);
    
    	static void PostEvent(BroadcastEvent::Event_Void id);
    	static void PostEvent(BroadcastEvent::Event_Variant id, QVariant data);
    	static void PostEvent(BroadcastEvent::Event_Variant_List id, QVariantList data);
    
    private:
    	typedef void (CGlobalBroadcast::*func_void)();
    	typedef void (CGlobalBroadcast::*func_variant)(QVariant);
    	typedef void (CGlobalBroadcast::*func_variant_list)(QVariantList);
    
    private:
    	static CGlobalBroadcast* globalBroadcast;
    	//function map
    	QHash<BroadcastEvent::Event_Void, func_void> funcMap_void;
    	QHash<BroadcastEvent::Event_Variant, func_variant> funcMap_variant;
    	QHash<BroadcastEvent::Event_Variant_List, func_variant_list> funcMap_variant_list;
    
    //注册信号
    private:
    	inline void installFuncVoid() {
    		funcMap_void.insert(BroadcastEvent::CUSTOM_EVENT_VOID, &CGlobalBroadcast::custom_event_void);
    	}
    
    	inline void installFuncVariant() {
    		funcMap_variant.insert(BroadcastEvent::CUSTOM_EVENT_VARIANT, &CGlobalBroadcast::custom_event_variant);
    	}
    
    	inline void installFuncVariantList() {
    		funcMap_variant_list.insert(BroadcastEvent::CUSTOM_EVENT_VARIANT_LIST, &CGlobalBroadcast::custom_event_variant_list);
    	}
    
    #define F_VOID(f_n)			void f_n()
    #define F_VARIANT(f_n)		void f_n(QVariant data)
    #define F_VARIANT_LIST(f_n)	void f_n(QVariantList data)
    //定义消息信号
    signals:
    	//function void
    	F_VOID(custom_event_void);
    
    	//function variant
    	F_VARIANT(custom_event_variant);
    
    	//function variant list
    	F_VARIANT_LIST(custom_event_variant_list);
    };
    
    template<typename F>
    inline void CGlobalBroadcast::RegisterEvent(BroadcastEvent::Event_Void id, F f) {
    	connect(globalBroadcast, globalBroadcast->funcMap_void.value(id), f);
    }
    
    template<typename F>
    inline void CGlobalBroadcast::RegisterEvent(BroadcastEvent::Event_Variant id, F f) {
    	connect(globalBroadcast, globalBroadcast->funcMap_variant.value(id), f);
    }
    
    template<typename F>
    inline void CGlobalBroadcast::RegisterEvent(BroadcastEvent::Event_Variant_List id, F f) {
    	connect(globalBroadcast, globalBroadcast->funcMap_variant_list.value(id), f);
    }
    
    template<typename F>
    inline void CGlobalBroadcast::RegisterEvent(BroadcastEvent::Event_Void id, const QObject * context, F f)
    {
    	connect(globalBroadcast, globalBroadcast->funcMap_void.value(id), context, f);
    }
    
    template<typename F>
    inline void CGlobalBroadcast::RegisterEvent(BroadcastEvent::Event_Variant id, const QObject * context, F f)
    {
    	connect(globalBroadcast, globalBroadcast->funcMap_variant.value(id), context, f);
    }
    
    template<typename F>
    inline void CGlobalBroadcast::RegisterEvent(BroadcastEvent::Event_Variant_List id, const QObject * context, F f)
    {
    	connect(globalBroadcast, globalBroadcast->funcMap_variant_list.value(id), context, f);
    }
    
    //CGlobalBroadcast.cpp
    #include "CGlobalBroadcast.h"
    
    CGlobalBroadcast* CGlobalBroadcast::globalBroadcast = nullptr;
    
    CGlobalBroadcast::CGlobalBroadcast(QObject* parent) 
    	: QObject(parent) 
    {
    	installFuncVoid();
    	installFuncVariant();
    	installFuncVariantList();
    }
    
    void CGlobalBroadcast::Install(QObject * parent) {
    	if (globalBroadcast == nullptr) {
    		globalBroadcast = new CGlobalBroadcast(parent);
    	}
    }
    
    void CGlobalBroadcast::PostEvent(BroadcastEvent::Event_Void id) {
    	emit (globalBroadcast->*(globalBroadcast->funcMap_void.value(id)))();
    }
    
    void CGlobalBroadcast::PostEvent(BroadcastEvent::Event_Variant id, QVariant data) {
    	emit (globalBroadcast->*(globalBroadcast->funcMap_variant.value(id)))(data);
    }
    
    void CGlobalBroadcast::PostEvent(BroadcastEvent::Event_Variant_List id, QVariantList data) {
    	emit (globalBroadcast->*(globalBroadcast->funcMap_variant_list.value(id)))(data);
    }
    
    

    注册全局广播实例

    CGlobalBroadcast::Install(parent);
    

    在A类中发送广播

    struct StructA {
    	int a;
    	QString b;
    };
    Q_DECLARE_METATYPE(StructA);
    void A::sendEvent(){
    	//没有参数的通知
    	CGlobalBroadcast::PostEvent(BroadcastEvent::CUSTOM_EVENT_VOID);
    	//发送1个QString
    	CGlobalBroadcast::PostEvent(BroadcastEvent::CUSTOM_EVENT_VARIANT, "hello B!");
    	//发送1个StructA
    	StructA structA;
    	CGlobalBroadcast::PostEvent(BroadcastEvent::CUSTOM_EVENT_VARIANT, QVariant::fromValue(structA));
    	//发送一堆数据
    	QVariantList data;
    	data << 1;
    	data << "abc";
    	CGlobalBroadcast::PostEvent(BroadcastEvent::CUSTOM_EVENT_VARIANT_LIST, data);
    }
    

    在B类中接收广播

    void B::receiverEvent(){
    	//接收没有参数的通知
    	CGlobalBroadcast::RegisterEvent(BroadcastEvent::CUSTOM_EVENT_VOID, [&]() {
    		//do something...
    	});
    	//接收A发送的QString
    	CGlobalBroadcast::RegisterEvent(BroadcastEvent::CUSTOM_EVENT_VARIANT, [&](QVariant data) {
    		auto str = data.toString();
    		//do something...
    	});
    	//接收A发送的结构体
    	CGlobalBroadcast::RegisterEvent(BroadcastEvent::CUSTOM_EVENT_VARIANT, [&](QVariant data) {
    		auto structA = data.value<StructA>();
    		//do something...
    	});
    	//接收A发送的一堆数据
    	CGlobalBroadcast::RegisterEvent(BroadcastEvent::CUSTOM_EVENT_VARIANT_LIST, [&](QVariantList data) {
    		auto dataInt = data.at(0).toInt();
    		auto dataStr = data.at(1).toString();
    		//do something...
    	});
    } 
    

    用起来很爽,发送和接收都不用connect了,甚至不用继承QObject,A类和B类相隔十万八千里,只要都包含CGlobalBroadcast.h就可以传递数据,不同的消息可以通过消息ID区分,而且B看心情接收不接收消息,B和另一个C也可以接收相同的消息,但是…由于添加消息写在头文件里,每添加1个消息ID后,所有用到CGlobalBroadcast的cpp得全部重新编译一次。

    改进

    主要解决上述1个问题:由于消息的传递是通过1个实例进行的,在同一个线程下的接收函数发送频率太高会发生阻塞。由此将CGlobalBroadcast做成模板基类,可以实现多个消息发送类,让定义消息分开

    定义模板基类CGlobalBroadcastImpl.h

    #pragma once
    
    #include <qobject.h>
    #include <qvariant.h>
    #include <qhash.h> 
    
    template<typename T, typename B>
    class CGlobalBroadcastImpl : public QObject {
    public:
    	CGlobalBroadcastImpl<T, B>(QObject* parent) : QObject(parent) {}
    
    public:
    	static void Install(QObject* parent) {
    		if (globalBroadcast == nullptr) {
    			globalBroadcast = new T(parent);
    		}
    	}
    
    	template<typename F>
    	static void RegisterEvent(typename B::Event_Void id, F f);
    
    	template<typename F>
    	static void RegisterEvent(typename B::Event_Variant id, F f);
    
    	template<typename F>
    	static void RegisterEvent(typename B::Event_Variant_List id, F f);
    
    	//connect auto
    	template<typename F>
    	static void RegisterEvent(typename B::Event_Void id, const QObject* context, F f);
    
    	template<typename F>
    	static void RegisterEvent(typename B::Event_Variant id, const QObject* context, F f);
    
    	template<typename F>
    	static void RegisterEvent(typename B::Event_Variant_List id, const QObject* context, F f);
    
    	static void PostEvent(typename B::Event_Void id) {
    		emit (globalBroadcast->*(globalBroadcast->funcMap_void.value(id)))();
    	}
    
    	static void PostEvent(typename B::Event_Variant id, QVariant data) {
    		emit (globalBroadcast->*(globalBroadcast->funcMap_variant.value(id)))(data);
    	}
    
    	static void PostEvent(typename B::Event_Variant_List id, QVariantList data) {
    		emit (globalBroadcast->*(globalBroadcast->funcMap_variant_list.value(id)))(data);
    	}
    
    private:
    	typedef void (T::*func_void)();
    	typedef void (T::*func_variant)(QVariant);
    	typedef void (T::*func_variant_list)(QVariantList);
    
    protected:
    	static T* globalBroadcast;
    	//function map
    	QHash<typename B::Event_Void, func_void> funcMap_void;
    	QHash<typename B::Event_Variant, func_variant> funcMap_variant;
    	QHash<typename B::Event_Variant_List, func_variant_list> funcMap_variant_list;
    
    //注册信号
    private:
    	virtual void installFuncVoid() = 0;
    	virtual void installFuncVariant() = 0;
    	virtual void installFuncVariantList() = 0;
    
    #define F_VOID(f_n)			void f_n()
    #define F_VARIANT(f_n)		void f_n(QVariant data)
    #define F_VARIANT_LIST(f_n)	void f_n(QVariantList data)
    };
    
    template<typename T, typename B>
    template<typename F>
    inline void CGlobalBroadcastImpl<T, B>::RegisterEvent(typename B::Event_Void id, F f)
    {
    	connect(globalBroadcast, globalBroadcast->funcMap_void.value(id), f);
    }
    
    template<typename T, typename B>
    template<typename F>
    inline void CGlobalBroadcastImpl<T, B>::RegisterEvent(typename B::Event_Variant id, F f)
    {
    	connect(globalBroadcast, globalBroadcast->funcMap_variant.value(id), f);
    }
    
    template<typename T, typename B>
    template<typename F>
    inline void CGlobalBroadcastImpl<T, B>::RegisterEvent(typename B::Event_Variant_List id, F f) {
    	connect(globalBroadcast, globalBroadcast->funcMap_variant_list.value(id), f);
    }
    
    template<typename T, typename B>
    template<typename F>
    inline void CGlobalBroadcastImpl<T, B>::RegisterEvent(typename B::Event_Void id, const QObject * context, F f)
    {
    	connect(globalBroadcast, globalBroadcast->funcMap_void.value(id), context, f);
    }
    
    template<typename T, typename B>
    template<typename F>
    inline void CGlobalBroadcastImpl<T, B>::RegisterEvent(typename B::Event_Variant id, const QObject * context, F f)
    {
    	connect(globalBroadcast, globalBroadcast->funcMap_variant.value(id), context, f);
    }
    
    template<typename T, typename B>
    template<typename F>
    inline void CGlobalBroadcastImpl<T, B>::RegisterEvent(typename B::Event_Variant_List id, const QObject * context, F f)
    {
    	connect(globalBroadcast, globalBroadcast->funcMap_variant_list.value(id), context, f);
    }
    
    
    

    重新定义CGlobalBroadcast,使用方法跟原来一样

    //CGlobalBroadcast.h
    #pragma once
    
    #include "CGlobalBroadcastImpl.h"
    
    //添加消息Id
    struct BroadcastEvent {
    	enum Event_Void {
    		CUSTOM_EVENT_VOID = 0,
    	};
    
    	enum Event_Variant {
    		CUSTOM_EVENT_VARIANT = 0,
    	};
    
    	enum Event_Variant_List {
    		CUSTOM_EVENT_VARIANT_LIST = 0,
    	};
    };
    
    class CGlobalBroadcast : public CGlobalBroadcastImpl<CGlobalBroadcast, BroadcastEvent> {
    	Q_OBJECT
    
    public:
    	CGlobalBroadcast(QObject* parent) : CGlobalBroadcastImpl(parent) {
    		installFuncVoid();
    		installFuncVariant();
    		installFuncVariantList();
    	}
    	
    private:
    	void installFuncVoid() override;
    	void installFuncVariant() override;
    	void installFuncVariantList() override;
    
    	//定义消息信号
    signals:
    	//function void
    	F_VOID(custom_event_void);
    
    	//function variant
    	F_VARIANT(custom_event_variant);
    
    	//function variant list
    	F_VARIANT_LIST(custom_event_variant_list);
    };
    
    //CGlobalBroadcast.cpp
    #include "CGlobalBroadcast.h"
    
    CGlobalBroadcast* CGlobalBroadcast::globalBroadcast = nullptr;
    
    void CGlobalBroadcast::installFuncVoid() {
    	funcMap_void.insert(BroadcastEvent::CUSTOM_EVENT_VOID, &CGlobalBroadcast::custom_event_void);
    }
    
    void CGlobalBroadcast::installFuncVariant() {
    	funcMap_variant.insert(BroadcastEvent::CUSTOM_EVENT_VARIANT, &CGlobalBroadcast::custom_event_variant);
    }
    
    void CGlobalBroadcast::installFuncVariantList() {
    	funcMap_variant_list.insert(BroadcastEvent::CUSTOM_EVENT_VARIANT_LIST, &CGlobalBroadcast::custom_event_variant_list);
    }
    
    

    demo工程下载

    展开全文
  • Qt信号槽机制详解

    2020-12-11 15:01:16
      毫无疑问,Qt信号槽机制是Qt框架的核心机制之一,从本质上来讲,其实际是观察者模式。当某个事件发生后,继承于QObject的某个对象就会发出一个信号,如果有对象对此信号感兴趣,就可以连接(connect)过来,...


    slot and signal

    const char *qFlagLocation(const char *method)
    {
        QThreadData *currentThreadData = QThreadData::current(false);
        if (currentThreadData != 0)
            currentThreadData->flaggedSignatures.store(method);
        return method;
    }
    
    void store(const char* method)
    { locations[idx++ % Count] = method; }
    
    const char* locations[Count];
    
    #define QT_STRINGIFY2(x) #x
    #define QT_STRINGIFY(x) QT_STRINGIFY2(x)
    # define QLOCATION "\0" __FILE__ ":" QT_STRINGIFY(__LINE__)
    const char *qFlagLocation(const char *method);
    #define SLOT(a) qFlagLocation("1" #a QLOCATION)
    

      结论:

    1. SIGNAL与SLOT宏会利用预编译器将一些参数转化成字符串,并且在前面添加上编码。
    2. qFlagLocation 用于定位代码对应的行信息,会将对应代码的地址信息注册到一个有两个入口的表里。
    3. 这些信息会写到预编译文件中,类似如下形式:
    connect(this, qFlagLocation("2""ageChanged(int)" "\0" "Object.h" ":" "54"), this, qFlagLocation("1""onAgeChanged(int)" "\0" "Object.h" ":" "54"));
    connect(this, qFlagLocation("2""scoreChanged(int)" "\0" "Object.h" ":" "55"), this, qFlagLocation("1""onScoreChanged(int)" "\0" "Object.h" ":" "55"));
    

    moc编译器

      为了方便测试,我们实现一个简单的自定义类。

    /******************************  MyClass.h  ******************************/
    #ifndef MYCLASS_H
    #define MYCLASS_H
    
    #include <QObject>
    
    class MyClass : public QObject
    {
      Q_OBJECT
    public:
      explicit MyClass(QObject *parent = nullptr);
    
    signals:
      void scoreChanded();
      void ageChanged();
    
    public slots:
      void onScoreChanded();
      void onAgeChanged();
    
    private:
      int score;
      int age;
    
    };
    
    #endif // MYCLASS_H
    
    /******************************  MyClass.cpp  ******************************/
    #include "MyClass.h"
    
    MyClass::MyClass(QObject *parent) : QObject(parent)
    {
      connect(this,SIGNAL(scoreChanded()),this,SLOT(onScoreChanded()));
      connect(this,SIGNAL(ageChanged()),this,SLOT(onAgeChanged()));
    }
    
    void MyClass::onScoreChanded()
    {
    
    }
    
    void MyClass::onAgeChanged()
    {
    
    }
    

      如果一个自定义类要使用信号槽,那么除了继承QObject之外,还需要在类中声明Q_OBJECT宏,Q_OBJECT的定义如下:

    #define Q_OBJECT \
    public: \
        QT_WARNING_PUSH \
        Q_OBJECT_NO_OVERRIDE_WARNING \
        static const QMetaObject staticMetaObject; \
        virtual const QMetaObject *metaObject() const; \
        virtual void *qt_metacast(const char *); \
        virtual int qt_metacall(QMetaObject::Call, int, void **); \
        QT_TR_FUNCTIONS \
    private: \
        Q_OBJECT_NO_ATTRIBUTES_WARNING \
        Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); \
        QT_WARNING_POP \
        struct QPrivateSignal {}; \
        QT_ANNOTATE_CLASS(qt_qobject, "")
    

      在该宏扩展中,我们可以看到声明的静态成员staticMetaObject,以及一些函数,先不管这些成员及函数具体有什么用,这些成员没有被初始化,函数也没有定义,这是不合理的。那么它们到底是在哪里被初始化以及定义的呢?
      这就要涉及到moc编译器,moc编译器会为我们生成一个moc_xxx.cpp文件。就上面这个类而言,其生成的moc_xxx.cpp中内容如下:

    QT_INIT_METAOBJECT const QMetaObject MyClass::staticMetaObject = {
        { &QObject::staticMetaObject, qt_meta_stringdata_MyClass.data,
          qt_meta_data_MyClass,  qt_static_metacall, nullptr, nullptr}
    };
    
    const QMetaObject *MyClass::metaObject() const
    {
        return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
    }
    
    void *MyClass::qt_metacast(const char *_clname)
    {
        if (!_clname) return nullptr;
        if (!strcmp(_clname, qt_meta_stringdata_MyClass.stringdata0))
            return static_cast<void*>(this);
        return QObject::qt_metacast(_clname);
    }
    
    int MyClass::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
    {
        _id = QObject::qt_metacall(_c, _id, _a);
        if (_id < 0)
            return _id;
        if (_c == QMetaObject::InvokeMetaMethod) {
            if (_id < 4)
                qt_static_metacall(this, _c, _id, _a);
            _id -= 4;
        } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
            if (_id < 4)
                *reinterpret_cast<int*>(_a[0]) = -1;
            _id -= 4;
        }
        return _id;
    }
    
    void MyClass::scoreChanded()
    {
        QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
    }
    
    // SIGNAL 1
    void MyClass::ageChanged()
    {
        QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
    }
    
    

      在上述代码中,我们可以看到对staticMetaObject成员的填充,那么填充的到底是些什么东西呢?这就需要看看QMetaObject的定义,源码如下:

    struct Q_CORE_EXPORT QMetaObject
    {
        ...
        struct { // private data
            const QMetaObject *superdata;
            const QByteArrayData *stringdata;
            const uint *data;
            typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **);
            StaticMetacallFunction static_metacall;
            const QMetaObject * const *relatedMetaObjects;
            void *extradata; //reserved for future use
        } d;
        ...
    }
    

      其中,

    • const QMetaObject superdata; //元数据代表的类的基类的元数据,被填充为基类的元数据指针&QObject::staticMetaObject
    • const char stringdata; //元数据的签名标记,被填充为qt_meta_stringdata_MyClass.data
    • const uint *data; //元数据的索引数组的指针,被填充为qt_meta_data_MyClass
    • StaticMetacallFunction static_metacall; //扩展元数据表的指针,内部被填充为函数指针qt_static_metacall。
    • StaticMetacallFunction static_metacall;//被填充为qt_static_metacall
        relatedMetaObjects和extradata则被指向nullptr。

    元数据表

      元数据表被填充到了QMetaObject中的data指针,其在moc_xxx.cpp中生成的定义如下:

    static const uint qt_meta_data_MyClass[] = {
    
     // content:
           7,       // revision
           0,       // classname
           0,    0, // classinfo
           4,   14, // methods
           0,    0, // properties
           0,    0, // enums/sets
           0,    0, // constructors
           0,       // flags
           2,       // signalCount
    
     // signals: name, argc, parameters, tag, flags
           1,    0,   34,    2, 0x06 /* Public */,
           3,    0,   35,    2, 0x06 /* Public */,
    
     // slots: name, argc, parameters, tag, flags
           4,    0,   36,    2, 0x0a /* Public */,
           5,    0,   37,    2, 0x0a /* Public */,
    
     // signals: parameters
        QMetaType::Void,
        QMetaType::Void,
    
     // slots: parameters
        QMetaType::Void,
        QMetaType::Void,
    
           0        // eod
    };
    

      那么这个数组中的数字代表什么意思呢?事实上,这些数字要和qt_meta_stringdata_MyClass配合起来看,它们代表了相应数据在qt_meta_stringdata_MyClass中索引位置。

    typedef QIntegerForSizeof<void*>::Signed qptrdiff;
    
    #define QT_MOC_LITERAL(idx, ofs, len) \
        Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
        qptrdiff(offsetof(qt_meta_stringdata_MyClass_t, stringdata0) + ofs \
            - idx * sizeof(QByteArrayData)) \
        )
    
    struct qt_meta_stringdata_MyClass_t {
        QByteArrayData data[6];
        char stringdata0[61];
    };
    
    static const qt_meta_stringdata_MyClass_t qt_meta_stringdata_MyClass = {
        {
    QT_MOC_LITERAL(0, 0, 7), // "MyClass"
    QT_MOC_LITERAL(1, 8, 12), // "scoreChanded"
    QT_MOC_LITERAL(2, 21, 0), // ""
    QT_MOC_LITERAL(3, 22, 10), // "ageChanged"
    QT_MOC_LITERAL(4, 33, 14), // "onScoreChanded"
    QT_MOC_LITERAL(5, 48, 12) // "onAgeChanged"
    
        },
        "MyClass\0scoreChanded\0\0ageChanged\0"
        "onScoreChanded\0onAgeChanged"
    };
    

      这里就不再详细介绍其是如何匹配的了,只要我们明白,staticMetaObject中成员指针中存储了元数据表,我们以此可以完成对元数据表中各种信息的获取。

    信号的实现

      除了上述内容外,moc_xxx.cpp中还提供了信号的定义,需要理解的是,信号本质上是一个函数。

    // SIGNAL 0
    void MyClass::scoreChanded()
    {
        QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
    }
    
    // SIGNAL 1
    void MyClass::ageChanged()
    {
        QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
    }
    

      activate的在源码中定义如下:

    void QMetaObject::activate(QObject *sender, const QMetaObject *m, int local_signal_index,
                               void **argv)
    {
        activate(sender, QMetaObjectPrivate::signalOffset(m), local_signal_index, argv);
    }
    

      其中,

    • sender也就是信号发送者。
    • m是宏扩展中的静态成员。
    • local_signal_index是信号索引。
    • argv则是信号参数。

    槽函数的调用

    void MyClass::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
    {
        if (_c == QMetaObject::InvokeMetaMethod) {
            MyClass *_t = static_cast<MyClass *>(_o);
            Q_UNUSED(_t)
            switch (_id) {
            case 0: _t->scoreChanded(); break;
            case 1: _t->ageChanged(); break;
            case 2: _t->onScoreChanded(); break;
            case 3: _t->onAgeChanged(); break;
            default: ;
            }
        } else if (_c == QMetaObject::IndexOfMethod) {
            int *result = reinterpret_cast<int *>(_a[0]);
            {
                typedef void (MyClass::*_t)();
                if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyClass::scoreChanded)) {
                    *result = 0;
                    return;
                }
            }
            {
                typedef void (MyClass::*_t)();
                if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyClass::ageChanged)) {
                    *result = 1;
                    return;
                }
            }
        }
        Q_UNUSED(_a);
    }
    

      上述代码可以发现,每一个信号、每一个槽函数都被编号,然后在qt_static_metacall函数中根据索引被调用。
      在每一个QMetaObject对象中,槽、信号以及其它的对象可调用函数都会分配一个从0开始的索引。索引是有顺序的,信号在第