Qt基类

QWidget类参考

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

#include <qwidget.h>

继承QObject和QPaintDevice。

被QButton、QFrame、QDialog、QComboBox、QDataBrowser、QDataView、QDateTimeEdit、QDesktopWidget、QDial、QDockArea、QGLWidget、QHeader、QMainWindow、QNPWidget、QScrollBar、QSizeGrip、QSlider、QSpinBox、QStatusBar、QTabBar、QTabWidget、QWorkspace和QXtWidget继承。

所有成员函数的列表。

公有成员

• QWidget ( QWidget * parent = 0, const char * name = 0, WFlags f = 0 )
• ~QWidget ()
• WId winId () const
• QStyle & style () const
• void setStyle ( QStyle * style )
• QStyle * setStyle ( const QString & style )
• bool isTopLevel () const
• bool isDialog () const
• bool isPopup () const
• bool isDesktop () const
• bool isModal () const
• bool isEnabled () const
• bool isEnabledTo ( QWidget * ancestor ) const
• bool isEnabledToTLW () const  (obsolete)
• QRect frameGeometry () const
• const QRect & geometry () const
• int x () const
• int y () const
• QPoint pos () const
• QSize frameSize () const
• QSize size () const
• int width () const
• int height () const
• QRect rect () const
• QRect childrenRect () const
• QRegion childrenRegion () const
• QSize minimumSize () const
• QSize maximumSize () const
• int minimumWidth () const
• int minimumHeight () const
• int maximumWidth () const
• int maximumHeight () const
• void setMinimumSize ( const QSize & )
• virtual void setMinimumSize ( int minw, int minh )
• void setMaximumSize ( const QSize & )
• virtual void setMaximumSize ( int maxw, int maxh )
• void setMinimumWidth ( int minw )
• void setMinimumHeight ( int minh )
• void setMaximumWidth ( int maxw )
• void setMaximumHeight ( int maxh )
• QSize sizeIncrement () const
• void setSizeIncrement ( const QSize & )
• virtual void setSizeIncrement ( int w, int h )
• QSize baseSize () const
• void setBaseSize ( const QSize & )
• void setBaseSize ( int basew, int baseh )
• void setFixedSize ( const QSize & s )
• void setFixedSize ( int w, int h )
• void setFixedWidth ( int w )
• void setFixedHeight ( int h )
• QPoint mapToGlobal ( const QPoint & pos ) const
• QPoint mapFromGlobal ( const QPoint & pos ) const
• QPoint mapToParent ( const QPoint & pos ) const
• QPoint mapFromParent ( const QPoint & pos ) const
• QPoint mapTo ( QWidget * parent, const QPoint & pos ) const
• QPoint mapFrom ( QWidget * parent, const QPoint & pos ) const
• QWidget * topLevelWidget () const
• BackgroundMode backgroundMode () const
• virtual void setBackgroundMode ( BackgroundMode )
• void setBackgroundMode ( BackgroundMode m, BackgroundMode visual )
• const QColor & foregroundColor () const
• const QColor & eraseColor () const
• virtual void setEraseColor ( const QColor & color )
• const QPixmap * erasePixmap () const
• virtual void setErasePixmap ( const QPixmap & pixmap )
• const QColorGroup & colorGroup () const
• const QPalette & palette () const
• bool ownPalette () const
• virtual void setPalette ( const QPalette & )
• void unsetPalette ()
• const QColor & paletteForegroundColor () const
• void setPaletteForegroundColor ( const QColor & )
• const QColor & paletteBackgroundColor () const
• virtual void setPaletteBackgroundColor ( const QColor & )
• const QPixmap * paletteBackgroundPixmap () const
• virtual void setPaletteBackgroundPixmap ( const QPixmap & )
• const QBrush & backgroundBrush () const
• QFont font () const
• bool ownFont () const
• virtual void setFont ( const QFont & )
• void unsetFont ()
• QFontMetrics fontMetrics () const
• QFontInfo fontInfo () const
• const QCursor & cursor () const
• bool ownCursor () const
• virtual void setCursor ( const QCursor & )
• virtual void unsetCursor ()
• QString caption () const
• const QPixmap * icon () const
• QString iconText () const
• bool hasMouseTracking () const
• bool hasMouse () const
• virtual void setMask ( const QBitmap & bitmap )
• virtual void setMask ( const QRegion & region )
• void clearMask ()
• const QColor & backgroundColor () const  (obsolete)
• virtual void setBackgroundColor ( const QColor & c )  (obsolete)
• const QPixmap * backgroundPixmap () const  (obsolete)
• virtual void setBackgroundPixmap ( const QPixmap & pm )  (obsolete)
• enum FocusPolicy { NoFocus = 0, TabFocus = 0x1, ClickFocus = 0x2, StrongFocus = 0x3, WheelFocus = 0x7 }
• bool isActiveWindow () const
• virtual void setActiveWindow ()
• bool isFocusEnabled () const
• FocusPolicy focusPolicy () const
• virtual void setFocusPolicy ( FocusPolicy )
• bool hasFocus () const
• virtual void setFocusProxy ( QWidget * w )
• QWidget * focusProxy () const
• void grabMouse ()
• void grabMouse ( const QCursor & cursor )
• void releaseMouse ()
• void grabKeyboard ()
• void releaseKeyboard ()
• bool isUpdatesEnabled () const
• virtual bool close ( bool alsoDelete )
• bool isVisible () const
• bool isVisibleTo ( QWidget * ancestor ) const
• bool isVisibleToTLW () const  (obsolete)
• QRect visibleRect () const
• bool isHidden () const
• bool isMinimized () const
• bool isMaximized () const
• virtual QSize sizeHint () const
• virtual QSize minimumSizeHint () const
• virtual QSizePolicy sizePolicy () const
• virtual void setSizePolicy ( QSizePolicy )
• virtual int heightForWidth ( int w ) const
• virtual void adjustSize ()
• QLayout * layout () const
• void updateGeometry ()
• virtual void reparent ( QWidget * parent, WFlags f, const QPoint & p, bool showIt = FALSE )
• void reparent ( QWidget * parent, const QPoint & p, bool showIt = FALSE )
• void recreate ( QWidget * parent, WFlags f, const QPoint & p, bool showIt = FALSE )  (obsolete)
• void erase ()
• void erase ( int x, int y, int w, int h )
• void erase ( const QRect & r )
• void erase ( const QRegion & reg )
• void scroll ( int dx, int dy )
• void scroll ( int dx, int dy, const QRect & r )
• void drawText ( int x, int y, const QString & str )
• void drawText ( const QPoint & pos, const QString & str )
• QWidget * focusWidget () const
• QRect microFocusHint () const
• bool acceptDrops () const
• virtual void setAcceptDrops ( bool on )
• virtual void setAutoMask ( bool )
• bool autoMask () const
• enum BackgroundOrigin { WidgetOrigin, ParentOrigin, WindowOrigin }
• virtual void setBackgroundOrigin ( BackgroundOrigin )
• BackgroundOrigin backgroundOrigin () const
• virtual bool customWhatsThis () const
• QWidget * parentWidget ( bool sameWindow = FALSE ) const
• WFlags testWFlags ( WFlags f ) const
• QWidget * childAt ( int x, int y, bool includeThis = FALSE ) const
• QWidget * childAt ( const QPoint & p, bool includeThis = FALSE ) const
• void setPalette ( const QPalette & p, bool )  (obsolete)
• void setFont ( const QFont & f, bool )  (obsolete)

