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

equal deleted inserted replaced

-:93b982ccede2
+:5daf16870df6
 #elif defined(Q_WS_WIN)
 , noPaintOnScreen(0)
 , nativeGesturePanEnabled(0)
 #elif defined(Q_WS_MAC)
 , needWindowChange(0)
+, hasAlienChildren(0)
 , window_event(0)
 , qd_hd(0)
 #endif
 {
 if (!qApp) {
 if (version != QObjectPrivateVersion)
 qFatal("Cannot mix incompatible Qt libraries");
 isWidget = true;
 memset(high_attributes, 0, sizeof(high_attributes));
+#if QT_MAC_USE_COCOA
+drawRectOriginalAdded = false;
+originalDrawMethod = true;
+changeMethods = false;
+#endif // QT_MAC_USE_COCOA
 #ifdef QWIDGET_EXTRA_DEBUG
 static int count = 0;
 qDebug() << "widgets" << ++count;
 #endif
 }
 Q_Q(QWidget);
 if (QApplication::type() == QApplication::Tty)
 qFatal("QWidget: Cannot create a QWidget when no GUI is being used");
 Q_ASSERT(allWidgets);
-allWidgets->insert(q);
+if (allWidgets)
+allWidgets->insert(q);
 QWidget *desktopWidget = 0;
 if (parentWidget && parentWidget->windowType() == Qt::Desktop) {
 desktopWidget = parentWidget;
 parentWidget = 0;
 data.in_destructor = false;
 // Widgets with Qt::MSWindowsOwnDC (typically QGLWidget) must have a window handle.
 if (f & Qt::MSWindowsOwnDC)
 q->setAttribute(Qt::WA_NativeWindow);
+#ifdef Q_WS_MAC
+q->setAttribute(Qt::WA_NativeWindow);
+#endif
 q->setAttribute(Qt::WA_QuitOnClose); // might be cleared in adjustQuitOnCloseAttribute()
 adjustQuitOnCloseAttribute();
 q->setAttribute(Qt::WA_WState_Hidden);
 type = Qt::Window;
 flags |= Qt::Window;
 }
 if (QWidget *parent = parentWidget()) {
+#ifdef Q_WS_MAC
+if (testAttribute(Qt::WA_NativeWindow) == false)
+parent->d_func()->hasAlienChildren = true;
+#endif
 if (type & Qt::Window) {
 if (!parent->testAttribute(Qt::WA_WState_Created))
 parent->createWinId();
 } else if (testAttribute(Qt::WA_NativeWindow) && !parent->internalWinId()
 && !testAttribute(Qt::WA_DontCreateNativeAncestors)) {
 #if defined (QT_CHECK_STATE)
 if (paintingActive())
 qWarning("QWidget: %s (%s) deleted while being painted", className(), name());
 #endif
+foreach (Qt::GestureType type, d->gestureContext.keys())
+ungrabGesture(type);
 // force acceptDrops false before winId is destroyed.
 d->registerDropSite(false);
 #ifndef QT_NO_ACTION
 // remove all actions from this widget
 // and if that also doesn't work, then give up
 }
 }
 }
