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

equal deleted inserted replaced

-:93b982ccede2
+:5daf16870df6
 #endif
 }
 bool qt_isGenuineQWidget(const QWidget *window)
 {
-return window && qt_isGenuineQWidget(OSViewRef(window->winId()));
+if (!window)
+return false;
+if (!window->internalWinId())
+return true;  //alien
+return qt_isGenuineQWidget(OSViewRef(window->internalWinId()));
 }
 Q_GUI_EXPORT OSWindowRef qt_mac_window_for(const QWidget *w)
 {
 OSViewRef hiview = qt_mac_nativeview_for(w);
 wclass = kDrawerWindowClass;
 else if (q->testAttribute(Qt::WA_ShowModal) && flags & Qt::CustomizeWindowHint)
 wclass = kDocumentWindowClass;
 else if(popup || (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_5 && type == Qt::SplashScreen))
 wclass = kModalWindowClass;
-else if(q->testAttribute(Qt::WA_ShowModal) || type == Qt::Dialog)
+else if(type == Qt::Dialog)
 wclass = kMovableModalWindowClass;
 else if(type == Qt::ToolTip)
 wclass = kHelpWindowClass;
 else if(type == Qt::Tool || (QSysInfo::MacintoshVersion < QSysInfo::MV_10_5
 && type == Qt::SplashScreen))
 wclass = kFloatingWindowClass;
+else if(q->testAttribute(Qt::WA_ShowModal))
+wclass = kMovableModalWindowClass;
 else
 wclass = kDocumentWindowClass;
 WindowAttributes wattr = NSBorderlessWindowMask;
 if(qt_mac_is_macsheet(q)) {
 WindowAttributes tmp_wattr = wattr;
 qDebug("Qt: internal: ** Attributes:");
 for(int i = 0; tmp_wattr && known_attribs[i].name; i++) {
 if((tmp_wattr & known_attribs[i].tag) == known_attribs[i].tag) {
 tmp_wattr ^= known_attribs[i].tag;
-qDebug("Qt: internal: * %s %s", known_attribs[i].name,
-(GetAvailableWindowAttributes(wclass) & known_attribs[i].tag) ? "" : "(*)");
 }
 }
 if(tmp_wattr)
 qDebug("Qt: internal: !! Attributes: Unknown (%d)", (int)tmp_wattr);
 }
 updateFrameStrut();
 qt_mac_update_sizer(q);
 applyMaxAndMinSizeOnWindow();
 }
 #else  // QT_MAC_USE_COCOA
+void QWidgetPrivate::setWindowLevel()
+{
+Q_Q(QWidget);
+const QWidget * const windowParent = q->window()->parentWidget();
+const QWidget * const primaryWindow = windowParent ? windowParent->window() : 0;
+NSInteger winLevel = -1;
+if (q->windowType() == Qt::Popup) {
+winLevel = NSPopUpMenuWindowLevel;
+// Popup should be in at least the same level as its parent.
+if (primaryWindow) {
+OSWindowRef parentRef = qt_mac_window_for(primaryWindow);
+winLevel = qMax([parentRef level], winLevel);
+}
+} else if (q->windowType() == Qt::Tool) {
+winLevel = NSFloatingWindowLevel;
+} else if (q->windowType() == Qt::Dialog) {
+// Correct modality level (NSModalPanelWindowLevel) will be
+// set by cocoa when creating a modal session later.
+winLevel = NSNormalWindowLevel;
+}
+// StayOnTop window should appear above Tool windows.
+if (data.window_flags & Qt::WindowStaysOnTopHint)
+winLevel = NSPopUpMenuWindowLevel;
+// Tooltips should appear above StayOnTop windows.
+if (q->windowType() == Qt::ToolTip)
+winLevel = NSScreenSaverWindowLevel;
+// All other types are Normal level.
+if (winLevel == -1)
+winLevel = NSNormalWindowLevel;
+[qt_mac_window_for(q) setLevel:winLevel];
+}
 void QWidgetPrivate::finishCreateWindow_sys_Cocoa(void * /*NSWindow * */ voidWindowRef)
 {
 Q_Q(QWidget);
 QMacCocoaAutoReleasePool pool;
 NSWindow *windowRef = static_cast<NSWindow *>(voidWindowRef);
 [nsview setFrame:bounds];
 [nsview setHidden:NO];
 if (q->testAttribute(Qt::WA_DropSiteRegistered))
 registerDropSite(true);
 transferChildren();
+// Tell Cocoa explicit that we wan't the view to receive key events
+// (regardless of focus policy) because this is how it works on other
+// platforms (and in the carbon port):
+if (!qApp->focusWidget())
+[windowRef makeFirstResponder:nsview];
 }
 if (topExtra->posFromMove) {
 updateFrameStrut();
 // make sure that we don't report a faulty opacity:
 q->setWindowOpacity(1.0f);
 q->setAttribute(Qt::WA_WState_WindowOpacitySet, false);
 }