公有槽

• virtual void setEnabled ( bool )
• void setDisabled ( bool disable )
• virtual void setCaption ( const QString & )
• virtual void setIcon ( const QPixmap & )
• virtual void setIconText ( const QString & )
• virtual void setMouseTracking ( bool enable )
• virtual void setFocus ()
• void clearFocus ()
• virtual void setUpdatesEnabled ( bool enable )
• void update ()
• void update ( int x, int y, int w, int h )
• void update ( const QRect & r )
• void repaint ()
• void repaint ( bool erase )
• void repaint ( int x, int y, int w, int h, bool erase = TRUE )
• void repaint ( const QRect & r, bool erase = TRUE )
• void repaint ( const QRegion & reg, bool erase = TRUE )
• virtual void show ()
• virtual void hide ()
• void iconify ()  (obsolete)
• virtual void showMinimized ()
• virtual void showMaximized ()
• void showFullScreen ()
• virtual void showNormal ()
• virtual void polish ()
• void constPolish () const
• bool close ()
• void raise ()
• void lower ()
• void stackUnder ( QWidget * w )
• virtual void move ( int x, int y )
• void move ( const QPoint & )
• virtual void resize ( int w, int h )
• void resize ( const QSize & )
• virtual void setGeometry ( int x, int y, int w, int h )
• virtual void setGeometry ( const QRect & )

静态公有成员

• void setTabOrder ( QWidget * first, QWidget * second )
• QWidget * mouseGrabber ()
• QWidget * keyboardGrabber ()
• QWidget * find ( WId id )

属性

• 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坐标 （只读）

保护成员

• virtual bool event ( QEvent * e )
• virtual void mousePressEvent ( QMouseEvent * e )
• virtual void mouseReleaseEvent ( QMouseEvent * e )
• virtual void mouseDoubleClickEvent ( QMouseEvent * e )
• virtual void mouseMoveEvent ( QMouseEvent * e )
• virtual void wheelEvent ( QWheelEvent * e )
• virtual void keyPressEvent ( QKeyEvent * e )
• virtual void keyReleaseEvent ( QKeyEvent * e )
• virtual void focusInEvent ( QFocusEvent * )
• virtual void focusOutEvent ( QFocusEvent * )
• virtual void enterEvent ( QEvent * )
• virtual void leaveEvent ( QEvent * )
• virtual void paintEvent ( QPaintEvent * )
• virtual void moveEvent ( QMoveEvent * )
• virtual void resizeEvent ( QResizeEvent * )
• virtual void closeEvent ( QCloseEvent * e )
• virtual void contextMenuEvent ( QContextMenuEvent * e )
• virtual void imStartEvent ( QIMEvent * e )
• virtual void imComposeEvent ( QIMEvent * e )
• virtual void imEndEvent ( QIMEvent * e )
• virtual void tabletEvent ( QTabletEvent * e )
• virtual void dragEnterEvent ( QDragEnterEvent * )
• virtual void dragMoveEvent ( QDragMoveEvent * )
• virtual void dragLeaveEvent ( QDragLeaveEvent * )
• virtual void dropEvent ( QDropEvent * )
• virtual void showEvent ( QShowEvent * )
• virtual void hideEvent ( QHideEvent * )
• virtual bool macEvent ( MSG * )
• virtual bool winEvent ( MSG * )
• virtual bool x11Event ( XEvent * )
• virtual bool qwsEvent ( QWSEvent * )
• virtual void updateMask ()
• virtual void styleChange ( QStyle & oldStyle )
• virtual void enabledChange ( bool oldEnabled )
• virtual void paletteChange ( const QPalette & oldPalette )
• virtual void fontChange ( const QFont & oldFont )
• virtual void windowActivationChange ( bool oldActive )
• virtual int metric ( int m ) const
• void resetInputContext ()
• virtual void create ( WId window = 0, bool initializeWindow = TRUE, bool destroyOldWindow = TRUE )
• virtual void destroy ( bool destroyWindow = TRUE, bool destroySubWindows = TRUE )
• WFlags getWFlags () const
• virtual void setWFlags ( WFlags f )
• void clearWFlags ( WFlags f )
• virtual bool focusNextPrevChild ( bool next )
• QFocusData * focusData ()
• virtual void setKeyCompression ( bool compress )
• virtual void setMicroFocusHint ( int x, int y, int width, int height, bool text = TRUE, QFont * f = 0 )

 