-#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_MAC)
 else if (!internalWinId() && isVisible()) {
 qApp->d_func()->sendSyntheticEnterLeave(this);
 #ifdef Q_WS_QWS
 } else if (isVisible()) {
 qApp->d_func()->sendSyntheticEnterLeave(this);
 // set all QPointers for this object to zero
 QObjectPrivate::clearGuards(this);
 if (d->declarativeData) {
-d->declarativeData->destroyed(this);
+QAbstractDeclarativeData::destroyed(d->declarativeData, this);
 d->declarativeData = 0;                 // don't activate again in ~QObject
 }
+#ifdef QT_MAC_USE_COCOA
+// QCocoaView holds a pointer back to this widget. Clear it now
+// to make sure it's not followed later on. The lifetime of the
+// QCocoaView might exceed the lifetime of this widget in cases
+// where Cocoa itself holds references to it.
+extern void qt_mac_clearCocoaViewQWidgetPointers(QWidget *);
+qt_mac_clearCocoaViewQWidgetPointers(this);
+#endif
 if (!d->children.isEmpty())
 d->deleteChildren();
 QApplication::removePostedEvents(this);
 x->posFromMove = false;
 x->sizeAdjusted = false;
 x->inTopLevelResize = false;
 x->inRepaint = false;
 x->embedded = 0;
+#ifdef Q_WS_MAC
+#ifdef QT_MAC_USE_COCOA
+x->wasMaximized = false;
+#endif // QT_MAC_USE_COCOA
+#endif // Q_WS_MAC
 createTLSysExtra();
 #ifdef QWIDGET_EXTRA_DEBUG
 static int count = 0;
 qDebug() << "tlextra" << ++count;
 #endif
 \sa find()
 */
 WId QWidget::winId() const
 {
 if (!testAttribute(Qt::WA_WState_Created) || !internalWinId()) {
+#ifdef ALIEN_DEBUG
+qDebug() << "QWidget::winId: creating native window for" << this;
+#endif
 QWidget *that = const_cast<QWidget*>(this);
 that->setAttribute(Qt::WA_NativeWindow);
 that->d_func()->createWinId();
 return that->data->winid;
 }
 void QWidgetPrivate::createWinId(WId winid)
 {
 Q_Q(QWidget);
+#ifdef ALIEN_DEBUG
+qDebug() << "QWidgetPrivate::createWinId for" << q << winid;
+#endif
 const bool forceNativeWindow = q->testAttribute(Qt::WA_NativeWindow);
 if (!q->testAttribute(Qt::WA_WState_Created) || (forceNativeWindow && !q->internalWinId())) {
 if (!q->isWindow()) {
 QWidget *parent = q->parentWidget();
 QWidgetPrivate *pd = parent->d_func();
 */
 void QWidget::createWinId()
 {
 Q_D(QWidget);
+#ifdef ALIEN_DEBUG
+qDebug()  << "QWidget::createWinId" << this;
+#endif
 //    qWarning("QWidget::createWinId is obsolete, please fix your code.");
 d->createWinId();
 }
 /*!
 )
 {
 Q_Q(QWidget);
 QStyle *oldStyle  = q->style();
 #ifndef QT_NO_STYLE_STYLESHEET
-QStyle *origStyle = 0;
+QWeakPointer<QStyle> origStyle;
 #endif
 #ifdef Q_WS_MAC
 // the metalhack boolean allows Qt/Mac to do a proper re-polish depending
 // on how the Qt::WA_MacBrushedMetal attribute is set. It is only ever
 #endif
 {
 createExtra();
 #ifndef QT_NO_STYLE_STYLESHEET
-origStyle = extra->style;
+origStyle = extra->style.data();
 #endif
 extra->style = newStyle;
 }
 // repolish
 if (c)
 c->d_func()->inheritStyle();
 }
 }
+#ifndef QT_NO_STYLE_STYLESHEET
+if (!qobject_cast<QStyleSheetStyle*>(newStyle)) {
+if (const QStyleSheetStyle* cssStyle = qobject_cast<QStyleSheetStyle*>(origStyle.data())) {
+cssStyle->clearWidgetFont(q);
+}
+}
+#endif
 QEvent e(QEvent::StyleChange);
 QApplication::sendEvent(q, &e);
 #ifdef QT3_SUPPORT
 q->styleChange(*oldStyle);
 #endif
 #ifndef QT_NO_STYLE_STYLESHEET
-if (!qobject_cast<QStyleSheetStyle*>(newStyle)) {
-if (const QStyleSheetStyle* cssStyle = qobject_cast<QStyleSheetStyle*>(origStyle)) {
-cssStyle->clearWidgetFont(q);
-}
-}
-#endif
-#ifndef QT_NO_STYLE_STYLESHEET
 // dereference the old stylesheet style
-if (QStyleSheetStyle *proxy = qobject_cast<QStyleSheetStyle *>(origStyle))
+if (QStyleSheetStyle *proxy = qobject_cast<QStyleSheetStyle *>(origStyle.data()))
 proxy->deref();
 #endif
 }
 // Inherits style from the current parent and propagates it as necessary
 or QGLWidget::renderPixmap() instead.
 */
 void QWidget::render(QPaintDevice *target, const QPoint &targetOffset,
 const QRegion &sourceRegion, RenderFlags renderFlags)
 {
-Q_D(QWidget);
+d_func()->render(target, targetOffset, sourceRegion, renderFlags, false);
-if (!target) {
-qWarning("QWidget::render: null pointer to paint device");
-return;
-}
-const bool inRenderWithPainter = d->extra && d->extra->inRenderWithPainter;
-QRegion paintRegion = !inRenderWithPainter ? d->prepareToRender(sourceRegion, renderFlags)
-: sourceRegion;
-if (paintRegion.isEmpty())
-return;
-#ifndef Q_WS_MAC
-QPainter *oldSharedPainter = inRenderWithPainter ? d->sharedPainter() : 0;
-// Use the target's shared painter if set (typically set when doing
-// "other->render(widget);" in the widget's paintEvent.
-if (target->devType() == QInternal::Widget) {
-QWidgetPrivate *targetPrivate = static_cast<QWidget *>(target)->d_func();
-if (targetPrivate->extra && targetPrivate->extra->inRenderWithPainter) {
-QPainter *targetPainter = targetPrivate->sharedPainter();
-if (targetPainter && targetPainter->isActive())
-d->setSharedPainter(targetPainter);
-}
-}
-#endif
-// Use the target's redirected device if set and adjust offset and paint
-// region accordingly. This is typically the case when people call render
-// from the paintEvent.
-QPoint offset = targetOffset;
-offset -= paintRegion.boundingRect().topLeft();
-QPoint redirectionOffset;
-QPaintDevice *redirected = 0;
-if (target->devType() == QInternal::Widget)
-redirected = static_cast<QWidget *>(target)->d_func()->redirected(&redirectionOffset);
-if (!redirected)
-redirected = QPainter::redirected(target, &redirectionOffset);
-if (redirected) {
-target = redirected;
-offset -= redirectionOffset;
-}
-if (!inRenderWithPainter) { // Clip handled by shared painter (in qpainter.cpp).
-if (QPaintEngine *targetEngine = target->paintEngine()) {
-const QRegion targetSystemClip = targetEngine->systemClip();
-if (!targetSystemClip.isEmpty())
-paintRegion &= targetSystemClip.translated(-offset);
-}
-}
-// Set backingstore flags.
-int flags = QWidgetPrivate::DrawPaintOnScreen | QWidgetPrivate::DrawInvisible;
-if (renderFlags & DrawWindowBackground)
-flags |= QWidgetPrivate::DrawAsRoot;
-if (renderFlags & DrawChildren)
-flags |= QWidgetPrivate::DrawRecursive;
-else
-flags |= QWidgetPrivate::DontSubtractOpaqueChildren;
-#ifdef Q_WS_QWS
-flags |= QWidgetPrivate::DontSetCompositionMode;
-#endif
-if (target->devType() == QInternal::Printer) {
-QPainter p(target);
-d->render_helper(&p, targetOffset, paintRegion, renderFlags);
-return;
-}
-#ifndef Q_WS_MAC
-// Render via backingstore.
-d->drawWidget(target, paintRegion, offset, flags, d->sharedPainter());
-// Restore shared painter.
-if (oldSharedPainter)
-d->setSharedPainter(oldSharedPainter);
-#else
-// Render via backingstore (no shared painter).
-d->drawWidget(target, paintRegion, offset, flags, 0);
-#endif
 }
 /*!
 \overload
 bool flushed = QWidgetBackingStore::flushPaint(q, toBePainted);
 #endif
 QPaintEngine *paintEngine = pdev->paintEngine();
 if (paintEngine) {
 setRedirected(pdev, -offset);
+#ifdef Q_WS_MAC
+// (Alien support) Special case for Mac when redirecting: If the paint device
+// is of the Widget type we need to set WA_WState_InPaintEvent since painting
+// outside the paint event is not supported on QWidgets. The attributeis
+// restored further down.
+if (pdev->devType() == QInternal::Widget)
+static_cast<QWidget *>(pdev)->setAttribute(Qt::WA_WState_InPaintEvent);
+#endif
 if (sharedPainter)
 paintEngine->d_func()->systemClip = toBePainted;
 else
 paintEngine->d_func()->systemRect = q->data->crect;
 backingStore->markDirtyOnScreen(toBePainted, q, offset);
 #endif
 //restore
 if (paintEngine) {
+#ifdef Q_WS_MAC
+if (pdev->devType() == QInternal::Widget)
+static_cast<QWidget *>(pdev)->setAttribute(Qt::WA_WState_InPaintEvent, false);
+#endif
 restoreRedirected();
 if (!sharedPainter)
 paintEngine->d_func()->systemRect = QRect();
 else
 paintEngine->d_func()->currentClipWidget = 0;
 #ifdef Q_BACKINGSTORE_SUBSURFACES
 , q->windowSurface()
 #endif
 , sharedPainter, backingStore);
 }
+}
+void QWidgetPrivate::render(QPaintDevice *target, const QPoint &targetOffset,
+const QRegion &sourceRegion, QWidget::RenderFlags renderFlags,
+bool readyToRender)
+{
+if (!target) {
+qWarning("QWidget::render: null pointer to paint device");
+return;
+}
+const bool inRenderWithPainter = extra && extra->inRenderWithPainter;
+QRegion paintRegion = !inRenderWithPainter && !readyToRender
+? prepareToRender(sourceRegion, renderFlags)
+: sourceRegion;
+if (paintRegion.isEmpty())
+return;
+#ifndef Q_WS_MAC
+QPainter *oldSharedPainter = inRenderWithPainter ? sharedPainter() : 0;
+// Use the target's shared painter if set (typically set when doing
+// "other->render(widget);" in the widget's paintEvent.
+if (target->devType() == QInternal::Widget) {
+QWidgetPrivate *targetPrivate = static_cast<QWidget *>(target)->d_func();
+if (targetPrivate->extra && targetPrivate->extra->inRenderWithPainter) {
+QPainter *targetPainter = targetPrivate->sharedPainter();
+if (targetPainter && targetPainter->isActive())
+setSharedPainter(targetPainter);
+}
+}
+#endif
+// Use the target's redirected device if set and adjust offset and paint
+// region accordingly. This is typically the case when people call render
+// from the paintEvent.
+QPoint offset = targetOffset;
+offset -= paintRegion.boundingRect().topLeft();
+QPoint redirectionOffset;
+QPaintDevice *redirected = 0;
+if (target->devType() == QInternal::Widget)
+redirected = static_cast<QWidget *>(target)->d_func()->redirected(&redirectionOffset);
+if (!redirected)
+redirected = QPainter::redirected(target, &redirectionOffset);
+if (redirected) {
+target = redirected;
+offset -= redirectionOffset;
+}
+if (!inRenderWithPainter) { // Clip handled by shared painter (in qpainter.cpp).
+if (QPaintEngine *targetEngine = target->paintEngine()) {
+const QRegion targetSystemClip = targetEngine->systemClip();
+if (!targetSystemClip.isEmpty())
+paintRegion &= targetSystemClip.translated(-offset);
+}
+}
+// Set backingstore flags.
+int flags = DrawPaintOnScreen | DrawInvisible;
+if (renderFlags & QWidget::DrawWindowBackground)
+flags |= DrawAsRoot;
+if (renderFlags & QWidget::DrawChildren)
+flags |= DrawRecursive;
+else
+flags |= DontSubtractOpaqueChildren;
+#ifdef Q_WS_QWS
+flags |= DontSetCompositionMode;
+#endif
+if (target->devType() == QInternal::Printer) {
+QPainter p(target);
+render_helper(&p, targetOffset, paintRegion, renderFlags);
+return;
+}
+#ifndef Q_WS_MAC
+// Render via backingstore.
+drawWidget(target, paintRegion, offset, flags, sharedPainter());
+// Restore shared painter.
+if (oldSharedPainter)
+setSharedPainter(oldSharedPainter);
+#else
+// Render via backingstore (no shared painter).
+drawWidget(target, paintRegion, offset, flags, 0);
+#endif
 }
 void QWidgetPrivate::paintSiblingsRecursive(QPaintDevice *pdev, const QObjectList& siblings, int index, const QRegion &rgn,
 const QPoint &offset, int flags
 #ifdef Q_BACKINGSTORE_SUBSURFACES
 const QTransform &painterTransform = context->painter->worldTransform();
 sourceRect = painterTransform.mapRect(sourceRect);
 pixmapOffset = painterTransform.map(pixmapOffset);
 }
 QRect effectRect;
-if (mode == QGraphicsEffect::PadToEffectiveBoundingRect) {
+if (mode == QGraphicsEffect::PadToEffectiveBoundingRect)
 effectRect = m_widget->graphicsEffect()->boundingRectFor(sourceRect).toAlignedRect();
+else if (mode == QGraphicsEffect::PadToTransparentBorder)
-} else if (mode == QGraphicsEffect::PadToTransparentBorder) {
 effectRect = sourceRect.adjusted(-1, -1, 1, 1).toAlignedRect();
+else
-} else {
 effectRect = sourceRect.toAlignedRect();
-}
 if (offset)
 *offset = effectRect.topLeft();
-if (deviceCoordinates) {
-// Clip to device rect.
-int left, top, right, bottom;
-effectRect.getCoords(&left, &top, &right, &bottom);
-if (left < 0) {
-if (offset)
-offset->rx() += -left;
-effectRect.setX(0);
-}
-if (top < 0) {
-if (offset)
-offset->ry() += -top;
-effectRect.setY(0);
-}
-// NB! We use +-1 for historical reasons (see QRect documentation).
-QPaintDevice *device = context->painter->device();
-const int deviceWidth = device->width();
-const int deviceHeight = device->height();
-if (right + 1 > deviceWidth)
-effectRect.setRight(deviceWidth - 1);
-if (bottom + 1 > deviceHeight)
-effectRect.setBottom(deviceHeight -1);
-}
 pixmapOffset -= effectRect.topLeft();
 QPixmap pixmap(effectRect.size());
 pixmap.fill(Qt::transparent);
-m_widget->render(&pixmap, pixmapOffset);
+m_widget->render(&pixmap, pixmapOffset, QRegion(), QWidget::DrawChildren);
 return pixmap;
 }
 #endif //QT_NO_GRAPHICSEFFECT
 #ifndef QT_NO_GRAPHICSVIEW
 QApplication::sendEvent(previousProxyFocus, &event);
 if (that)
 QApplication::sendEvent(that->style(), &event);
 }
 if (!isHidden()) {
+#ifndef QT_NO_GRAPHICSVIEW
+// Update proxy state
+if (QWExtra *topData = window()->d_func()->extra)
+if (topData->proxyWidget && topData->proxyWidget->hasFocus())
+topData->proxyWidget->d_func()->updateProxyInputMethodAcceptanceFromWidget();
+#endif
 // Send event to self
 QFocusEvent event(QEvent::FocusIn, reason);
 QPointer<QWidget> that = f;
 QApplication::sendEvent(f, &event);
 if (that)
 second = sp;
 //    QWidget *fp = first->d_func()->focus_prev;
 QWidget *fn = first->d_func()->focus_next;
-if (fn == second)
+if (fn == second || first == second)
 return;
 QWidget *sp = second->d_func()->focus_prev;
 QWidget *sn = second->d_func()->focus_next;
 \sa restoreGeometry(), QMainWindow::saveState(), QMainWindow::restoreState()
 */
 QByteArray QWidget::saveGeometry() const
 {
+#ifdef QT_MAC_USE_COCOA
+// We check if the window was maximized during this invocation. If so, we need to record the
+// starting position as 0,0.
+Q_D(const QWidget);
+QRect newFramePosition = frameGeometry();
+QRect newNormalPosition = normalGeometry();
+if(d->topData()->wasMaximized && !(windowState() & Qt::WindowMaximized)) {
+// Change the starting position
+newFramePosition.moveTo(0, 0);
+newNormalPosition.moveTo(0, 0);
+}
+#endif // QT_MAC_USE_COCOA
 QByteArray array;
 QDataStream stream(&array, QIODevice::WriteOnly);
 stream.setVersion(QDataStream::Qt_4_0);
 const quint32 magicNumber = 0x1D9D0CB;
 quint16 majorVersion = 1;
 quint16 minorVersion = 0;
 stream << magicNumber
 << majorVersion
 << minorVersion
+#ifdef QT_MAC_USE_COCOA
+<< newFramePosition
+<< newNormalPosition
+#else
 << frameGeometry()
 << normalGeometry()
+#endif // QT_MAC_USE_COCOA
 << qint32(QApplication::desktop()->screenNumber(this))
 << quint8(windowState() & Qt::WindowMaximized)
 << quint8(windowState() & Qt::WindowFullScreen);
 return array;
 }
 {
 Q_Q(QWidget);
 bool isEmbedded = false;
 #if !defined QT_NO_GRAPHICSVIEW
-isEmbedded = q->isWindow() && nearestGraphicsProxyWidget(q->parentWidget()) != 0;
+isEmbedded = q->isWindow() && !bypassGraphicsProxyWidget(q) && nearestGraphicsProxyWidget(q->parentWidget()) != 0;
 #else
 Q_UNUSED(isEmbedded);
 #endif
 if (!isEmbedded && (q->windowType() == Qt::Popup))
 hideChildren(false);
 // next bit tries to move the focus if the focus widget is now
 // hidden.
 if (wasVisible) {
-#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_MAC)
 qApp->d_func()->sendSyntheticEnterLeave(q);
 #endif
 QWidget *fw = QApplication::focusWidget();
 while (fw &&  !fw->isWindow()) {
 // remove posted quit events when showing a new window
 QCoreApplication::removePostedEvents(qApp, QEvent::Quit);
 d->show_helper();
-#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_MAC)
 qApp->d_func()->sendSyntheticEnterLeave(this);
 #endif
 }
 QEvent showToParentEvent(QEvent::ShowToParent);
 // hide_sys() on an ancestor won't have any affect on this
 // widget, so it needs an explicit hide_sys() of its own
 widget->d_func()->hide_sys();
 }
 }
-#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined (Q_WS_QWS) || defined(Q_WS_MAC)
 qApp->d_func()->sendSyntheticEnterLeave(widget);
 #endif
 #ifndef QT_NO_ACCESSIBILITY
 if (!spontaneous)
 QAccessible::updateAccessibility(widget, 0, QAccessible::ObjectHide);
 #ifdef QT3_SUPPORT
 if (isMain)
 QApplication::quit();
 #endif
-// Attempt to close the application only if this widget has the
+// Attempt to close the application only if this has WA_QuitOnClose set and a non-visible parent
-// WA_QuitOnClose flag set set and has a non-visible parent
+quitOnClose = quitOnClose && (parentWidget.isNull() || !parentWidget->isVisible());
-quitOnClose = quitOnClose && (parentWidget.isNull() || !parentWidget->isVisible() || parentWidget->testAttribute(Qt::WA_DontShowOnScreen));
 if (quitOnClose) {
-// If there is no non-withdrawn primary window left (except
+/* if there is no non-withdrawn primary window left (except
-// the ones without QuitOnClose or with WA_DontShowOnScreen),
+the ones without QuitOnClose), we emit the lastWindowClosed
-// we emit the lastWindowClosed signal
+signal */
 QWidgetList list = QApplication::topLevelWidgets();
 bool lastWindowClosed = true;
 for (int i = 0; i < list.size(); ++i) {
 QWidget *w = list.at(i);
-if ((w->isVisible() && !w->testAttribute(Qt::WA_DontShowOnScreen))
+if (!w->isVisible() || w->parentWidget() || !w->testAttribute(Qt::WA_QuitOnClose))
-&& !w->parentWidget() && w->testAttribute(Qt::WA_QuitOnClose)) {
+continue;
 lastWindowClosed = false;
 break;
-}
 }
 if (lastWindowClosed)
 QApplicationPrivate::emitLastWindowClosed();
 }
 QWidget *desktopWidget = 0;
 if (parent && parent->windowType() == Qt::Desktop)
 desktopWidget = parent;
 bool newParent = (parent != parentWidget()) || !wasCreated || desktopWidget;
-#if defined(Q_WS_X11) || defined(Q_WS_WIN)
+#if defined(Q_WS_X11) || defined(Q_WS_WIN) || defined(Q_WS_MAC)
 if (newParent && parent && !desktopWidget) {
 if (testAttribute(Qt::WA_NativeWindow) && !qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings))
 parent->d_func()->enforceNativeChildren();
 else if (parent->d_func()->nativeChildrenForced() || parent->testAttribute(Qt::WA_PaintOnScreen))
 setAttribute(Qt::WA_NativeWindow);
 return (d->extra && d->extra->topextra) ? d->extra->topextra->iconPixmap : 0;
 }
 #endif // QT3_SUPPORT
 /*!
-Sets the attribute \a attribute on this widget if \a on is true;
+\internal
-otherwise clears the attribute.
+This just sets the corresponding attribute bit to 1 or 0
-\sa testAttribute()
+*/
-*/
+static void setAttribute_internal(Qt::WidgetAttribute attribute, bool on, QWidgetData *data,
-void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
+QWidgetPrivate *d)
 {
-if (testAttribute(attribute) == on)
-return;
-Q_D(QWidget);
-Q_ASSERT_X(sizeof(d->high_attributes)*8 >= (Qt::WA_AttributeCount - sizeof(uint)*8),
-"QWidget::setAttribute(WidgetAttribute, bool)",
-"QWidgetPrivate::high_attributes[] too small to contain all attributes in WidgetAttribute");
-#ifdef Q_WS_WIN
-// ### Don't use PaintOnScreen+paintEngine() to do native painting in 5.0
-if (attribute == Qt::WA_PaintOnScreen && on && !inherits("QGLWidget")) {
-// see qwidget_win.cpp, ::paintEngine for details
-paintEngine();
-if (d->noPaintOnScreen)
-return;
-}
-#endif
 if (attribute < int(8*sizeof(uint))) {
 if (on)
 data->widget_attributes |= (1<<attribute);
 else
 data->widget_attributes &= ~(1<<attribute);
 if (on)
 d->high_attributes[int_off] |= (1<<(x-(int_off*8*sizeof(uint))));
 else
 d->high_attributes[int_off] &= ~(1<<(x-(int_off*8*sizeof(uint))));
 }
+}
+/*!
+Sets the attribute \a attribute on this widget if \a on is true;
+otherwise clears the attribute.
+\sa testAttribute()
+*/
+void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
+{
+if (testAttribute(attribute) == on)
+return;
+Q_D(QWidget);
+Q_ASSERT_X(sizeof(d->high_attributes)*8 >= (Qt::WA_AttributeCount - sizeof(uint)*8),
+"QWidget::setAttribute(WidgetAttribute, bool)",
+"QWidgetPrivate::high_attributes[] too small to contain all attributes in WidgetAttribute");
+#ifdef Q_WS_WIN
+// ### Don't use PaintOnScreen+paintEngine() to do native painting in 5.0
+if (attribute == Qt::WA_PaintOnScreen && on && !inherits("QGLWidget")) {
+// see qwidget_win.cpp, ::paintEngine for details
+paintEngine();
+if (d->noPaintOnScreen)
+return;
+}
+#endif
+setAttribute_internal(attribute, on, data, d);
 switch (attribute) {
 #ifndef QT_NO_DRAGANDDROP
 case Qt::WA_AcceptDrops:  {
 case Qt::WA_MacSmallSize:
 case Qt::WA_MacMiniSize:
 #ifdef Q_WS_MAC
 {
 // We can only have one of these set at a time
-static const int MacSizes[] = { Qt::WA_MacNormalSize, Qt::WA_MacSmallSize,
+const Qt::WidgetAttribute MacSizes[] = { Qt::WA_MacNormalSize, Qt::WA_MacSmallSize,
-Qt::WA_MacMiniSize, 0 };
+Qt::WA_MacMiniSize };
-for (int i = 0; MacSizes[i] != 0; ++i) {
+for (int i = 0; i < 3; ++i) {
-if (MacSizes[i] == attribute)
+if (MacSizes[i] != attribute)
-continue;
+setAttribute_internal(MacSizes[i], false, data, d);
-int macsize_x = MacSizes[i] - 8*sizeof(uint);
-int macsize_int_off = macsize_x / (8*sizeof(uint));
-d->high_attributes[macsize_int_off] &= ~(1<<(macsize_x-(macsize_int_off*8*sizeof(uint))));
 }
 d->macUpdateSizeAttribute();
 }
 #endif
 break;
 #endif //QT_NO_IM
 break;
 }
 case Qt::WA_PaintOnScreen:
 d->updateIsOpaque();
-#if defined(Q_WS_WIN) || defined(Q_WS_X11)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined(Q_WS_MAC)
 // Recreate the widget if it's already created as an alien widget and
 // WA_PaintOnScreen is enabled. Paint on screen widgets must have win id.
 // So must their children.
 if (on) {
 setAttribute(Qt::WA_NativeWindow);
 d->createExtra();
 d->extra->compress_events = on;
 break;
 case Qt::WA_X11OpenGLOverlay:
 d->updateIsOpaque();
+break;
+case Qt::WA_X11DoNotAcceptFocus:
+if (testAttribute(Qt::WA_WState_Created))
+d->updateX11AcceptFocus();
 break;
 #endif
 case Qt::WA_DontShowOnScreen: {
 if (on && isVisible()) {
 // Make sure we keep the current state and only hide the widget
 {
 delete winId;
 }
 #endif
+#if QT_MAC_USE_COCOA
+void QWidgetPrivate::syncUnifiedMode() {
+// The whole purpose of this method is to keep the unifiedToolbar in sync.
+// That means making sure we either exchange the drawing methods or we let
+// the toolbar know that it does not require to draw the baseline.
+Q_Q(QWidget);
+// This function makes sense only if this is a top level
+if(!q->isWindow())
+return;
+OSWindowRef window = qt_mac_window_for(q);
+if(changeMethods) {
+// Ok, we are in documentMode.
+if(originalDrawMethod)
+qt_mac_replaceDrawRect(window, this);
+} else {
+if(!originalDrawMethod)
+qt_mac_replaceDrawRectOriginal(window, this);
+}
+}
+#endif // QT_MAC_USE_COCOA
 QT_END_NAMESPACE
 #include "moc_qwidget.cpp"

branch	GCC_SURGE
changeset 31	5daf16870df6
parent 30	5dc02b23752f
child 33	3e2da88830cd