FCL/sf/mw/qt: comparison src/gui/kernel/qwidget.cpp

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 , usesDoubleBufferedGLContext(0)
 #if defined(Q_WS_X11)
 , picture(0)
 #elif defined(Q_WS_WIN)
 , noPaintOnScreen(0)
+, nativeGesturePanEnabled(0)
 #elif defined(Q_WS_MAC)
 , needWindowChange(0)
 , isGLWidget(0)
 , window_event(0)
 , qd_hd(0)
 widgetItem->wid = 0;
 if (extra)
 deleteExtra();
+#ifndef QT_NO_GRAPHICSEFFECT
 delete graphicsEffect;
+#endif //QT_NO_GRAPHICSEFFECT
 }
 QWindowSurface *QWidgetPrivate::createDefaultWindowSurface()
 {
 Q_Q(QWidget);
 If \a enable is true, make this widget have edit focus, in which
 case Qt::Key_Up and Qt::Key_Down will be delivered to the widget
 normally; otherwise, Qt::Key_Up and Qt::Key_Down are used to
 change focus.
-This feature is only available in Qt for Embedded Linux.
+This feature is only available in Qt for Embedded Linux and Qt
+for Symbian.
 \sa hasEditFocus(), QApplication::keypadNavigationEnabled()
 */
 void QWidget::setEditFocus(bool on)
 {
 In Qt, contextual softkeys are added to a widget by calling addAction() and
 passing a \c QAction with a softkey role set on it. When the widget
 containing the softkey actions has focus, its softkeys should appear in
 the user interface. Softkeys are discovered by traversing the widget
-heirarchy so it is possible to define a single set of softkeys that are
+hierarchy so it is possible to define a single set of softkeys that are
 present at all times by calling addAction() for a given top level widget.
 On some platforms, this concept overlaps with \c QMenuBar such that if no
 other softkeys are found and the top level widget is a QMainWindow containing
 a QMenuBar, the menubar actions may appear on one of the softkeys.
 {
 if (!extra) {                                // if not exists
 extra = new QWExtra;
 extra->glContext = 0;
 extra->topextra = 0;
+#ifndef QT_NO_GRAPHICSVIEW
 extra->proxyWidget = 0;
+#endif
 #ifndef QT_NO_CURSOR
 extra->curs = 0;
 #endif
 extra->minw = 0;
 extra->minh = 0;
 */
 void QWidgetPrivate::propagatePaletteChange()
 {
 Q_Q(QWidget);
 // Propagate a new inherited mask to all children.
+#ifndef QT_NO_GRAPHICSVIEW
 if (!q->parentWidget() && extra && extra->proxyWidget) {
-#ifndef QT_NO_GRAPHICSVIEW
 QGraphicsProxyWidget *p = extra->proxyWidget;
 inheritedPaletteResolveMask = p->d_func()->inheritedPaletteResolveMask | p->palette().resolve();
+} else
 #endif //QT_NO_GRAPHICSVIEW
-} else if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation)) {
+if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation)) {
 inheritedPaletteResolveMask = 0;
 }
 int mask = data.pal.resolve() | inheritedPaletteResolveMask;
 QEvent pc(QEvent::PaletteChange);
 }
 }
 return r;
 }
+#ifndef QT_NO_GRAPHICSEFFECT
 void QWidgetPrivate::invalidateGraphicsEffectsRecursively()
 {
 Q_Q(QWidget);
 QWidget *w = q;
 do {
 w->graphicsEffect()->source()->d_func()->invalidateCache();
 }
 w = w->parentWidget();
 } while (w);
 }
+#endif //QT_NO_GRAPHICSEFFECT
 void QWidgetPrivate::setDirtyOpaqueRegion()
 {
 Q_Q(QWidget);
 dirtyOpaqueChildren = true;
+#ifndef QT_NO_GRAPHICSEFFECT
 invalidateGraphicsEffectsRecursively();
+#endif //QT_NO_GRAPHICSEFFECT
 if (q->isWindow())
 return;
 QWidget *parent = q->parentWidget();
 QWidgetPrivate *pd = parent->d_func();
 if (!pd->dirtyOpaqueChildren)
 pd->setDirtyOpaqueRegion();
 }