详细描述

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

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

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

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

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

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

函数分组：

上下文

函数

窗口函数

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

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

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

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

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

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

也可以参考QEvent、QPainter、QGridLayout、QBoxLayout和抽象窗口部件类。

 

成员类型文档

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进行或运算。

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

注意Qt的X11版本也许不能在所有的系统上传递风格标记得所有组合。这是因为在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）就是用它，否则设置大小为子对象所占用的矩形（所有子窗口部件几何形状的合集）。

也可以参考sizeHint和childrenRect。

实例：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.cpp和themes/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()。

也可以参考focus、setFocus()、focusInEvent()、focusOutEvent()、focusPolicy和QApplication::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.cpp和popup/popup.cpp。

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

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

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

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

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

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

也可以参考closeEvent()、QCloseEvent、hide()、QApplication::quit()、QApplication::setMainWidget()和QApplication::lastWindowClosed()。

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

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

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

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

实例：action/application.cpp、application/application.cpp、i18n/mywidget.cpp、popup/popup.cpp和qwerty/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 * ) [虚 保护]

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

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

也可以参考QTextDrag、QImageDrag和QDragEnterEvent。

实例：iconview/simple_dd/main.cpp。

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

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

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

也可以参考QTextDrag、QImageDrag和QDragLeaveEvent。

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

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

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

也可以参考QTextDrag、QImageDrag和QDragMoveEvent。

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

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

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

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

也可以参考font、foregroundColor()和QPainter::drawText()。

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

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

在位置pos绘制字符串str。

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

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

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

也可以参考QTextDrag、QImageDrag和QDropEvent。

实例：iconview/simple_dd/main.cpp。

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

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

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

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

也可以参考enabled、enabled、repaint()、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()检查Tab和Shift+Tab并且试图适当地移动焦点。如果没有窗口部件被焦点移入（或者键按下不是Tab或Shift+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(), focusPolicy、keyPressEvent()、keyReleaseEvent()、event()和QFocusEvent。

在QtMultiLineEdit中被重新实现。

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

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

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

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

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

也可以参考focusData()。

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

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

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

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

也可以参考focusInEvent()、focusPolicy、keyPressEvent()、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()更新这个窗口部件。

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

也可以参考font、font、update()和updateGeometry()。

QFontInfo QWidget::fontInfo () const

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

也可以参考font、fontMetrics()和font。

QFontMetrics QWidget::fontMetrics () const

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

也可以参考font、fontInfo()和font。

实例：drawdemo/drawdemo.cpp和qmag/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，表明最佳高度不依赖于宽度。

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

在QMenuBar和QTextEdit中被重新实现。

void QWidget::hide () [虚 槽]

隐藏窗口部件。

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

也可以参考hideEvent()、hidden、show()、showMinimized()、visible和close()。

实例：mdi/application.cpp、network/ftpclient/ftpmainwindow.cpp、popup/popup.cpp、 progress/progress.cpp、scrollview/scrollview.cpp和xform/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()。

也可以参考enabled和enabled。

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()、focusPolicy, focusInEvent()、focusOutEvent()、event()和QKeyEvent。

实例：picture/picture.cpp。

在QLineEdit、QTextEdit和QtMultiLineEdit中被重新实现。

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

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

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

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

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

也可以参考keyPressEvent()、QKeyEvent::ignore()、focusPolicy、focusInEvent()、focusOutEvent()、event()和QKeyEvent。

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

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

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

也可以参考grabMouse()和mouseGrabber()。

QLayout * QWidget::layout () const

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

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

也可以参考sizePolicy。

实例：chart/optionsform.cpp和fonts/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”属性。

在QLineEdit和QtMultiLineEdit中被重新实现。

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。

也可以参考mouseTracking、mousePressEvent()、 mouseReleaseEvent()、mouseDoubleClickEvent()、event()和QMouseEvent。

实例：aclock/aclock.cpp、drawlines/connect.cpp、iconview/simple_dd/main.cpp、life/life.cpp、popup/popup.cpp、qmag/qmag.cpp和scribble/scribble.cpp。

在QSizeGrip中被重新实现。

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

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

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

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

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

实例：biff/biff.cpp、drawlines/connect.cpp、iconview/simple_dd/main.cpp, life/life.cpp, qmag/qmag.cpp、scribble/scribble.cpp和tooltip/tooltip.cpp。

在QSizeGrip中被重新实现。

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

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

也可以参考mouseDoubleClickEvent()、mouseMoveEvent()、event()和QMouseEvent。

实例：drawlines/connect.cpp、hello/hello.cpp、popup/popup.cpp、qmag/qmag.cpp、scribble/scribble.cpp、showimg/showimg.cpp和t14/cannon.cpp。

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

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

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

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

这个和move( QSize(x, y) )一致。

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

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

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

也可以参考resizeEvent()、event()、pos和QMoveEvent。

bool QWidget::ownCursor () const

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

bool QWidget::ownFont () const

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

bool QWidget::ownPalette () const

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

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

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

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

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

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

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

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

也可以参考event()、repaint()、update()、QPainter、QPixmap和QPaintEvent。

实例：drawdemo/drawdemo.cpp、drawlines/connect.cpp、qmag/qmag.cpp、scribble/scribble.cpp、splitter/splitter.cpp、t8/cannon.cpp和t9/cannon.cpp。

在QButton、QFrame、QGLWidget、QSizeGrip、QStatusBar和QTabBar中被重新实现。

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()得到新的调色板。

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