+if (qApp->overrideCursor())
+[windowRef disableCursorRects];
+setWindowLevel();
 macUpdateHideOnSuspend();
 macUpdateOpaqueSizeGrip();
 macUpdateIgnoreMouseEvents();
 setWindowTitle_helper(extra->topextra->caption);
 setWindowIconText_helper(extra->topextra->iconText);
 #endif
 setWinId((WId)osview);
 }
 } else {
 data.fstrut_dirty = false; // non-toplevel widgets don't have a frame, so no need to update the strut
-if(OSViewRef osview = qt_mac_create_widget(q, this, qt_mac_nativeview_for(parentWidget))) {
+#ifdef QT_MAC_USE_COCOA
+if (q->testAttribute(Qt::WA_NativeWindow) == false ||
+q->internalWinId() != 0) {
+#ifdef ALIEN_DEBUG
+qDebug() << "Skipping native widget creation for" << this;
+#endif
+} else
+#endif
+if (OSViewRef osview = qt_mac_create_widget(q, this, qt_mac_nativeview_for(parentWidget))) {
 #ifndef QT_MAC_USE_COCOA
 HIRect bounds = CGRectMake(data.crect.x(), data.crect.y(), data.crect.width(), data.crect.height());
 HIViewSetFrame(osview, &bounds);
 setWinId((WId)osview);
 #else
 }
 }
 }
 }