-QRegion QWidgetPrivate::getOpaqueRegion() const
-{
-Q_Q(const QWidget);
-QRegion r = isOpaque ? q->rect() : getOpaqueChildren();
-if (extra && extra->hasMask)
-r &= extra->mask;
-if (r.isEmpty())
-return r;
-return r & clipRect();
-}
 const QRegion &QWidgetPrivate::getOpaqueChildren() const
 {
 if (!dirtyOpaqueChildren)
 return opaqueChildren;
 QWidget *child = qobject_cast<QWidget *>(children.at(i));
 if (!child || !child->isVisible() || child->isWindow())
 continue;
 const QPoint offset = child->geometry().topLeft();
-that->opaqueChildren += child->d_func()->getOpaqueRegion().translated(offset);
+QWidgetPrivate *childd = child->d_func();
-}
+QRegion r = childd->isOpaque ? child->rect() : childd->getOpaqueChildren();
+if (childd->extra && childd->extra->hasMask)
+r &= childd->extra->mask;
+if (r.isEmpty())
+continue;
+r.translate(offset);
+that->opaqueChildren += r;
+}
+that->opaqueChildren &= q_func()->rect();
 that->dirtyOpaqueChildren = false;
 return that->opaqueChildren;
 }
 Q_Q(const QWidget);
 const QWidget *w = q;
 QPoint offset;
+#ifndef QT_NO_GRAPHICSEFFECT
 if (graphicsEffect) {
 w = q->parentWidget();
 offset -= data.crect.topLeft();
 }