也可以参考palette和palette。

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为真，Qt在paintEvent()调用之前擦除区域(x,y,w,h)。

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

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

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

也可以参考update()、paintEvent()、updatesEnabled和erase()。

实例：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()、updatesEnabled和erase()。

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

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

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

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

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

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

也可以参考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 ) [虚 槽]

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

这个和resize( QSize(w, h) )一致。

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

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

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

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

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

也可以参考moveEvent()、event()、size、QResizeEvent和paintEvent()。

实例：drawdemo/drawdemo.cpp、mainlyQt/editor.cpp、mainlyXt/editor.cpp 、menu/menu.cpp、qmag/qmag.cpp、scribble/scribble.cpp和tooltip/tooltip.cpp。

在QFrame和QGLWidget中被重新实现。

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

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

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

也可以参考QScrollView、erase()和bitBlt()。

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

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

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

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

也可以参考QScrollView、erase()和bitBlt()。

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

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

void QWidget::setActiveWindow () [虚]

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

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

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

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

也可以参考isActiveWindow、topLevelWidget()和show()。

在QXtWidget中被重新实现。

void QWidget::setAutoMask ( bool ) [虚]

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

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

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

实例：customlayout/main.cpp、desktop/desktop.cpp、hello/main.cpp、movies/main.cpp和splitter/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 )

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

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

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

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

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

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

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

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

更多信息请参考enabled文档。

也可以参考isEnabledTo()、QKeyEvent、QMouseEvent和enabledChange()。

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

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

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

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

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

也可以参考erasePixmap()、backgroundColor()、backgroundMode和palette。

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

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

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

void QWidget::setFixedHeight ( int h )

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

也可以参考sizeHint、minimumSize、maximumSize和setFixedSize()。

实例：fonts/simple-qfont-demo/viewer.cpp、layout/layout.cpp、qdir/qdir.cpp和showimg/showimg.cpp。

void QWidget::setFixedSize ( const QSize & s )

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

也可以参考maximumSize和minimumSize。

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

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

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

void QWidget::setFixedWidth ( int w )

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

也可以参考sizeHint、minimumSize、maximumSize和setFixedSize()。

实例：network/ftpclient/ftpmainwindow.cpp、progressbar/progressbar.cpp和qdir/qdir.cpp。

void QWidget::setFocus () [虚 槽]

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

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

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

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

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

也可以参考focus、clearFocus()、focusInEvent()、focusOutEvent()、focusPolicy、QApplication::focusWidget()、grabKeyboard()和grabMouse()。

实例：addressbook/centralwidget.cpp、lineedits/lineedits.cpp、mdi/application.cpp、popup/popup.cpp、rot13/rot13.cpp、t8/main.cpp和wizard/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”属性。

在QComboBox、QLabel和QTabDialog中被重新实现。

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 ) [虚 槽]

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