+#ifdef QT_MAC_USE_COCOA
+void QWidgetPrivate::setSubWindowStacking(bool set)
+{
+Q_Q(QWidget);
+if (!q->isWindow() || !q->testAttribute(Qt::WA_WState_Created))
+return;
+if (QWidget *parent = q->parentWidget()) {
+if (parent->testAttribute(Qt::WA_WState_Created)) {
+if (set)
+[qt_mac_window_for(parent) addChildWindow:qt_mac_window_for(q) ordered:NSWindowAbove];
+else
+[qt_mac_window_for(parent) removeChildWindow:qt_mac_window_for(q)];
+}
+}
+QList<QWidget *> widgets = q->findChildren<QWidget *>();
+for (int i=0; i<widgets.size(); ++i) {
+QWidget *child = widgets.at(i);
+if (child->isWindow() && child->testAttribute(Qt::WA_WState_Created)) {
+if (set)
+[qt_mac_window_for(q) addChildWindow:qt_mac_window_for(child) ordered:NSWindowAbove];
+else
+[qt_mac_window_for(q) removeChildWindow:qt_mac_window_for(child)];
+}
+}
+}
+#endif
 void QWidgetPrivate::setParent_sys(QWidget *parent, Qt::WindowFlags f)
 {
 Q_Q(QWidget);
 QMacCocoaAutoReleasePool pool;
 QTLWExtra *topData = maybeTopData();
 if (q->testAttribute(Qt::WA_DropSiteRegistered))
 q->setAttribute(Qt::WA_DropSiteRegistered, false);
 //recreate and setup flags
 QObjectPrivate::setParent_helper(parent);
-QPoint pt = q->pos();
 bool explicitlyHidden = q->testAttribute(Qt::WA_WState_Hidden) && q->testAttribute(Qt::WA_WState_ExplicitShowHide);
 if (wasCreated && !qt_isGenuineQWidget(q))
 return;
-if ((data.window_flags & Qt::Sheet) && topData && topData->opacity == 242)
+if (!q->testAttribute(Qt::WA_WState_WindowOpacitySet)) {
 q->setWindowOpacity(1.0f);
+q->setAttribute(Qt::WA_WState_WindowOpacitySet, false);
+}
 setWinId(0); //do after the above because they may want the id
 data.window_flags = f;
 q->setAttribute(Qt::WA_WState_Created, false);
 q->setAttribute(Qt::WA_WState_Visible, false);
 q->setAttribute(Qt::WA_WState_Hidden, false);
 adjustFlags(data.window_flags, q);
-// keep compatibility with previous versions, we need to preserve the created state
+// keep compatibility with previous versions, we need to preserve the created state.
-// (but we recreate the winId for the widget being reparented, again for compatibility)
+// (but we recreate the winId for the widget being reparented, again for compatibility,
-if (wasCreated || (!q->isWindow() && parent->testAttribute(Qt::WA_WState_Created))) {
+// unless this is an alien widget. )
+const bool nonWindowWithCreatedParent = !q->isWindow() && parent->testAttribute(Qt::WA_WState_Created);
+const bool nativeWidget = q->internalWinId() != 0;
+if (wasCreated || nativeWidget && nonWindowWithCreatedParent) {
 createWinId();
 if (q->isWindow()) {
 #ifndef QT_MAC_USE_COCOA
 // We do this down below for wasCreated, so avoid doing this twice
 // (only for performance, it gets called a lot anyway).
 if (current->isWindow())
 break;
 current = current->parentWidget();
 }
 }
 invalidateBuffer(q->rect());
 qt_event_request_window_change(q);
 }
 QPoint QWidget::mapToGlobal(const QPoint &pos) const
 {
 Q_D(const QWidget);
-if (!testAttribute(Qt::WA_WState_Created)) {
+if (!testAttribute(Qt::WA_WState_Created) || !internalWinId()) {
 QPoint p = pos + data->crect.topLeft();
 return isWindow() ?  p : parentWidget()->mapToGlobal(p);
 }
 #ifndef QT_MAC_USE_COCOA
 QPoint tmp = d->mapToWS(pos);
 }
 QPoint QWidget::mapFromGlobal(const QPoint &pos) const
 {
 Q_D(const QWidget);
-if (!testAttribute(Qt::WA_WState_Created)) {
+if (!testAttribute(Qt::WA_WState_Created) || !internalWinId()) {
 QPoint p = isWindow() ?  pos : parentWidget()->mapFromGlobal(pos);
 return p - data->crect.topLeft();
 }
 #ifndef QT_MAC_USE_COCOA
 Rect win_rect;
 || (tlw->windowType() == Qt::Tool)
 || qt_mac_is_macdrawer(tlw)
 || windowActive) {
 #ifndef QT_MAC_USE_COCOA
 ActivateWindow(win, true);
+qApp->setActiveWindow(tlw);
 #else
 [win makeKeyWindow];
 #endif
-qApp->setActiveWindow(tlw);
 } else if(!isMinimized()) {
 #ifndef QT_MAC_USE_COCOA
 SelectWindow(win);
 #else
 [win makeKeyAndOrderFront:win];
 return;
 dirtyOnWidget += r;
 #ifndef QT_MAC_USE_COCOA
 HIViewSetNeedsDisplay(qt_mac_nativeview_for(q), true);
 #else
-[qt_mac_nativeview_for(q) setNeedsDisplay:YES];
+	    qt_mac_set_needs_display(q, QRegion());
 #endif
 return;
 }
 int x = r.x(), y = r.y(), w = r.width(), h = r.height();
 HIViewSetNeedsDisplayInRegion(qt_mac_nativeview_for(q), QMacSmartQuickDrawRegion(rgnHandle), true);
 else {
 HIViewSetNeedsDisplay(qt_mac_nativeview_for(q), true); // do a complete repaint on overflow.
 }
 #else
-// Cocoa doesn't do regions, it seems more efficient to just update the bounding rect instead of a potential number of message passes for each rect.
+// Alien support: get the first native ancestor widget (will be q itself in the non-alien case),
-const QRect &boundingRect = rgn.boundingRect();
+// map the coordinates from q space to NSView space and invalidate the rect.
-[qt_mac_nativeview_for(q) setNeedsDisplayInRect:NSMakeRect(boundingRect.x(),
+QWidget *nativeParent = q->internalWinId() ? q : q->nativeParentWidget();
-boundingRect.y(), boundingRect.width(),
+if (nativeParent == 0)
-boundingRect.height())];
+	return;
+QVector<QRect> rects = rgn.rects();
+for (int i = 0; i < rects.count(); ++i) {
+const QRect &rect = rects.at(i);
+	const QRect nativeBoundingRect = QRect(
+		QPoint(q->mapTo(nativeParent, rect.topLeft())),
+		QSize(rect.size()));
+	[qt_mac_nativeview_for(nativeParent) setNeedsDisplayInRect:NSMakeRect(nativeBoundingRect.x(),
+		nativeBoundingRect.y(), nativeBoundingRect.width(),
+		nativeBoundingRect.height())];
+}
 #endif
 }
 bool QWidgetPrivate::isRealWindow() const
 {
 q->setAttribute(Qt::WA_Mapped);
 if (q->testAttribute(Qt::WA_DontShowOnScreen))
 return;
 bool realWindow = isRealWindow();
+#ifndef QT_MAC_USE_COCOA
 if (realWindow && !q->testAttribute(Qt::WA_Moved)) {
+if (qt_mac_is_macsheet(q))
+recreateMacWindow();
 q->createWinId();
 if (QWidget *p = q->parentWidget()) {
 p->createWinId();
-#ifndef QT_MAC_USE_COCOA
 RepositionWindow(qt_mac_window_for(q), qt_mac_window_for(p), kWindowCenterOnParentWindow);
-#else
-CGRect parentFrame = NSRectToCGRect([qt_mac_window_for(p) frame]);
-OSWindowRef windowRef = qt_mac_window_for(q);
-NSRect windowFrame = [windowRef frame];
-NSPoint parentCenter = NSMakePoint(CGRectGetMidX(parentFrame), CGRectGetMidY(parentFrame));
-[windowRef setFrameTopLeftPoint:NSMakePoint(parentCenter.x - (windowFrame.size.width / 2),
-(parentCenter.y + (windowFrame.size.height / 2)))];
-#endif
 } else {
-#ifndef QT_MAC_USE_COCOA
 RepositionWindow(qt_mac_window_for(q), 0, kWindowCenterOnMainScreen);
-#else
+}
-// Ideally we would do a "center" here, but NSWindow's center is more equivalent to
+}
-// kWindowAlertPositionOnMainScreen instead of kWindowCenterOnMainScreen.
+#endif
-QRect availGeo = QApplication::desktop()->availableGeometry(q);
-// Center the content only.
-data.crect.moveCenter(availGeo.center());
-QRect fStrut = frameStrut();
-QRect frameRect(data.crect.x() - fStrut.left(), data.crect.y() - fStrut.top(),
-fStrut.left() + fStrut.right() + data.crect.width(),
-fStrut.top() + fStrut.bottom() + data.crect.height());
-NSRect cocoaFrameRect = NSMakeRect(frameRect.x(), flipYCoordinate(frameRect.bottom() + 1), frameRect.width(), frameRect.height());
-[qt_mac_window_for(q) setFrame:cocoaFrameRect display:NO];
-#endif
-}
-}
 data.fstrut_dirty = true;
 if (realWindow) {
 // Delegates can change window state, so record some things earlier.
 bool isCurrentlyMinimized = (q->windowState() & Qt::WindowMinimized);
 setModal_sys();
 #ifndef QT_MAC_USE_COCOA
 ShowHide(window, true);
 #else
 // sync the opacity value back (in case of a fade).
 [window setAlphaValue:q->windowOpacity()];
-[window makeKeyAndOrderFront:window];
+setSubWindowStacking(true);
-// If this window is app modal, we need to start spinning
+QWidget *top = 0;
-// a modal session for it. Interrupting
+if (QApplicationPrivate::tryModalHelper(q, &top)) {
-// the event dispatcher will make this happend:
+[window makeKeyAndOrderFront:window];
-if (data.window_modality == Qt::ApplicationModal)
+// If this window is app modal, we need to start spinning
-QEventDispatcherMac::instance()->interrupt();
+// a modal session for it. Interrupting
+// the event dispatcher will make this happend:
+if (data.window_modality == Qt::ApplicationModal)
+QEventDispatcherMac::instance()->interrupt();
+} else {
+// The window is modally shaddowed, so we need to make
+// sure that we don't pop in front of the modal window:
+[window orderFront:window];
+if (!top->testAttribute(Qt::WA_DontShowOnScreen)) {
+if (NSWindow *modalWin = qt_mac_window_for(top))
+[modalWin orderFront:window];
+}
+}
 #endif
 if (q->windowType() == Qt::Popup) {
 			    if (q->focusWidget())
 				    q->focusWidget()->d_func()->setFocus_sys();
 				else
 [window miniaturize:window];
 #endif
 } else if (!q->testAttribute(Qt::WA_ShowWithoutActivating)) {
 #ifndef QT_MAC_USE_COCOA
 qt_event_request_activate(q);
-#else
-[qt_mac_window_for(q) makeKeyWindow];
 #endif
 }
 } else if(topData()->embedded || !q->parentWidget() || q->parentWidget()->isVisible()) {
 #ifndef QT_MAC_USE_COCOA
 HIViewSetVisible(qt_mac_nativeview_for(q), true);
 Q_Q(QWidget);
 if((q->windowType() == Qt::Desktop)) //you can't hide the desktop!
 return;
 QMacCocoaAutoReleasePool pool;
 if(q->isWindow()) {
+#ifdef QT_MAC_USE_COCOA
+setSubWindowStacking(false);
+#endif
 OSWindowRef window = qt_mac_window_for(q);
 if(qt_mac_is_macsheet(q)) {
 #ifndef QT_MAC_USE_COCOA
 WindowRef parent = 0;
 if(GetSheetWindowParent(window, &parent) != noErr || !parent)
 SetWindowModality(window, kWindowModalityNone,
 q->parentWidget() ? qt_mac_window_for(q->parentWidget()->window()) : 0);
 }
 #endif
 }
-if(q->isActiveWindow() && !(q->windowType() == Qt::Popup)) {
+#ifndef QT_MAC_USE_COCOA
+// If the window we now hide was the active window, we need
+// to find, and activate another window on screen. NB: Cocoa takes care of this
+// logic for us (and distinquishes between main windows and key windows)
+if (q->isActiveWindow() && !(q->windowType() == Qt::Popup)) {
 QWidget *w = 0;
 if(q->parentWidget())
 w = q->parentWidget()->window();
 if(!w || (!w->isVisible() && !w->isMinimized())) {
-#ifndef QT_MAC_USE_COCOA
 for (WindowPtr wp = GetFrontWindowOfClass(kMovableModalWindowClass, true);
 wp; wp = GetNextWindowOfClass(wp, kMovableModalWindowClass, true)) {
 if((w = qt_mac_find_window(wp)))
 break;
 }
 wp; wp = GetNextWindowOfClass(wp, kSimpleWindowClass, true)) {
 if((w = qt_mac_find_window(wp)))
 break;
 }
 }
-#else
-NSArray *windows = [NSApp windows];
-NSUInteger totalWindows = [windows count];
-for (NSUInteger i = 0; i < totalWindows; ++i) {
-OSWindowRef wp = [windows objectAtIndex:i];
-if ((w = qt_mac_find_window(wp)))
-break;
-}
-#endif
 }
 if(w && w->isVisible() && !w->isMinimized()) {
-#ifndef QT_MAC_USE_COCOA
+qt_event_request_activate(w);
-qt_event_request_activate(w);
+}
-#else
+}
-[qt_mac_window_for(w) makeKeyWindow];
+#endif
-#endif
-}
-}
 } else {
 invalidateBuffer(q->rect());
 #ifndef QT_MAC_USE_COCOA
 HIViewSetVisible(qt_mac_nativeview_for(q), false);
 #else
 return;
 #if QT_MAC_USE_COCOA
 QMacCocoaAutoReleasePool pool;
 if (isRealWindow()) {
-// Calling orderFront shows the window on Cocoa too.
+// With the introduction of spaces it is not as simple as just raising the window.
+// First we need to check if we are in the right space. If we are, then we just continue
+// as usual. The problem comes when we are not in the active space. There are two main cases:
+// 1. Our parent was moved to a new space. In this case we want the window to be raised
+// in the same space as its parent.
+// 2. We don't have a parent. For this case we will just raise the window and let Cocoa
+// switch to the corresponding space.
+// NOTICE: There are a lot of corner cases here. We are keeping this simple for now, if
+// required we will introduce special handling for some of them.
 if (!q->testAttribute(Qt::WA_DontShowOnScreen) && q->isVisible()) {
-[qt_mac_window_for(q) orderFront:qt_mac_window_for(q)];
+OSWindowRef window = qt_mac_window_for(q);
+// isOnActiveSpace is available only from 10.6 onwards, so we need to check if it is
+// available before calling it.
+if([window respondsToSelector:@selector(isOnActiveSpace)]) {
+if(![window performSelector:@selector(isOnActiveSpace)]) {
+QWidget *parentWidget = q->parentWidget();
+if(parentWidget) {
+OSWindowRef parentWindow = qt_mac_window_for(parentWidget);
+if(parentWindow && [parentWindow isOnActiveSpace]) {
+// The window was created in a different space. Therefore if we want
+// to show it in the current space we need to recreate it in the new
+// space.
+recreateMacWindow();
+window = qt_mac_window_for(q);
+}
+}
+}
+}
+[window orderFront:window];
 }
 if (qt_mac_raise_process) { //we get to be the active process now
 ProcessSerialNumber psn;
 GetCurrentProcess(&psn);
 SetFrontProcessWithOptions(&psn, kSetFrontProcessFrontWindowOnly);
 /*
 Modifies the bounds for a widgets backing HIView during moves and resizes. Also updates the
 widget, either by scrolling its contents or repainting, depending on the WA_StaticContents
 flag
 */
-static void qt_mac_update_widget_posisiton(QWidget *q, QRect oldRect, QRect newRect)
+static void qt_mac_update_widget_position(QWidget *q, QRect oldRect, QRect newRect)
 {
 #ifndef QT_MAC_USE_COCOA
 HIRect bounds = CGRectMake(newRect.x(), newRect.y(),
 newRect.width(), newRect.height());
 const HIRect horizontalSlice = CGRectMake(0, starty, startx, stopy);
 HIViewSetNeedsDisplayInRect(view, &horizontalSlice, true);
 #else
 Q_UNUSED(oldRect);
 NSRect bounds = NSMakeRect(newRect.x(), newRect.y(),
-newRect.width(), newRect.height());
+	    newRect.width(), newRect.height());
 [qt_mac_nativeview_for(q) setFrame:bounds];
 #endif
 }
 /*
 QRect wrect;
 //xrect is the X geometry of my X widget. (starts out in  parent's Qt coord sys, and ends up in parent's X coord sys)
 QRect xrect = data.crect;
 QRect parentWRect;
-if (q->isWindow() && topData()->embedded) {
+bool isEmbeddedWindow = (q->isWindow() && topData()->embedded);
+if (isEmbeddedWindow) {
 #ifndef QT_MAC_USE_COCOA
 HIViewRef parentView = HIViewGetSuperview(qt_mac_nativeview_for(q));
 #else
 NSView *parentView = [qt_mac_nativeview_for(q) superview];
 #endif
 parentWRect = q->parentWidget()->data->wrect;
 }
 if (parentWRect.isValid()) {
 // parent is clipped, and we have to clip to the same limit as parent
-if (!parentWRect.contains(xrect)) {
+if (!parentWRect.contains(xrect) && !isEmbeddedWindow) {
 xrect &= parentWRect;
 wrect = xrect;
 //translate from parent's to my Qt coord sys
 wrect.translate(-data.crect.topLeft());
 }
 if (!w->isWindow() && w->testAttribute(Qt::WA_WState_Created))
 w->d_func()->setWSGeometry();
 }
 }
-qt_mac_update_widget_posisiton(q, oldRect, xrect);
+qt_mac_update_widget_position(q, oldRect, xrect);
 if  (jump)
 q->update();
 if (mapWindow && !dontShow) {
 if(q->windowType() == Qt::Desktop)
 return;
 QMacCocoaAutoReleasePool pool;
 bool realWindow = isRealWindow();
+BOOL needDisplay = realWindow ? YES : NO;
 if (realWindow && !q->testAttribute(Qt::WA_DontShowOnScreen)){
 adjustWithinMaxAndMinSize(w, h);
 #ifndef QT_MAC_USE_COCOA
 if (w != 0 && h != 0) {
 topData()->isSetGeometry = 0;
 } else {
 setGeometry_sys_helper(x, y, w, h, isMove);
 }
 #else
+if (!isMove && !q->testAttribute(Qt::WA_Moved) && !q->isVisible()) {
+// INVARIANT: The location of the window has not yet been set. The default will
+// instead be to center it on the desktop, or over the parent, if any. Since we now
+// resize the window, we need to adjust the top left position to keep the window
+// centeralized. And we need to to this now (and before show) in case the positioning
+// of other windows (e.g. sub-windows) depend on this position:
+if (QWidget *p = q->parentWidget()) {
+x = p->geometry().center().x() - (w / 2);
+y = p->geometry().center().y() - (h / 2);
+} else {
+QRect availGeo = QApplication::desktop()->availableGeometry(q);
+x = availGeo.center().x() - (w / 2);
+y = availGeo.center().y() - (h / 2);
+}
+}
 QSize  olds = q->size();
 const bool isResize = (olds != QSize(w, h));
 NSWindow *window = qt_mac_window_for(q);
 const QRect &fStrut = frameStrut();
 const QRect frameRect(QPoint(x - fStrut.left(), y - fStrut.top()),
 q->setAttribute(Qt::WA_PendingResizeEvent);
 QPoint currTopLeft = data.crect.topLeft();
 if (currTopLeft.x() == x && currTopLeft.y() == y
 && cocoaFrameRect.size.width != 0
 && cocoaFrameRect.size.height != 0) {
-[window setFrame:cocoaFrameRect display:NO];
+[window setFrame:cocoaFrameRect display:needDisplay];
 } else {
 // The window is moved and resized (or resized to zero).
 // Since Cocoa usually only sends us a resize callback after
 // setting a window frame, we issue an explicit move as
 // well. To stop Cocoa from optimize away the move (since the move
 // would have the same origin as the setFrame call) we shift the
 // window back and forth inbetween.
 cocoaFrameRect.origin.y += 1;
-[window setFrame:cocoaFrameRect display:NO];
+[window setFrame:cocoaFrameRect display:needDisplay];
 cocoaFrameRect.origin.y -= 1;
 [window setFrameOrigin:cocoaFrameRect.origin];
 }
 #endif
 } else {
 if (!q->testAttribute(Qt::WA_WState_Created))
 return;
 #ifndef QT_MAC_USE_COCOA
 SetControlDragTrackingEnabled(qt_mac_nativeview_for(q), on);
 #else
-NSView *view = qt_mac_nativeview_for(q);
+NSWindow *win = qt_mac_window_for(q);
-if (on && [view isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaView) class]]) {
+if (on) {
-[static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(view) registerDragTypes];
+if ([win isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaWindow) class]])
+[static_cast<QT_MANGLE_NAMESPACE(QCocoaWindow) *>(win) registerDragTypes];
+else if ([win isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaPanel) class]])
+[static_cast<QT_MANGLE_NAMESPACE(QCocoaPanel) *>(win) registerDragTypes];
 }
 #endif
 }
 void QWidgetPrivate::registerTouchWindow()
 if (q->isWindow()) {
 NSWindow *window = qt_mac_window_for(q);
 [window setOpaque:(extra->imageMask == 0)];
 [window invalidateShadow];
 }
-[qt_mac_nativeview_for(q) setNeedsDisplay:YES];
+qt_mac_set_needs_display(q, QRegion());
 }
 #endif
 struct QPaintEngineCleanupHandler
 {
 #ifdef QT_MAC_USE_COCOA
 QMacCocoaAutoReleasePool pool;
 bool alreadySheet = [windowRef styleMask] & NSDocModalWindowMask;
 if (windowParent && q->windowModality() == Qt::WindowModal){
-// Window should be window-modal, which implies a sheet.
+// INVARIANT: Window should be window-modal (which implies a sheet).
 if (!alreadySheet) {
 // NB: the following call will call setModal_sys recursivly:
 recreateMacWindow();
 windowRef = qt_mac_window_for(q);
 }
 bool worksWhenModal = isDialog ? [static_cast<NSPanel *>(ref) worksWhenModal] : false;
 if (worksWhenModal)
 [static_cast<NSPanel *>(windowRef) setWorksWhenModal:YES];
 }
 } else {
-// Window shold not be window-modal, and as such, not a sheet.
+// INVARIANT: Window shold _not_ be window-modal (and as such, not a sheet).
 if (alreadySheet){
 // NB: the following call will call setModal_sys recursivly:
 recreateMacWindow();
 windowRef = qt_mac_window_for(q);
 }
-if (q->windowModality() == Qt::ApplicationModal) {
+if (q->windowModality() == Qt::NonModal
-[windowRef setLevel:NSModalPanelWindowLevel];
+&& primaryWindow && primaryWindow->windowModality() == Qt::ApplicationModal) {
-} else if (primaryWindow && primaryWindow->windowModality() == Qt::ApplicationModal) {
+// INVARIANT: Our window has a parent that is application modal.
-// INVARIANT: Our window is a dialog that has a dialog parent that is
+// This means that q is supposed to be on top of this window and
-// application modal, or . This means that q is supposed to be on top of this
+// not be modally shaddowed:
-// dialog and not be modally shaddowed:
-[windowRef setLevel:NSModalPanelWindowLevel];
 if ([windowRef isKindOfClass:[NSPanel class]])
 [static_cast<NSPanel *>(windowRef) setWorksWhenModal:YES];
-} else {
-// INVARIANT: q should not be modal.
-NSInteger winLevel = -1;
-if (q->windowType() == Qt::Popup) {
-winLevel = NSPopUpMenuWindowLevel;
-// Popup should be in at least the same level as its parent.
-if (primaryWindow) {
-OSWindowRef parentRef = qt_mac_window_for(primaryWindow);
-winLevel = qMax([parentRef level], winLevel);
-}
-} else if (q->windowType() == Qt::Tool) {
-winLevel = NSFloatingWindowLevel;
-} else if (q->windowType() == Qt::Dialog) {
-winLevel = NSModalPanelWindowLevel;
-}
-// StayOnTop window should appear above Tool windows.
-if (data.window_flags & Qt::WindowStaysOnTopHint)
-winLevel = NSPopUpMenuWindowLevel;
-// Tooltips should appear above StayOnTop windows.
-if (q->windowType() == Qt::ToolTip)
-winLevel = NSScreenSaverWindowLevel;
-// All other types are Normal level.
-if (winLevel == -1)
-winLevel = NSNormalWindowLevel;
-[windowRef setLevel:winLevel];
 }
 }
 #else
 const bool primaryWindowModal = primaryWindow ? primaryWindow->testAttribute(Qt::WA_ShowModal) : false;

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