+#endif //QT_NO_GRAPHICSEFFECT
 while (w) {
 const QWidgetPrivate *wd = w->d_func();
 if (wd->extra && wd->extra->hasMask)
 region &= (w != q) ? wd->extra->mask.translated(offset) : wd->extra->mask;
 void QWidgetPrivate::updateIsOpaque()
 {
 // hw: todo: only needed if opacity actually changed
 setDirtyOpaqueRegion();
+#ifndef QT_NO_GRAPHICSEFFECT
 if (graphicsEffect) {
 // ### We should probably add QGraphicsEffect::isOpaque at some point.
 setOpaque(false);
 return;
 }
+#endif //QT_NO_GRAPHICSEFFECT
 Q_Q(QWidget);
 #ifdef Q_WS_X11
 if (q->testAttribute(Qt::WA_X11OpenGLOverlay)) {
 setOpaque(false);
 }
 #endif
 #if defined(Q_WS_MAC)
 setEnabled_helper_sys(enable);
 #endif
+#ifndef QT_NO_IM
 if (q->testAttribute(Qt::WA_InputMethodEnabled) && q->hasFocus()) {
-QInputContext *qic = inputContext();
+QWidget *focusWidget = effectiveFocusWidget();
+QInputContext *qic = focusWidget->d_func()->inputContext();
 if (enable) {
-qic->setFocusWidget(q);
+qic->setFocusWidget(focusWidget);
 } else {
 qic->reset();
 qic->setFocusWidget(0);
 }
 }
+#endif //QT_NO_IM
 QEvent e(QEvent::EnabledChange);
 QApplication::sendEvent(q, &e);
 #ifdef QT3_SUPPORT
 q->enabledChange(!enable); // compatibility
 #endif
 QPalette QWidgetPrivate::naturalWidgetPalette(uint inheritedMask) const
 {
 Q_Q(const QWidget);
 QPalette naturalPalette = QApplication::palette(q);
 if (!q->testAttribute(Qt::WA_StyleSheet)
-&& (!q->isWindow() || q->testAttribute(Qt::WA_WindowPropagation) || (extra && extra->proxyWidget))) {
+&& (!q->isWindow() || q->testAttribute(Qt::WA_WindowPropagation)
+#ifndef QT_NO_GRAPHICSVIEW
+|| (extra && extra->proxyWidget)
+#endif //QT_NO_GRAPHICSVIEW
+)) {
 if (QWidget *p = q->parentWidget()) {
 if (!p->testAttribute(Qt::WA_StyleSheet)) {
 if (!naturalPalette.isCopyOf(QApplication::palette())) {
 QPalette inheritedPalette = p->palette();
 inheritedPalette.resolve(inheritedMask);
 naturalPalette = inheritedPalette.resolve(naturalPalette);
 } else {
 naturalPalette = p->palette();
 }
 }
-} else if (extra && extra->proxyWidget) {
+}
 #ifndef QT_NO_GRAPHICSVIEW
+else if (extra && extra->proxyWidget) {
 QPalette inheritedPalette = extra->proxyWidget->palette();
 inheritedPalette.resolve(inheritedMask);
 naturalPalette = inheritedPalette.resolve(naturalPalette);
+}
 #endif //QT_NO_GRAPHICSVIEW
-}
 }
 naturalPalette.resolve(0);
 return naturalPalette;
 }
 /*!
 QFont QWidgetPrivate::naturalWidgetFont(uint inheritedMask) const
 {
 Q_Q(const QWidget);
 QFont naturalFont = QApplication::font(q);
 if (!q->testAttribute(Qt::WA_StyleSheet)
-&& (!q->isWindow() || q->testAttribute(Qt::WA_WindowPropagation) || (extra && extra->proxyWidget))) {
+&& (!q->isWindow() || q->testAttribute(Qt::WA_WindowPropagation)
+#ifndef QT_NO_GRAPHICSVIEW
+|| (extra && extra->proxyWidget)
+#endif //QT_NO_GRAPHICSVIEW
+)) {
 if (QWidget *p = q->parentWidget()) {
 if (!p->testAttribute(Qt::WA_StyleSheet)) {
 if (!naturalFont.isCopyOf(QApplication::font())) {
 QFont inheritedFont = p->font();
 inheritedFont.resolve(inheritedMask);
 naturalFont = inheritedFont.resolve(naturalFont);
 } else {
 naturalFont = p->font();
 }
 }
-} else if (extra && extra->proxyWidget) {
+}
 #ifndef QT_NO_GRAPHICSVIEW
+else if (extra && extra->proxyWidget) {
 QFont inheritedFont = extra->proxyWidget->font();
 inheritedFont.resolve(inheritedMask);
 naturalFont = inheritedFont.resolve(naturalFont);
+}
 #endif //QT_NO_GRAPHICSVIEW
-}
 }
 naturalFont.resolve(0);
 return naturalFont;
 }
 #if defined(Q_WS_X11)
 // make sure the font set on this widget is associated with the correct screen
 data.fnt.x11SetScreen(xinfo.screen());
 #endif
 // Combine new mask with natural mask and propagate to children.
+#ifndef QT_NO_GRAPHICSVIEW
 if (!q->parentWidget() && extra && extra->proxyWidget) {
-#ifndef QT_NO_GRAPHICSVIEW
 QGraphicsProxyWidget *p = extra->proxyWidget;
 inheritedFontResolveMask = p->d_func()->inheritedFontResolveMask | p->font().resolve();
+} else
 #endif //QT_NO_GRAPHICSVIEW
-} else if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation)) {
+if (q->isWindow() && !q->testAttribute(Qt::WA_WindowPropagation)) {
 inheritedFontResolveMask = 0;
 }
 uint newMask = data.fnt.resolve() | inheritedFontResolveMask;
 for (int i = 0; i < children.size(); ++i) {
 \brief the layout direction for this widget
 By default, this property is set to Qt::LeftToRight.
 When the layout direction is set on a widget, it will propagate to
-the widget's children. Children added after the call to \c
+the widget's children, but not to a child that is a window and not
-setLayoutDirection() will not inherit the parent's layout
+to a child for which setLayoutDirection() has been explicitly
+called. Also, child widgets added \e after setLayoutDirection()
+has been called for the parent do not inherit the parent's layout
 direction.
 \sa QApplication::layoutDirection
 */
 void QWidget::setLayoutDirection(Qt::LayoutDirection direction)
 \since 4.6
 \sa setGraphicsEffect()
 */
+#ifndef QT_NO_GRAPHICSEFFECT
 QGraphicsEffect *QWidget::graphicsEffect() const
 {
 Q_D(const QWidget);
 return d->graphicsEffect;
 }
+#endif //QT_NO_GRAPHICSEFFECT
 /*!
 \brief The setGraphicsEffect function is for setting the widget's graphics effect.
 the new \a effect.
 If \a effect is the installed on a different widget, setGraphicsEffect() will remove
 the effect from the widget and install it on this widget.
+QWidget takes ownership of \a effect.
 \note This function will apply the effect on itself and all its children.
 \since 4.6
 \sa graphicsEffect()
 */
+#ifndef QT_NO_GRAPHICSEFFECT
 void QWidget::setGraphicsEffect(QGraphicsEffect *effect)
 {
 Q_D(QWidget);
 if (d->graphicsEffect == effect)
 return;
-if (d->graphicsEffect && effect) {
+if (d->graphicsEffect) {
+d->invalidateBuffer(rect());
 delete d->graphicsEffect;
 d->graphicsEffect = 0;
 }
-if (!effect) {
+if (effect) {
-// Unset current effect.
-QGraphicsEffectPrivate *oldEffectPrivate = d->graphicsEffect->d_func();
-d->graphicsEffect = 0;
-if (oldEffectPrivate) {
-oldEffectPrivate->setGraphicsEffectSource(0); // deletes the current source.
-}
-} else {
 // Set new effect.
 QGraphicsEffectSourcePrivate *sourced = new QWidgetEffectSourcePrivate(this);
 QGraphicsEffectSource *source = new QGraphicsEffectSource(*sourced);
 d->graphicsEffect = effect;
 effect->d_func()->setGraphicsEffectSource(source);
+update();
 }
 d->updateIsOpaque();
-update();
+}
-}
+#endif //QT_NO_GRAPHICSEFFECT
 bool QWidgetPrivate::isAboutToShow() const
 {
 if (data.in_show)
 return true;
 const QSize size = rect.size();
 if (size.isNull())
 return;
 QPixmap pixmap(size);
-if (!(renderFlags & QWidget::DrawWindowBackground)
+if (!(renderFlags & QWidget::DrawWindowBackground) || !isOpaque)
-|| !q->palette().brush(q->backgroundRole()).isOpaque())
 pixmap.fill(Qt::transparent);
 q->render(&pixmap, QPoint(), toBePainted, renderFlags);
 const bool restore = !(painter->renderHints() & QPainter::SmoothPixmapTransform);
 painter->setRenderHints(QPainter::SmoothPixmapTransform, true);
 {
 if (rgn.isEmpty())
 return;
 Q_Q(QWidget);
+#ifndef QT_NO_GRAPHICSEFFECT
 if (graphicsEffect && graphicsEffect->isEnabled()) {
 QGraphicsEffectSource *source = graphicsEffect->d_func()->source;
 QWidgetEffectSourcePrivate *sourced = static_cast<QWidgetEffectSourcePrivate *>
 (source->d_func());
 if (!sourced->context) {
 QPaintEngine *paintEngine = pdev->paintEngine();
 paintEngine->d_func()->systemClip = rgn.translated(offset);
 QPainter p(pdev);
 p.translate(offset);
 context.painter = &p;
-graphicsEffect->draw(&p, source);
+graphicsEffect->draw(&p);
 paintEngine->d_func()->systemClip = QRegion();
 } else {
 context.painter = sharedPainter;
 if (sharedPainter->worldTransform() != sourced->lastEffectTransform) {
 sourced->invalidateCache();
 sourced->lastEffectTransform = sharedPainter->worldTransform();
 }
 sharedPainter->save();
 sharedPainter->translate(offset);
-graphicsEffect->draw(sharedPainter, source);
+graphicsEffect->draw(sharedPainter);
 sharedPainter->restore();
 }
 sourced->context = 0;
 return;
 }
 }
+#endif //QT_NO_GRAFFICSEFFECT
 const bool asRoot = flags & DrawAsRoot;
 const bool alsoOnScreen = flags & DrawPaintOnScreen;
 const bool recursive = flags & DrawRecursive;
 const bool alsoInvisible = flags & DrawInvisible;
 return;
 QWidgetPrivate *wd = w->d_func();
 const QPoint widgetPos(w->data->crect.topLeft());
 const bool hasMask = wd->extra && wd->extra->hasMask && !wd->graphicsEffect;
 if (index > 0) {
 QRegion wr(rgn);
 if (wd->isOpaque)
 wr -= hasMask ? wd->extra->mask.translated(widgetPos) : w->data->crect;
 paintSiblingsRecursive(pdev, siblings, --index, wr, offset, flags
 , currentSurface
 #endif
 , sharedPainter, backingStore);
 }
-if (w->updatesEnabled() && (!w->d_func()->extra || !w->d_func()->extra->proxyWidget)) {
+if (w->updatesEnabled()
+#ifndef QT_NO_GRAPHICSVIEW
+&& (!w->d_func()->extra || !w->d_func()->extra->proxyWidget)
+#endif //QT_NO_GRAPHICSVIEW
+) {
 QRegion wRegion(rgn);
 wRegion &= wd->effectiveRectFor(w->data->crect);
 wRegion.translate(-widgetPos);
 if (hasMask)
 wRegion &= wd->extra->mask;
 wd->drawWidget(pdev, wRegion, offset + widgetPos, flags, sharedPainter, backingStore);
 }
 }
+#ifndef QT_NO_GRAPHICSEFFECT
 QRectF QWidgetEffectSourcePrivate::boundingRect(Qt::CoordinateSystem system) const
 {
 if (system != Qt::DeviceCoordinates)
 return m_widget->rect();
 wd->drawWidget(context->pdev, toBePainted, context->offset, context->flags,
 context->sharedPainter, context->backingStore);
 }
-QPixmap QWidgetEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset) const
+QPixmap QWidgetEffectSourcePrivate::pixmap(Qt::CoordinateSystem system, QPoint *offset,
+QGraphicsEffect::PixmapPadMode mode) const
 {
 const bool deviceCoordinates = (system == Qt::DeviceCoordinates);
 if (!context && deviceCoordinates) {
 // Device coordinates without context not yet supported.
 qWarning("QGraphicsEffectSource::pixmap: Not yet implemented, lacking device context");
 const QTransform &painterTransform = context->painter->worldTransform();
 sourceRect = painterTransform.mapRect(sourceRect);
 pixmapOffset = painterTransform.map(pixmapOffset);
 }
-QRect effectRect = m_widget->graphicsEffect()->boundingRectFor(sourceRect).toAlignedRect();
+QRect effectRect;
+if (mode == QGraphicsEffect::PadToEffectiveBoundingRect) {
+effectRect = m_widget->graphicsEffect()->boundingRectFor(sourceRect).toAlignedRect();
+} else if (mode == QGraphicsEffect::PadToTransparentBorder) {
+effectRect = sourceRect.adjusted(-1, -1, 1, 1).toAlignedRect();
+} else {
+effectRect = sourceRect.toAlignedRect();
+}
 if (offset)
 *offset = effectRect.topLeft();
 if (deviceCoordinates) {
 // Clip to device rect.
 QPixmap pixmap(effectRect.size());
 pixmap.fill(Qt::transparent);
 m_widget->render(&pixmap, pixmapOffset);
 return pixmap;
 }
+#endif //QT_NO_GRAPHICSEFFECT
 #ifndef QT_NO_GRAPHICSVIEW
 /*!
 \internal
 tell it that it is about to lose the focus. Then a focus in event
 is sent to this widget to tell it that it just received the focus.
 (Nothing happens if the focus in and focus out widgets are the
 same.)
+\note On embedded platforms, setFocus() will not cause an input panel
+to be opened by the input method. If you want this to happen, you
+have to send a QEvent::RequestSoftwareInputPanel event to the
+widget yourself.
 setFocus() gives focus to a widget regardless of its focus policy,
 but does not clear any keyboard grab (see grabKeyboard()).
 Be aware that if the widget is hidden, it will not accept focus
 until it is shown.
 called from focusOutEvent() or focusInEvent(), you may get an
 infinite recursion.
 \sa hasFocus(), clearFocus(), focusInEvent(), focusOutEvent(),
 setFocusPolicy(), focusWidget(), QApplication::focusWidget(), grabKeyboard(),
-grabMouse(), {Keyboard Focus}
+grabMouse(), {Keyboard Focus}, QEvent::RequestSoftwareInputPanel
 */
 void QWidget::setFocus(Qt::FocusReason reason)
 {
 if (!isEnabled())
 parent->d_func()->layout->activate();
 if (parent->isWindow())
 break;
 parent = parent->parentWidget();
 }
-if (parent && !d->getOpaqueRegion().isEmpty())
+if (parent)
 parent->d_func()->setDirtyOpaqueRegion();
 }
 // adjust size if necessary
 if (!wasResized
 changeEvent(event);
 {
 QList<QObject*> childList = d->children;
 for (int i = 0; i < childList.size(); ++i) {
 QObject *o = childList.at(i);
-QApplication::sendEvent(o, event);
+if (o)
+QApplication::sendEvent(o, event);
 }
 }
 update();
 break;
 case QEvent::WindowUnblocked:
 {
 QList<QObject*> childList = d->children;
 for (int i = 0; i < childList.size(); ++i) {
 QObject *o = childList.at(i);
-if (o != QApplication::activeModalWidget()) {
+if (o && o != QApplication::activeModalWidget()) {
 if (qobject_cast<QWidget *>(o) && static_cast<QWidget *>(o)->isWindow()) {
 // do not forward the event to child windows,
 // QApplication does this for us
 continue;
 }
 #endif
 case QEvent::TouchBegin:
 case QEvent::TouchUpdate:
 case QEvent::TouchEnd:
 {
+#ifndef Q_WS_MAC
 QTouchEvent *touchEvent = static_cast<QTouchEvent *>(event);
 const QTouchEvent::TouchPoint &touchPoint = touchEvent->touchPoints().first();
-if (touchPoint.isPrimary())
+if (touchPoint.isPrimary() || touchEvent->deviceType() == QTouchEvent::TouchPad)
 break;
 // fake a mouse event!
 QEvent::Type eventType = QEvent::None;
 switch (touchEvent->type()) {
 touchPoint.screenPos().toPoint(),
 Qt::LeftButton,
 Qt::LeftButton,
 touchEvent->modifiers());
 (void) QApplication::sendEvent(this, &mouseEvent);
+#endif // Q_WS_MAC
 break;
 }
 case QEvent::Gesture:
 event->ignore();
 break;
 \sa inputMethodQuery(), QInputContext
 */
 Qt::InputMethodHints QWidget::inputMethodHints() const
 {
 Q_D(const QWidget);
+#ifndef QT_NO_IM
 return d->imHints;
+#else //QT_NO_IM
+return 0;
+#endif //QT_NO_IM
 }
 void QWidget::setInputMethodHints(Qt::InputMethodHints hints)
 {
+#ifndef QT_NO_IM
 Q_D(QWidget);
 d->imHints = hints;
 // Optimisation to update input context only it has already been created.
 if (d->ic || qApp->d_func()->inputContext) {
 QInputContext *ic = inputContext();
 if (ic)
 ic->update();
 }
+#endif //QT_NO_IM
 }
 #ifndef QT_NO_DRAGANDDROP
 if (dx == 0 && dy == 0)
 return;
 Q_D(QWidget);
 #ifndef QT_NO_GRAPHICSVIEW
 if (QGraphicsProxyWidget *proxy = QWidgetPrivate::nearestGraphicsProxyWidget(this)) {
-	// Graphics View maintains its own dirty region as a list of rects;
+// Graphics View maintains its own dirty region as a list of rects;
-	// until we can connect item updates directly to the view, we must
+// until we can connect item updates directly to the view, we must
-	// separately add a translated dirty region.
+// separately add a translated dirty region.
-	if (!d->dirty.isEmpty()) {
+if (!d->dirty.isEmpty()) {
-	    foreach (const QRect &rect, (d->dirty.translated(dx, dy)).rects())
+foreach (const QRect &rect, (d->dirty.translated(dx, dy)).rects())
-		proxy->update(rect);
+proxy->update(rect);
-	}
+}
 proxy->scroll(dx, dy, proxy->subWidgetRect(this));
 return;
 }
 #endif
 d->setDirtyOpaqueRegion();
 if (dx == 0 && dy == 0)
 return;
 Q_D(QWidget);
 #ifndef QT_NO_GRAPHICSVIEW
 if (QGraphicsProxyWidget *proxy = QWidgetPrivate::nearestGraphicsProxyWidget(this)) {
-	// Graphics View maintains its own dirty region as a list of rects;
+// Graphics View maintains its own dirty region as a list of rects;
-	// until we can connect item updates directly to the view, we must
+// until we can connect item updates directly to the view, we must
-	// separately add a translated dirty region.
+// separately add a translated dirty region.
-	if (!d->dirty.isEmpty()) {
+if (!d->dirty.isEmpty()) {
-	    foreach (const QRect &rect, (d->dirty.translated(dx, dy) & r).rects())
+foreach (const QRect &rect, (d->dirty.translated(dx, dy) & r).rects())
-		proxy->update(rect);
+proxy->update(rect);
-	}
+}
 proxy->scroll(dx, dy, r.translated(proxy->subWidgetRect(this).topLeft().toPoint()));
 return;
 }
 #endif
 d->scroll_sys(dx, dy, r);
 case Qt::WA_MouseTracking: {
 QEvent e(QEvent::MouseTrackingChange);
 QApplication::sendEvent(this, &e);
 break; }
 case Qt::WA_NativeWindow: {
+#ifndef QT_NO_IM
+QWidget *focusWidget = d->effectiveFocusWidget();
 QInputContext *ic = 0;
 if (on && !internalWinId() && testAttribute(Qt::WA_InputMethodEnabled) && hasFocus()) {
-ic = d->inputContext();
+ic = focusWidget->d_func()->inputContext();
 ic->reset();
 ic->setFocusWidget(0);
 }
 if (!qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings) && parentWidget())
 parentWidget()->d_func()->enforceNativeChildren();
 if (on && !internalWinId() && testAttribute(Qt::WA_WState_Created))
 d->createWinId();
 if (ic && isEnabled())
-ic->setFocusWidget(this);
+ic->setFocusWidget(focusWidget);
+#endif //QT_NO_IM
 break;
 }
 case Qt::WA_PaintOnScreen:
 d->updateIsOpaque();
 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
 #ifdef Q_WS_MAC
 d->macUpdateIgnoreMouseEvents();
 #endif
 break;
 case Qt::WA_InputMethodEnabled: {
-QInputContext *ic = d->ic;
+#ifndef QT_NO_IM
+QWidget *focusWidget = d->effectiveFocusWidget();
+QInputContext *ic = focusWidget->d_func()->ic;
 if (!ic && (!on || hasFocus()))
-ic = d->inputContext();
+ic = focusWidget->d_func()->inputContext();
 if (ic) {
-if (on && hasFocus() && ic->focusWidget() != this && isEnabled()) {
+if (on && hasFocus() && ic->focusWidget() != focusWidget && isEnabled()) {
-ic->setFocusWidget(this);
+ic->setFocusWidget(focusWidget);
-} else if (!on && ic->focusWidget() == this) {
+} else if (!on && ic->focusWidget() == focusWidget) {
 ic->reset();
 ic->setFocusWidget(0);
 }
 }
+#endif //QT_NO_IM
 break;
 }
 case Qt::WA_WindowPropagation:
 d->resolvePalette();
 d->resolveFont();
 The largest allowed size for a widget is QSize(QWIDGETSIZE_MAX,
 QWIDGETSIZE_MAX), i.e. QSize (16777215,16777215).
 \sa QWidget::setMaximumSize()
+*/
+/*!
+\fn QWidget::setupUi(QWidget *widget)
+Sets up the user interface for the specified \a widget.
+\note This function is available with widgets that derive from user
+interface descriptions created using \l{uic}.
+\sa {Using a Designer UI File in Your Application}
 */
 QRect QWidgetPrivate::frameStrut() const
 {
 Q_Q(const QWidget);
 Synonym for QList<QWidget *>.
 */
 /*!
-Subscribes the widget to a given \a gesture with a \a context.
+Subscribes the widget to a given \a gesture with specific \a flags.
-\sa QGestureEvent
+\sa ungrabGesture(), QGestureEvent
 \since 4.6
 */
-void QWidget::grabGesture(Qt::GestureType gesture, Qt::GestureContext context)
+void QWidget::grabGesture(Qt::GestureType gesture, Qt::GestureFlags flags)
 {
 Q_D(QWidget);
-d->gestureContext.insert(gesture, context);
+d->gestureContext.insert(gesture, flags);
 (void)QGestureManager::instance(); // create a gesture manager
 }
-QT_END_NAMESPACE
+/*!
+Unsubscribes the widget from a given \a gesture type
-#include "moc_qwidget.cpp"
+\sa grabGesture(), QGestureEvent
+\since 4.6
+*/
+void QWidget::ungrabGesture(Qt::GestureType gesture)
+{
+Q_D(QWidget);
+if (d->gestureContext.remove(gesture)) {
+QGestureManager *manager = QGestureManager::instance();
+manager->cleanupCachedGestures(this, gesture);
+}
+}
 /*!
 \typedef WId
 \relates QWidget
 Note that only visible widgets can grab mouse input. If
 isVisible() returns false for a widget, that widget cannot call
 grabMouse().
-\sa releaseMouse() grabKeyboard() releaseKeyboard() grabKeyboard()
+\sa releaseMouse() grabKeyboard() releaseKeyboard()
-focusWidget()
 */
 /*!
 \fn void QWidget::grabMouse(const QCursor &cursor)
 \overload
 void QWidgetPrivate::_q_delayedDestroy(WId winId)
 {
 delete winId;
 }
 #endif
+QT_END_NAMESPACE
+#include "moc_qwidget.cpp"

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7
child 7	f7bc934e204c
child 18	2f34d5167611