这相当于setGeometry( QRect(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只对可打印的字符执行键盘事件压缩。修正键、光标移动键、功能键和其它操作键（比如，Escape、Return、Backspace、PrintScreen）将会停止键盘事件压缩，即使如果可以更多可压缩的键盘事件。

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

也可以参考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 ) [虚]

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

这个函数相当于setMaximumSize( QSize(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 ) [虚]

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

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

void QWidget::setMinimumWidth ( int minw )

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

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

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

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

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

在QComboBox、QScrollBar和QSlider中被重新实现。

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()、QStyle、QApplication::style()和QApplication::setStyle()。

实例：grapher/grapher.cpp和progressbar/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()替代它/它们的代理。

也可以参考focusPolicy和setFocusProxy()。

实例：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()、visible和polish()。

实例：canvas/main.cpp、fonts/simple-qfont-demo/simple-qfont-demo.cpp、life/main.cpp、popup/popup.cpp、t1/main.cpp、t3/main.cpp和t4/main.cpp。

在QDialog和QMenuBar中被重新实现。

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.cpp、helpviewer/main.cpp、mdi/application.cpp、qwerty/main.cpp、qwerty/qwerty.cpp和scribble/main.cpp。

void QWidget::showMinimized () [虚 槽]

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

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

也可以参考showNormal()、showMaximized()、show()、hide(), visible和minimized。

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()、updatesEnabled、erase()和setWFlags()。

实例：desktop/desktop.cpp和scrollview/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 () [虚 保护]

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

也可以参考autoMask、setMask()和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()、isActiveWindow、update()和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()、palette和QApplication::setPalette()。

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

BackgroundMode backgroundMode

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

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

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

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

    setBackgroundMode( PaletteBase );

    

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

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

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

BackgroundOrigin backgroundOrigin

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

这个原点是WidgetOrigin（默认）、ParentOrigin和WindowOrigin其中之一。

只有在窗口部件有一个背景像素映射，对于定位有所不同。使用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

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

隐藏的子对象除外。

也可以参考childrenRegion和geometry。

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

QRegion childrenRegion

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

隐藏的子对象除外。

也可以参考childrenRect和geometry。

通过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形光标：

        setCursor( IbeamCursor );

    

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

也可以参考QApplication::setOverrideCursor()。

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

bool customWhatsThis

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

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

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

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

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

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

bool enabled

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

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

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

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

也可以参考enabled、isEnabledTo()、QKeyEvent、QMouseEvent和enabledChange()。

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

bool focus

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

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

也可以参考setFocus()、a href="#clearFocus">clearFocus()、focusPolicy和QApplication::focusWidget()。

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

bool focusEnabled

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

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

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

也可以参考focusPolicy、focusInEvent()、focusOutEvent()、keyPressEvent()、keyReleaseEvent()和enabled。

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

FocusPolicy focusPolicy

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

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

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

也可以参考focusEnabled、focusInEvent()、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

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

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

也可以参考geometry、x、a href="#y-prop">y和pos。

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

QSize frameSize

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

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

QRect geometry

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

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

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

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

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

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

也可以参考frameGeometry、rect、pos、size、moveEvent()、resizeEvent()、minimumSize和maximumSize。

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

int height

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

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

也可以参考geometry、width和size。

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

bool hidden

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

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

也可以参考hide()、show()、visible和isVisibleTo()。

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

QPixmap icon

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

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

也可以参考iconText、caption和设置应用程序图标。

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

QString iconText

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

这个属性只对顶级窗口部件有效。如果没有图标文本被设置，这个函数返回QString::null。

也可以参考icon和caption。

通过setIconText()设置属性值并且通过iconText()来获得属性值。

bool isActiveWindow

这个属性保存的是窗口部件或者它的一个子对象是否是活动窗口。

活动窗口是有键盘焦点的窗口

当弹出窗口是可视的，这个属性对于活动窗口和这个弹出窗口都是真。

也可以参考setActiveWindow()和QApplication::activeWindow()。

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

bool isDesktop

这个属性保存的是窗口部件是否是桌面窗口部件，比如，代表桌面。

一个桌面窗口部件也是顶级窗口部件。

也可以参考isTopLevel和QApplication::desktop()。

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

bool isDialog

这个属性保存的是窗口部件是否是对话框窗口部件。

对话框窗口部件是次要的顶级窗口部件，比如一个有父对象的顶级窗口部件。

也可以参考isTopLevel和QDialog。

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

bool isModal

这个属性保存的是窗口部件是否是模式窗口部件。

这个属性只对顶级窗口部件有效。一个模式窗口部件防止对其它所有顶级窗口部件得到任何输入。

也可以参考isTopLevel、isDialog和QDialog。

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

bool isPopup

这个属性保存的是窗口部件是否是弹出窗口部件。

一个弹出窗口部件是在窗口部件的构造函数中使用窗口部件标记WType_Popup创建的。一个弹出窗口部件也是一个顶级窗口部件。

也可以参考isTopLevel。

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

bool isTopLevel

This property holds whether the widget is a top-level widget. 这个属性保存的是窗口部件是否是顶级窗口部件。

顶级窗口部件通常有框架和标题。弹出和桌面窗口部件也是顶级窗口部件。

顶级窗口部件可以有父窗口部件。然后它和它的父窗口部件就形成一个组并且当它的父对象被删除或最小化等等时，它也被删除或最小化等等。如果被窗口部件支持的话，它和它的父对象一样也有一个普通任务栏条目。

QDialog和QMainWindow窗口部件默认是顶级的，尽管在构造函数中被指定一个父窗口部件。这个行为是由WType_TopLevel窗口部件标记指定的。

也可以参考topLevelWidget()、isDialog、isModal、isPopup、isDesktop和parentWidget()。

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

int maximumHeight

这个属性保存的是窗口部件的最大高度。

这个属性和maximumSize().height()一致。

也可以参考maximumSize和maximumWidth。

通过setMaximumHeight()设置属性值并且通过maximumHeight().来获得属性值。

QSize maximumSize

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

这个窗口部件不能被重定义为比这个最大大小更大的大小了。

也可以参考maximumWidth、maximumHeight、maximumSize、minimumSize和sizeIncrement。

通过setMaximumSize()设置属性值并且通过maximumSize()来获得属性值。

int maximumWidth

这个属性保存的是窗口部件的最大宽度。

这个属性和maximumSize().width()一致。

也可以参考maximumSize和maximumHeight。

通过setMaximumWidth()设置属性值并且通过maximumWidth()来获得属性值。

QRect microFocusHint

这个属性保存的是窗口部件的当前设置的微焦点提示。

更多信息请参考setMicroFocusHint()的文档。

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

bool minimized

这个属性保存的是窗口部件是否是最小化的（变为图标了）。

这个属性和顶级窗口部件相关。

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

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

int minimumHeight

这个属性保存的是窗口部件的最小高度。

这个属性和minimumSize().height()一致。

也可以参考minimumSize和minimumWidth。

通过setMinimumHeight()设置属性值并且通过minimumHeight()来获得属性值。

QSize minimumSize

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

这个窗口部件不能被重定义比这个最小大小更小的大笑了。如果当前大小更小的话，窗口部件的大小被强制为最小大小。

如果你在这个窗口部件中使用了布局，最小大小将会被这个布局设置，而不是setMinimumSize()，除非你设置布局的重定义大小模式为QLayout::FreeResize。

也可以参考minimumWidth、minimumHeight、maximumSize、sizeIncrement和QLayout::resizeMode。

通过setMinimumSize()设置属性值并且通过minimumSize()来获得属性值。

QSize minimumSizeHint

这个属性保存的是建议的窗口部件最小大小。

如果这个属性值是无效的大小，那么就没有被建议的最小大小了。

如果这个窗口部件中没有布局，minimumSizeHint()默认实现返回无效大小并且否则的话返回布局的最小大小。绝大多数内置窗口部件重新实现了minimumSizeHint()。

QLayout从来不会重定义窗口部件大小小于minimumSizeHint。

也可以参考QSize::isValid()、size、minimumSize和sizePolicy。

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

int minimumWidth

这个属性保存的是窗口部件的最小宽度。

这个属性和minimumSize().width()一致。

也可以参考minimumSize和minimumHeight。

通过setMinimumWidth()设置属性值并且通过minimumWidth()来得到属性值。

bool mouseTracking

这个属性保存的是窗口部件跟踪鼠标是否生效。

如果鼠标跟踪失效（默认），当鼠标被移动的时候只有在至少一个鼠标按键被按下时，这个窗口部件才会接收鼠标移动事件。

如果鼠标跟踪生效，如果没有按键被按下，这个窗口部件也会接收鼠标移动事件。

也可以参考mouseMoveEvent()和QApplication::setGlobalMouseTracking()。

通过setMouseTracking()设置属性值并且通过hasMouseTracking()来获得属性值。

bool ownCursor

这个属性保存的是窗口部件是否使用它自己的光标。

如果为假，这个窗口部件使用它父窗口部件的光标。

也可以参考cursor。

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

bool ownFont

这个属性保存的是窗口部件是否使用它自己的字体。

如果为假，这个窗口部件使用它父窗口部件的字体。

也可以参考font。

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

bool ownPalette

这个属性保存的是窗口部件是否使用它自己的调色板。

如果为假，这个窗口部件使用它父窗口部件的调色板。

也可以参考palette。

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

QPalette palette

这个属性保存的是窗口部件的调色板。

只要没有特定的调色板被设置，或者在unsetPalette()被调用之后，这个窗口部件的特定调色板就是父窗口部件的调色板或者（如果这个窗口部件是顶级窗口部件）默认的应用程序调色板。

可以替代定义整个新的调色板的，你也可以使用paletteBackgroundColor、paletteBackgroundPixmap和paletteForegroundColor方便的属性来只改变窗口部件的背景和前景外观。

也可以参考ownPalette、colorGroup和QApplication::palette()。

通过setPalette()设置属性值，通过palette()来获得属性值并且通过unsetPalette()重置属性值。

QColor paletteBackgroundColor

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

这个调色板背景色通常被setBackgroundMode()隐含地设置，尽管它也可以由setPaletteBackgroundColor()明显地设置。setPaletteBackgroundColor()是一个创建和设置通过setPalette()修改过的QPalette方便函数。这个调色板根据窗口部件的背景模式被修改。例如，如果背景模式是PaletteButton，调色板的QColorGroup::Button颜色条目所用的颜色被设置。

如果有一个背景像素映射（使用setPaletteBackgroundPixmap()设置的），那么这个函数的返回值是不确定的。

也可以参考paletteBackgroundPixmap、paletteForegroundColor、palette和colorGroup。

通过setPaletteBackgroundColor()设置属性值，通过paletteBackgroundColor()来获得属性值并且通过unsetPalette()重置属性值。

QPixmap paletteBackgroundPixmap

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

这个调色板背景像素映射通常被setBackgroundMode()隐含地设置，尽管它也可以由setPaletteBackgroundPixmap()明显地设置。setPaletteBackgroundPixmap()是一个创建和设置通过setPalette()修改过的QPalette方便函数。这个调色板根据窗口部件的背景模式被修改。例如，如果背景模式是PaletteButton，调色板的QColorGroup::Button颜色条目所用的像素映射被设置。

如果有一个简单的背景颜色（使用setPaletteBackgroundColor()设置的），那么这个函数返回0。

也可以参考paletteBackgroundColor、paletteForegroundColor、palette和colorGroup。

通过setPaletteBackgroundPixmap()设置属性值，通过paletteBackgroundPixmap()来获得属性值并且通过unsetPalette()重置属性值。

QColor paletteForegroundColor

这个属性保存的是窗口部件的前景色。

setPaletteForegroundColor()是一个创建和设置通过setPalette()修改过的QPalette方便函数。这个调色板根据窗口部件的背景模式被修改。例如，如果背景模式是PaletteButton，调色板的QColorGroup::ButtonText颜色条目所用的颜色被设置。

也可以参考palette、QApplication::setPalette()、backgroundMode、foregroundColor()、backgroundMode和setEraseColor()。

通过setPaletteForegroundColor()设置属性值，通过paletteForegroundColor()来获得属性值并且通过unsetPalette().重置属性值。

QPoint pos

这个属性保存的是窗口部件在它的父窗口部件中的位置。

如果这个窗口部件是顶级窗口部件，那它的位置就是在桌面上包括它的框架的窗口部件的位置。

当改变位置时，这个窗口部件如果可视，会立即接收一个移动事件（moveEvent()）。如果这个窗口部件当前不是可视的，它被保证会在它被显示之前收到这个事件。

move()是虚函数，并且Qt中所有其它重载move()的重新实现都调用它。

警告：在moveEvent()调用move()或setGeometry()会导致无限循环。

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

也可以参考frameGeometry、size、x和y。

通过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()会导致无限循环。

也可以参考pos、geometry、minimumSize、maximumSize和resizeEvent()。

通过resize()设置属性值并且通过size()来获得属性值。

QSize sizeHint

这个属性保存的是建议的窗口部件大小。

如果这个属性值是无效的大小，那么就没有大小被建议。

如果这个窗口部件没有布局，sizeHint()的默认实现返回一个无效大小，并且否则的话就返回布局的首选大小。

也可以参考QSize::isValid()、minimumSizeHint、sizePolicy、minimumSize和updateGeometry()。

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

QSize sizeIncrement

这个属性保存的是窗口部件的大小增量。

当用户重新定义窗口的大小时，大小会在水平方向上按sizeIncrement().width()像素和垂直方向上按sizeIncrement.height()像素来逐步变化，基础大小为baseSize() 。首选的窗口部件大小为非负整数i和j：

        width = baseSize().width() + i * sizeIncrement().width();

        height = baseSize().height() + j * sizeIncrement().height();

    

注意，当你为所有的窗口部件设置大小增量时，它只对顶级窗口部件有效。

警告：大小增量在Windows下没有效果，并且也许会被X上的窗口管理器忽视。

也可以参考size、minimumSize和maximumSize。

通过setSizeIncrement()设置属性值并且通过sizeIncrement()来获得属性值。

QSizePolicy sizePolicy

这个属性保存的是窗口部件的默认布局行为。

如果有一个QLayout管理这个窗口部件的子对象，这个大小策略由布局使用的大小策略指定。如果没有这样的QLayout，那么这个函数的结果被使用。

默认策略是首选/首选，也就是说窗口部件可以被自由地重新定义大小，但是首选的是sizeHint()返回的大小。具有按钮特征的窗口部件设置它们的大小策略为水平方向可以伸展，但垂直方向固定。这同样适用于行编辑控件（比如QLineEdit、QSpinBox或可编辑的QComboBox）和其它水平方向的窗口部件（比如QProgressBar）。QToolButton的大小策略通常是允许两个方向都可以变化。支持不同方向的窗口部件（比如QSlider、QScrollBar或QHeader）仅仅按被指定的方向变化。可以提供滚动条的窗口部件（通常是QScrollView的子类）趋向于指定它们可以使用额外的空间，并且它们可以在小于sizeHint()时正常工作。

也可以参考sizeHint、QLayout、QSizePolicy和updateGeometry()。

通过setSizePolicy()设置属性值并且通过sizePolicy()来获得属性值。

bool underMouse

这个属性保存的是窗口部件是否在鼠标光标下。

这个值在拖放操作期间不会被完全地更新。

也可以参考QEvent::Enter和QEvent::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()、hidden、isVisibleTo()、minimized、showEvent()和hideEvent()。

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

QRect visibleRect

这个属性保存的是窗口部件的当前可视矩形。

这个属性对于优化窗口部件的立即重新绘制很有用。典型用法是：

    repaint( w->visibleRect() );

  

或

    repaint( w->visibleRect(), FALSE );

  

如果没有什么是可视的，这个返回的矩形为空。

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

int width

这个属性保存的是不包含任何窗口框架的窗口部件宽度。

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

也可以参考geometry、height和size。

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

int x

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

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

也可以参考frameGeometry、y和pos。

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

int y

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

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

也可以参考frameGeometry、x和pos。

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

 

QDialog类参考

QDialog类是对话框窗口的基类。 详情请见……

#include <qdialog.h>

继承了QWidget。

被QColorDialog、QErrorMessage、QFileDialog、QFontDialog、QInputDialog、QMessageBox、QProgressDialog、QTabDialog和QWizard继承。

所有成员函数的列表。

公有成员

• QDialog ( QWidget * parent = 0, const char * name = 0, bool modal = FALSE, WFlags f = 0 )
• ~QDialog ()
• enum DialogCode { Rejected, Accepted }
• int result () const
• virtual void show ()
• void setOrientation ( Orientation orientation )
• Orientation orientation () const
• void setExtension ( QWidget * extension )
• QWidget * extension () const
• void setSizeGripEnabled ( bool )
• bool isSizeGripEnabled () const

公有槽

• int exec ()

属性

• bool sizeGripEnabled - 大小控制是否生效

保护成员

• void setResult ( int i )

保护槽

• virtual void done ( int r )
• virtual void accept ()
• virtual void reject ()
• void showExtension ( bool showIt )

 

详细描述

QDialog类是对话框窗口的基类。

对话框窗口是主要用于短期任务以及和用户进行简要通讯的顶级窗口。QDialog可以是模式的也可以是非模式的。QDialog支持扩展性并且可以提供返回值。它们可以有默认按钮。QDialog也可以有一个QSizeGrip在它的右下角，使用setSizeGripEnabled()。

注意QDialog使用父窗口部件的方法和Qt中其它类稍微不同。对话框总是顶级窗口部件，但是如果它有一个父对象，它的默认位置就是父对象的中间。它也将和父对象共享工具条条目。

这里有三种有用的对话框：

1. 模式对话框就是阻塞同一应用程序中其它可视窗口的输入的对话框：用户必须完成这个对话框中的交互操作并且关闭了它之后才能访问应用程序中的其它任何窗口。模式对话框有它们自己的本地事件循环。用来让用户选择一个文件或者用来设置应用程序参数的对话框通常是模式的。调用exec()来显示模式对话框。当用户关闭这个对话框，exec()将提供一个可用的返回值并且这时流程控制继续从调用exec()的地方进行。通常，我们连接默认按钮，例如“OK”到accept()槽并且把“Cancel”连接到reject()槽，来使对话框关闭并且返回适当的值。另外我们也可以连接done()槽，传递给它Accepted或Rejected。
2. 非模式对话框是和同一个程序中其它窗口操作无关的对话框。在字处理软件中查找和替换对话框通常是非模式的来允许同时与应用程序主窗口和对话框进行交互。调用show()来显示非模式对话框。show()立即返回，这样调用代码中的控制流将会继续。在实践中你将会经常调用show()并且在调用show()的函数最后，控制返回主事件循环。
3. “半模式”对话框是立即把控制返回给调用者的模式对话框。半模式对话框没有它们自己的事件循环，所以你将需要周期性地调用QApplication::processEvents()来让这个半模式对话框有处理它的事件的机会。进程对话框（例如QProgressDialog）就是一个实例，在你想让用户能够和进程对话框交互的地方那个，例如撤销一个长期运行的操作，但是需要实际上执行这个操作。半模式对话框模式标记被设置为真并且调用show()函数来被显示。

默认按钮

对话框的“默认”按钮适当用户按下回车键或者换行键时被按下的按钮。这个按钮用来表示用户接受对话框的设置并且希望关闭这个对话框。使用QPushButton::setDefault()、QPushButton::isDefault()和QPushButton::autoDefault()来设置并且控制对话框的默认按钮。

扩展性

扩展性是可以用两种方式来显示对话框：一个局部对话框用来显示通常最常用的选项，和一个显示所有选项的完全对话框。通常可扩展的对话框将初始化为一个局部对话框，但是有一个“更多”按钮。如果用户点击这个“更多”按钮，完全对话框将会出现。扩展性是由setExtension()、setOrientation()和showExtension()。

返回值（模式对话框）

模式对话框通常用在需要返回值的地方，例如需要分清用户按下“OK”还是“Cancel”。对话框可以通过调用accept()或reject()槽来被关闭，并且exec()将返回适当的Accepted或Rejected。exec()返回这个对话框的结果。如果窗口还没有被销毁，这个结果也可以通过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文档。

请参考QTabDialog、QWidget、QProgressDialog、GUI 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.cpp、i18n/main.cpp、network/networkprotocol/view.cpp、a href="qdir-example.html#x1805">qdir/qdir.cpp、showimg/showimg.cpp和wizard/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

返回模式对话框的结果代码，Accepted或Rejected。

如果对话框使用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.cpp、showimg/showimg.cpp和sql/overview/form1/main.cpp。

从QWidget中重新实现的。

void QDialog::showExtension ( bool showIt ) [保护 槽]

如果showIt为真，对话框的扩展被显示，否则扩展被隐藏。

这个槽通常被连接到QPushButton的QButton::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 setRightJustification ( bool )
• virtual void setUsesBigPixmaps ( bool )
• virtual void setUsesTextLabel ( bool )
• virtual void setDockWindowsMovable ( bool )
• virtual void setOpaqueMoving ( bool )
• virtual void setDockMenuEnabled ( bool b )
• virtual void whatsThis ()
• virtual void setAppropriate ( QDockWindow * dw, bool a )
• virtual void customize ()
• void setToolBarsMovable ( bool )  （废弃）

信号

• void pixmapSizeChanged ( bool )
• void usesTextLabelChanged ( bool )
• void dockWindowPositionChanged ( QDockWindow * dockWindow )
• void toolBarPositionChanged ( QToolBar * )  （废弃）

属性

• bool dockWindowsMovable - 锚接窗口是否可以移动
• bool opaqueMoving - 锚接窗口是否是被不透明地移动
• bool rightJustification - 主窗口是否右对齐它的锚接窗口
• bool usesBigPixmaps - 大像素映射是否生效
• bool usesTextLabel - 工具条按钮的文本标签是否生效

保护成员

• virtual void childEvent ( QChildEvent * e )

保护槽

• virtual void setUpLayout ()
• virtual bool showDockMenu ( const QPoint & globalPos )
• void menuAboutToShow ()

相关函数

• 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.cpp、application/application.cpp、action/main.cpp和action/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提供了一个连接到状态条的QToolTipGroup。toolTipGroup()函数提供了对默认QToolTipGroup的访问。它不能设置一个不同的工具提示组。

新的锚接窗口和工具条可以通过使用addDockWindow()来被添加到QMainWindow中。锚接窗口可以使用moveDockWindow()来移动并且使用removeDockWindow()来移除。QMainWindow允许默认锚接窗口（工具条）锚接在所有它的锚接区域中（上、下、左、右）。你可以使用setDockEnabled()为锚接窗口而使锚接区域生效/失效。当添加或者移动锚接窗口时，你可以指定它们的“边缘”（锚接区域）。当前可用的边缘有：Top、Left、Right、Bottom、Minimized （有效地一个“隐藏”锚接区域）和TornOff（浮动）。关于这些区域的解释请参考Qt::Dock。注意*ToolBar函数被考虑向后兼容，所有的新代码都应该使用*DockWindow函数。QToolBar是QDockWindow的子类，所以所有对于锚接窗口能工作地函数对于工具条也一样可以工作。如果用户通过点击锚接窗口地窗口句柄来最小化一个锚接窗口，那么锚接窗口将会被移到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作为一个在它自己可移动的锚接窗口中可伸展的窗口部件并且限制这个锚接窗口只在Top或Bottom锚接区域存在：

    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.open( IO_WriteOnly ) ) {

      QTextStream ts( &f );

      ts << *mainWindow;

      f.close();

  }

  

为了恢复锚接窗口的位置和大小（通常是当这个应用程序再次开始），请这样做：

  QFile f( filename );

  if ( f.open( IO_ReadOnly ) ) {

      QTextStream ts( &f );

      ts >> *mainWindow;

      f.close();

  }

  

QSettings类可以和这些流操作符联合使用来存放这个应用程序的设置。

QMainWindow对锚接窗口和工具条的管理很明显地是由QDockArea在后面完成的。

对于多文档界面（MDI），使用QWorkspace作为中央窗口部件。

把锚接窗口（例如工具条）添加到QMainWindow的锚接区域是很简单的。如果被提供的锚接区域对于你的应用程序是不够的，我们建议你创建一个QWidget的子类并且把你自己的锚接区域（请参考QDockArea）添加到这个子类中，因为QMainWindow只提供了由它提供的标准锚接区域的特定功能。

 

也可以参考QToolBar、QDockWindow、QStatusBar、QAction、QMenuBar、QPopupMenu、QToolTipGroup、QDialog和主窗口和相关类。

 

成员类型文档

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而不是只把它作为QWidget的0。如果你不想让你的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 )

这个函数将会尽量紧凑地排列在可视的锚接区域（Top、Left、Right和Bottom）中的锚接窗口。

如果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的锚接区域中的锚接窗口，以及Minimized和TornOff锚接窗口的布局（大小和位置）都写到文本流ts中。

例如，这可以被用于和QSettings联合使用来保存用户的布局。

也可以参考operator>>()。

QTextStream & operator>> ( QTextStream & ts, QMainWindow & mainWindow )

从文本流ts中读入QMainWindow mainWindow的锚接区域中的锚接窗口，以及Minimized和TornOff锚接窗口的布局（大小和位置）。恢复锚接窗口和锚接区域的大小和位置。布局信息必须是由operator<<()生成的。

例如，这可以被用于和QSettings联合使用来恢复用户的布局。

也可以参考operator<<()。