--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/kernel/qwidget_mac.mm Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,4942 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/****************************************************************************
+**
+** Copyright (c) 2007-2008, Apple, Inc.
+**
+** All rights reserved.
+**
+** Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are met:
+**
+** * Redistributions of source code must retain the above copyright notice,
+** this list of conditions and the following disclaimer.
+**
+** * Redistributions in binary form must reproduce the above copyright notice,
+** this list of conditions and the following disclaimer in the documentation
+** and/or other materials provided with the distribution.
+**
+** * Neither the name of Apple, Inc. nor the names of its contributors
+** may be used to endorse or promote products derived from this software
+** without specific prior written permission.
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+** CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+** EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+** PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+** PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+** LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+**
+****************************************************************************/
+
+#include <private/qt_mac_p.h>
+#include <private/qeventdispatcher_mac_p.h>
+
+#include "qapplication.h"
+#include "qapplication_p.h"
+#include "qbitmap.h"
+#include "qcursor.h"
+#include "qdesktopwidget.h"
+#include "qevent.h"
+#include "qfileinfo.h"
+#include "qimage.h"
+#include "qlayout.h"
+#include "qmenubar.h"
+#include <private/qbackingstore_p.h>
+#include <private/qwindowsurface_mac_p.h>
+#include <private/qpaintengine_mac_p.h>
+#include "qpainter.h"
+#include "qstyle.h"
+#include "qtimer.h"
+#include "qfocusframe.h"
+#include "qdebug.h"
+#include <private/qmainwindowlayout_p.h>
+
+#include <private/qabstractscrollarea_p.h>
+#include <qabstractscrollarea.h>
+#include <ApplicationServices/ApplicationServices.h>
+#include <limits.h>
+#include <private/qt_cocoa_helpers_mac_p.h>
+#include <private/qcocoaview_mac_p.h>
+#include <private/qcocoawindow_mac_p.h>
+#include <private/qcocoawindowdelegate_mac_p.h>
+#include <private/qcocoapanel_mac_p.h>
+
+#include "qwidget_p.h"
+#include "qevent_p.h"
+#include "qdnd_p.h"
+#include <QtGui/qgraphicsproxywidget.h>
+
+QT_BEGIN_NAMESPACE
+
+#define XCOORD_MAX 16383
+#define WRECT_MAX 8191
+
+#ifndef QT_MAC_USE_COCOA
+
+extern "C" {
+ extern OSStatus _HIViewScrollRectWithOptions(HIViewRef, const HIRect *, CGFloat, CGFloat,
+ OptionBits) __attribute__ ((weak));
+}
+#define kHIViewScrollRectAdjustInvalid 1
+#define kHIViewScrollRectDontInvalidateRevealedArea 2
+#endif
+
+
+/*****************************************************************************
+ QWidget debug facilities
+ *****************************************************************************/
+//#define DEBUG_WINDOW_RGNS
+//#define DEBUG_WINDOW_CREATE
+//#define DEBUG_WINDOW_STATE
+//#define DEBUG_WIDGET_PAINT
+
+/*****************************************************************************
+ QWidget globals
+ *****************************************************************************/
+#ifndef QT_MAC_USE_COCOA
+typedef QHash<Qt::WindowFlags, WindowGroupRef> WindowGroupHash;
+Q_GLOBAL_STATIC(WindowGroupHash, qt_mac_window_groups)
+const UInt32 kWidgetCreatorQt = kEventClassQt;
+enum {
+ kWidgetPropertyQWidget = 'QWId' //QWidget *
+};
+#endif
+
+static bool qt_mac_raise_process = true;
+static OSWindowRef qt_root_win = 0;
+QWidget *mac_mouse_grabber = 0;
+QWidget *mac_keyboard_grabber = 0;
+
+#ifndef QT_MAC_USE_COCOA
+#ifdef QT_NAMESPACE
+
+// produce the string "com.trolltech.qt-namespace.widget", where "namespace" is the contents of QT_NAMESPACE.
+#define SS(x) #x
+#define S0(x) SS(x)
+#define S "com.trolltech.qt-" S0(QT_NAMESPACE) ".widget"
+
+static CFStringRef kObjectQWidget = CFSTR(S);
+
+#undef SS
+#undef S0
+#undef S
+
+#else
+static CFStringRef kObjectQWidget = CFSTR("com.trolltech.qt.widget");
+#endif // QT_NAMESPACE
+#endif // QT_MAC_USE_COCOA
+
+/*****************************************************************************
+ Externals
+ *****************************************************************************/
+extern QWidget *qt_mac_modal_blocked(QWidget *); //qapplication_mac.mm
+extern void qt_event_request_activate(QWidget *); //qapplication_mac.mm
+extern bool qt_event_remove_activate(); //qapplication_mac.mm
+extern void qt_mac_event_release(QWidget *w); //qapplication_mac.mm
+extern void qt_event_request_showsheet(QWidget *); //qapplication_mac.mm
+extern void qt_event_request_window_change(QWidget *); //qapplication_mac.mm
+extern QPointer<QWidget> qt_mouseover; //qapplication_mac.mm
+extern IconRef qt_mac_create_iconref(const QPixmap &); //qpixmap_mac.cpp
+extern void qt_mac_set_cursor(const QCursor *, const QPoint &); //qcursor_mac.mm
+extern void qt_mac_update_cursor(); //qcursor_mac.mm
+extern bool qt_nograb();
+extern CGImageRef qt_mac_create_cgimage(const QPixmap &, bool); //qpixmap_mac.cpp
+extern RgnHandle qt_mac_get_rgn(); //qregion_mac.cpp
+extern QRegion qt_mac_convert_mac_region(RgnHandle rgn); //qregion_mac.cpp
+
+/*****************************************************************************
+ QWidget utility functions
+ *****************************************************************************/
+void Q_GUI_EXPORT qt_mac_set_raise_process(bool b) { qt_mac_raise_process = b; }
+static QSize qt_mac_desktopSize()
+{
+ int w = 0, h = 0;
+ CGDisplayCount cg_count;
+ CGGetActiveDisplayList(0, 0, &cg_count);
+ QVector<CGDirectDisplayID> displays(cg_count);
+ CGGetActiveDisplayList(cg_count, displays.data(), &cg_count);
+ Q_ASSERT(cg_count == (CGDisplayCount)displays.size());
+ for(int i = 0; i < (int)cg_count; ++i) {
+ CGRect r = CGDisplayBounds(displays.at(i));
+ w = qMax<int>(w, qRound(r.origin.x + r.size.width));
+ h = qMax<int>(h, qRound(r.origin.y + r.size.height));
+ }
+ return QSize(w, h);
+}
+
+#ifdef QT_MAC_USE_COCOA
+static NSDrawer *qt_mac_drawer_for(const QWidget *widget)
+{
+ // This only goes one level below the content view so start with the window.
+ // This works fine for straight Qt stuff, but runs into problems if we are
+ // embedding, but if that's the case, they probably want to be using
+ // NSDrawer directly.
+ NSView *widgetView = reinterpret_cast<NSView *>(widget->window()->winId());
+ NSArray *windows = [NSApp windows];
+ for (NSWindow *window in windows) {
+ NSArray *drawers = [window drawers];
+ for (NSDrawer *drawer in drawers) {
+ NSArray *views = [[drawer contentView] subviews];
+ for (NSView *view in views) {
+ if (view == widgetView)
+ return drawer;
+ }
+ }
+ }
+ return 0;
+}
+#endif
+
+static void qt_mac_destructView(OSViewRef view)
+{
+#ifdef QT_MAC_USE_COCOA
+ [view removeFromSuperview];
+ [view release];
+#else
+ HIViewRemoveFromSuperview(view);
+ CFRelease(view);
+#endif
+}
+
+static void qt_mac_destructWindow(OSWindowRef window)
+{
+#ifdef QT_MAC_USE_COCOA
+ if ([window isVisible] && [window isSheet]){
+ [NSApp endSheet:window];
+ [window orderOut:window];
+ }
+
+ [[QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate] resignDelegateForWindow:window];
+ [window release];
+#else
+ // Remove property to clean up memory:
+ RemoveWindowProperty(window, kWidgetCreatorQt, kWidgetPropertyQWidget);
+ CFRelease(window);
+#endif
+}
+
+static void qt_mac_destructDrawer(NSDrawer *drawer)
+{
+#ifdef QT_MAC_USE_COCOA
+ [[QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate] resignDelegateForDrawer:drawer];
+ [drawer release];
+#else
+ Q_UNUSED(drawer);
+#endif
+}
+
+bool qt_mac_can_clickThrough(const QWidget *w)
+{
+ static int qt_mac_carbon_clickthrough = -1;
+ if (qt_mac_carbon_clickthrough < 0)
+ qt_mac_carbon_clickthrough = !qgetenv("QT_MAC_NO_COCOA_CLICKTHROUGH").isEmpty();
+ bool ret = !qt_mac_carbon_clickthrough;
+ for ( ; w; w = w->parentWidget()) {
+ if (w->testAttribute(Qt::WA_MacNoClickThrough)) {
+ ret = false;
+ break;
+ }
+ }
+ return ret;
+}
+
+bool qt_mac_is_macsheet(const QWidget *w)
+{
+ if (!w)
+ return false;
+
+ Qt::WindowModality modality = w->windowModality();
+ if (modality == Qt::ApplicationModal)
+ return false;
+ return w->parentWidget() && (modality == Qt::WindowModal || w->windowType() == Qt::Sheet);
+}
+
+bool qt_mac_is_macdrawer(const QWidget *w)
+{
+ return (w && w->parentWidget() && w->windowType() == Qt::Drawer);
+}
+
+bool qt_mac_insideKeyWindow(const QWidget *w)
+{
+#ifdef QT_MAC_USE_COCOA
+ return [[reinterpret_cast<NSView *>(w->winId()) window] isKeyWindow];
+#else
+ Q_UNUSED(w);
+#endif
+ return false;
+}
+
+bool qt_mac_set_drawer_preferred_edge(QWidget *w, Qt::DockWidgetArea where) //users of Qt for Mac OS X can use this..
+{
+ if(!qt_mac_is_macdrawer(w))
+ return false;
+
+#if QT_MAC_USE_COCOA
+ NSDrawer *drawer = qt_mac_drawer_for(w);
+ if (!drawer)
+ return false;
+ NSRectEdge edge;
+ if (where & Qt::LeftDockWidgetArea)
+ edge = NSMinXEdge;
+ else if (where & Qt::RightDockWidgetArea)
+ edge = NSMaxXEdge;
+ else if (where & Qt::TopDockWidgetArea)
+ edge = NSMaxYEdge;
+ else if (where & Qt::BottomDockWidgetArea)
+ edge = NSMinYEdge;
+ else
+ return false;
+
+ if (edge == [drawer preferredEdge]) //no-op
+ return false;
+
+ if (w->isVisible()) {
+ [drawer close];
+ [drawer openOnEdge:edge];
+ }
+ [drawer setPreferredEdge:edge];
+#else
+ OSWindowRef window = qt_mac_window_for(w);
+ OptionBits edge;
+ if(where & Qt::LeftDockWidgetArea)
+ edge = kWindowEdgeLeft;
+ else if(where & Qt::RightDockWidgetArea)
+ edge = kWindowEdgeRight;
+ else if(where & Qt::TopDockWidgetArea)
+ edge = kWindowEdgeTop;
+ else if(where & Qt::BottomDockWidgetArea)
+ edge = kWindowEdgeBottom;
+ else
+ return false;
+
+ if(edge == GetDrawerPreferredEdge(window)) //no-op
+ return false;
+
+ //do it
+ SetDrawerPreferredEdge(window, edge);
+ if(w->isVisible()) {
+ CloseDrawer(window, false);
+ OpenDrawer(window, edge, true);
+ }
+#endif
+ return true;
+}
+
+#ifndef QT_MAC_USE_COCOA
+Q_GUI_EXPORT
+#endif
+QPoint qt_mac_posInWindow(const QWidget *w)
+{
+ QPoint ret = w->data->wrect.topLeft();
+ while(w && !w->isWindow()) {
+ ret += w->pos();
+ w = w->parentWidget();
+ }
+ return ret;
+}
+
+//find a QWidget from a OSWindowRef
+QWidget *qt_mac_find_window(OSWindowRef window)
+{
+#ifdef QT_MAC_USE_COCOA
+ return [window QT_MANGLE_NAMESPACE(qt_qwidget)];
+#else
+ if(!window)
+ return 0;
+
+ QWidget *ret;
+ if(GetWindowProperty(window, kWidgetCreatorQt, kWidgetPropertyQWidget, sizeof(ret), 0, &ret) == noErr)
+ return ret;
+ return 0;
+#endif
+}
+
+inline static void qt_mac_set_fullscreen_mode(bool b)
+{
+ extern bool qt_mac_app_fullscreen; //qapplication_mac.mm
+ if(qt_mac_app_fullscreen == b)
+ return;
+ qt_mac_app_fullscreen = b;
+ if (b) {
+ SetSystemUIMode(kUIModeAllSuppressed, 0);
+ } else {
+ SetSystemUIMode(kUIModeNormal, 0);
+ }
+}
+
+Q_GUI_EXPORT OSViewRef qt_mac_nativeview_for(const QWidget *w)
+{
+ return reinterpret_cast<OSViewRef>(w->data->winid);
+}
+
+Q_GUI_EXPORT OSViewRef qt_mac_get_contentview_for(OSWindowRef w)
+{
+#ifdef QT_MAC_USE_COCOA
+ return [w contentView];
+#else
+ HIViewRef contentView = 0;
+ OSStatus err = GetRootControl(w, &contentView); // Returns the window's content view (Apple QA1214)
+ if (err == errUnknownControl) {
+ contentView = HIViewGetRoot(w);
+ } else if (err != noErr) {
+ qWarning("Qt:Could not get content or root view of window! %s:%d [%ld]",
+ __FILE__, __LINE__, err);
+ }
+ return contentView;
+#endif
+}
+
+bool qt_mac_sendMacEventToWidget(QWidget *widget, EventRef ref)
+{
+ return widget->macEvent(0, ref);
+}
+
+Q_GUI_EXPORT OSWindowRef qt_mac_window_for(OSViewRef view)
+{
+#ifdef QT_MAC_USE_COCOA
+ if (view)
+ return [view window];
+ return 0;
+#else
+ return HIViewGetWindow(view);
+#endif
+}
+
+static bool qt_isGenuineQWidget(OSViewRef ref)
+{
+#ifdef QT_MAC_USE_COCOA
+ return [ref isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaView) class]];
+#else
+ return HIObjectIsOfClass(HIObjectRef(ref), kObjectQWidget);
+#endif
+}
+
+bool qt_isGenuineQWidget(const QWidget *window)
+{
+ return window && qt_isGenuineQWidget(OSViewRef(window->winId()));
+}
+
+Q_GUI_EXPORT OSWindowRef qt_mac_window_for(const QWidget *w)
+{
+ OSViewRef hiview = qt_mac_nativeview_for(w);
+ if (hiview){
+ OSWindowRef window = qt_mac_window_for(hiview);
+ if (!window && qt_isGenuineQWidget(hiview)) {
+ QWidget *myWindow = w->window();
+ // This is a workaround for NSToolbar. When a widget is hidden
+ // by clicking the toolbar button, Cocoa reparents the widgets
+ // to another window (but Qt doesn't know about it).
+ // When we start showing them, it reparents back,
+ // but at this point it's window is nil, but the window it's being brought
+ // into (the Qt one) is for sure created.
+ // This stops the hierarchy moving under our feet.
+ if (myWindow != w && qt_mac_window_for(qt_mac_nativeview_for(myWindow)))
+ return qt_mac_window_for(qt_mac_nativeview_for(myWindow));
+
+ myWindow->d_func()->createWindow_sys();
+ // Reget the hiview since the "create window could potentially move the view (I guess).
+ hiview = qt_mac_nativeview_for(w);
+ window = qt_mac_window_for(hiview);
+ }
+ return window;
+ }
+ return 0;
+}
+#ifndef QT_MAC_USE_COCOA
+/* Checks if the current group is a 'stay on top' group. If so, the
+ group gets removed from the hash table */
+static void qt_mac_release_stays_on_top_group(WindowGroupRef group)
+{
+ for (WindowGroupHash::iterator it = qt_mac_window_groups()->begin(); it != qt_mac_window_groups()->end(); ++it) {
+ if (it.value() == group) {
+ qt_mac_window_groups()->remove(it.key());
+ return;
+ }
+ }
+}
+
+/* Use this function instead of ReleaseWindowGroup, this will be sure to release the
+ stays on top window group (created with qt_mac_get_stays_on_top_group below) */
+static void qt_mac_release_window_group(WindowGroupRef group)
+{
+ ReleaseWindowGroup(group);
+ if (GetWindowGroupRetainCount(group) == 0)
+ qt_mac_release_stays_on_top_group(group);
+}
+#define ReleaseWindowGroup(x) Are you sure you wanted to do that? (you wanted qt_mac_release_window_group)
+
+SInt32 qt_mac_get_group_level(WindowClass wclass)
+{
+ SInt32 group_level;
+ CGWindowLevel tmpLevel;
+ GetWindowGroupLevelOfType(GetWindowGroupOfClass(wclass), kWindowGroupLevelActive, &tmpLevel);
+ group_level = tmpLevel;
+ return group_level;
+}
+#endif
+
+#ifndef QT_MAC_USE_COCOA
+static void qt_mac_set_window_group(OSWindowRef window, Qt::WindowFlags flags, int level)
+{
+ WindowGroupRef group = 0;
+ if (qt_mac_window_groups()->contains(flags)) {
+ group = qt_mac_window_groups()->value(flags);
+ RetainWindowGroup(group);
+ } else {
+ CreateWindowGroup(kWindowActivationScopeNone, &group);
+ SetWindowGroupLevel(group, level);
+ SetWindowGroupParent(group, GetWindowGroupOfClass(kAllWindowClasses));
+ qt_mac_window_groups()->insert(flags, group);
+ }
+ SetWindowGroup(window, group);
+}
+
+inline static void qt_mac_set_window_group_to_stays_on_top(OSWindowRef window, Qt::WindowType type)
+{
+ // We create one static stays on top window group so that
+ // all stays on top (aka popups) will fall into the same
+ // group and be able to be raise()'d with releation to one another (from
+ // within the same window group).
+ qt_mac_set_window_group(window, type|Qt::WindowStaysOnTopHint, qt_mac_get_group_level(kOverlayWindowClass));
+}
+
+inline static void qt_mac_set_window_group_to_tooltip(OSWindowRef window)
+{
+ // Since new groups are created for 'stays on top' windows, the
+ // same must be done for tooltips. Otherwise, tooltips would be drawn
+ // below 'stays on top' widgets even tough they are on the same level.
+ // Also, add 'two' to the group level to make sure they also get on top of popups.
+ qt_mac_set_window_group(window, Qt::ToolTip, qt_mac_get_group_level(kHelpWindowClass)+2);
+}
+
+inline static void qt_mac_set_window_group_to_popup(OSWindowRef window)
+{
+ // In Qt, a popup is seen as a 'stay on top' window.
+ // Since new groups are created for 'stays on top' windows, the
+ // same must be done for popups. Otherwise, popups would be drawn
+ // below 'stays on top' windows. Add 1 to get above pure stay-on-top windows.
+ qt_mac_set_window_group(window, Qt::Popup, qt_mac_get_group_level(kOverlayWindowClass)+1);
+}
+#endif
+
+inline static bool updateRedirectedToGraphicsProxyWidget(QWidget *widget, const QRect &rect)
+{
+ if (!widget)
+ return false;
+
+#ifndef QT_NO_GRAPHICSVIEW
+ QWidget *tlw = widget->window();
+ QWExtra *extra = qt_widget_private(tlw)->extra;
+ if (extra && extra->proxyWidget) {
+ extra->proxyWidget->update(rect.translated(widget->mapTo(tlw, QPoint())));
+ return true;
+ }
+#endif
+
+ return false;
+}
+
+inline static bool updateRedirectedToGraphicsProxyWidget(QWidget *widget, const QRegion &rgn)
+{
+ if (!widget)
+ return false;
+
+#ifndef QT_NO_GRAPHICSVIEW
+ QWidget *tlw = widget->window();
+ QWExtra *extra = qt_widget_private(tlw)->extra;
+ if (extra && extra->proxyWidget) {
+ const QPoint offset(widget->mapTo(tlw, QPoint()));
+ const QVector<QRect> rects = rgn.rects();
+ for (int i = 0; i < rects.size(); ++i)
+ extra->proxyWidget->update(rects.at(i).translated(offset));
+ return true;
+ }
+#endif
+
+ return false;
+}
+
+void QWidgetPrivate::macUpdateIsOpaque()
+{
+ Q_Q(QWidget);
+ if (!q->testAttribute(Qt::WA_WState_Created))
+ return;
+#ifndef QT_MAC_USE_COCOA
+ HIViewFeatures bits;
+ HIViewRef hiview = qt_mac_nativeview_for(q);
+ HIViewGetFeatures(hiview, &bits);
+ if ((bits & kHIViewIsOpaque) == isOpaque)
+ return;
+ if (isOpaque) {
+ HIViewChangeFeatures(hiview, kHIViewIsOpaque, 0);
+ } else {
+ HIViewChangeFeatures(hiview, 0, kHIViewIsOpaque);
+ }
+ if (q->isVisible())
+ HIViewReshapeStructure(qt_mac_nativeview_for(q));
+#else
+ if (isRealWindow() && !q->testAttribute(Qt::WA_MacBrushedMetal)) {
+ bool opaque = isOpaque;
+ if (extra && extra->imageMask)
+ opaque = false; // we are never opaque when we have a mask.
+ [qt_mac_window_for(q) setOpaque:opaque];
+ }
+#endif
+}
+#ifdef QT_MAC_USE_COCOA
+static OSWindowRef qt_mac_create_window(QWidget *widget, WindowClass wclass,
+ NSUInteger wattr, const QRect &crect)
+{
+ // Determine if we need to add in our "custom window" attribute. Cocoa is rather clever
+ // in deciding if we need the maximize button or not (i.e., it's resizeable, so you
+ // must need a maximize button). So, the only buttons we have control over are the
+ // close and minimize buttons. If someone wants to customize and NOT have the maximize
+ // button, then we have to do our hack. We only do it for these cases because otherwise
+ // the window looks different when activated. This "QtMacCustomizeWindow" attribute is
+ // intruding on a public space and WILL BREAK in the future.
+ // One can hope that there is a more public API available by that time.
+ Qt::WindowFlags flags = widget ? widget->windowFlags() : Qt::WindowFlags(0);
+ if ((flags & Qt::CustomizeWindowHint)) {
+ if ((flags & (Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint
+ | Qt::WindowMinimizeButtonHint | Qt::WindowTitleHint))
+ && !(flags & Qt::WindowMaximizeButtonHint))
+ wattr |= QtMacCustomizeWindow;
+ }
+
+ // If we haven't created the desktop widget, you have to pass the rectangle
+ // in "cocoa coordinates" (i.e., top points to the lower left coordinate).
+ // Otherwise, we do the conversion for you. Since we are the only ones that
+ // create the desktop widget, this is OK (but confusing).
+ NSRect geo = NSMakeRect(crect.left(),
+ (qt_root_win != 0) ? flipYCoordinate(crect.bottom() + 1) : crect.top(),
+ crect.width(), crect.height());
+ QMacCocoaAutoReleasePool pool;
+ OSWindowRef window;
+ switch (wclass) {
+ case kMovableModalWindowClass:
+ case kModalWindowClass:
+ case kSheetWindowClass:
+ case kFloatingWindowClass:
+ case kOverlayWindowClass:
+ case kHelpWindowClass: {
+ NSPanel *panel;
+ BOOL needFloating = NO;
+ BOOL worksWhenModal = widget && (widget->windowType() == Qt::Popup);
+ // Add in the extra flags if necessary.
+ switch (wclass) {
+ case kSheetWindowClass:
+ wattr |= NSDocModalWindowMask;
+ break;
+ case kFloatingWindowClass:
+ case kHelpWindowClass:
+ needFloating = YES;
+ wattr |= NSUtilityWindowMask;
+ break;
+ default:
+ break;
+ }
+ panel = [[QT_MANGLE_NAMESPACE(QCocoaPanel) alloc] QT_MANGLE_NAMESPACE(qt_initWithQWidget):widget contentRect:geo styleMask:wattr];
+ [panel setFloatingPanel:needFloating];
+ [panel setWorksWhenModal:worksWhenModal];
+ window = panel;
+ break;
+ }
+ case kDrawerWindowClass: {
+ NSDrawer *drawer = [[NSDrawer alloc] initWithContentSize:geo.size preferredEdge:NSMinXEdge];
+ [[QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate] becomeDelegateForDrawer:drawer widget:widget];
+ QWidget *parentWidget = widget->parentWidget();
+ if (parentWidget)
+ [drawer setParentWindow:qt_mac_window_for(parentWidget)];
+ [drawer setLeadingOffset:0.0];
+ [drawer setTrailingOffset:25.0];
+ window = [[drawer contentView] window]; // Just to make sure we actually return a window
+ break;
+ }
+ default:
+ window = [[QT_MANGLE_NAMESPACE(QCocoaWindow) alloc] QT_MANGLE_NAMESPACE(qt_initWithQWidget):widget contentRect:geo styleMask:wattr];
+ break;
+ }
+ qt_syncCocoaTitleBarButtons(window, widget);
+ return window;
+}
+#else
+static OSWindowRef qt_mac_create_window(QWidget *, WindowClass wclass, WindowAttributes wattr,
+ const QRect &crect)
+{
+ OSWindowRef window;
+ Rect geo;
+ SetRect(&geo, crect.left(), crect.top(), crect.right() + 1, crect.bottom() + 1);
+ OSStatus err;
+ if(geo.right <= geo.left) geo.right = geo.left + 1;
+ if(geo.bottom <= geo.top) geo.bottom = geo.top + 1;
+ Rect null_rect;
+ SetRect(&null_rect, 0, 0, 1, 1);
+ err = CreateNewWindow(wclass, wattr, &null_rect, &window);
+ if(err == noErr) {
+ err = SetWindowBounds(window, kWindowContentRgn, &geo);
+ if(err != noErr)
+ qWarning("QWidget: Internal error (%s:%d)", __FILE__, __LINE__);
+ }
+ return window;
+}
+
+// window events
+static EventTypeSpec window_events[] = {
+ { kEventClassWindow, kEventWindowClose },
+ { kEventClassWindow, kEventWindowExpanded },
+ { kEventClassWindow, kEventWindowHidden },
+ { kEventClassWindow, kEventWindowZoomed },
+ { kEventClassWindow, kEventWindowCollapsed },
+ { kEventClassWindow, kEventWindowToolbarSwitchMode },
+ { kEventClassWindow, kEventWindowProxyBeginDrag },
+ { kEventClassWindow, kEventWindowProxyEndDrag },
+ { kEventClassWindow, kEventWindowResizeCompleted },
+ { kEventClassWindow, kEventWindowBoundsChanging },
+ { kEventClassWindow, kEventWindowGetRegion },
+ { kEventClassWindow, kEventWindowGetClickModality },
+ { kEventClassWindow, kEventWindowTransitionCompleted },
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+ { kEventClassGesture, kEventGestureStarted },
+ { kEventClassGesture, kEventGestureEnded },
+ { kEventClassGesture, kEventGestureMagnify },
+ { kEventClassGesture, kEventGestureSwipe },
+ { kEventClassGesture, kEventGestureRotate },
+#endif
+ { kEventClassMouse, kEventMouseDown }
+};
+static EventHandlerUPP mac_win_eventUPP = 0;
+static void cleanup_win_eventUPP()
+{
+ DisposeEventHandlerUPP(mac_win_eventUPP);
+ mac_win_eventUPP = 0;
+}
+static const EventHandlerUPP make_win_eventUPP()
+{
+ if(mac_win_eventUPP)
+ return mac_win_eventUPP;
+ qAddPostRoutine(cleanup_win_eventUPP);
+ return mac_win_eventUPP = NewEventHandlerUPP(QWidgetPrivate::qt_window_event);
+}
+OSStatus QWidgetPrivate::qt_window_event(EventHandlerCallRef er, EventRef event, void *)
+{
+ QScopedLoopLevelCounter loopLevelCounter(qApp->d_func()->threadData);
+ bool handled_event = true;
+ UInt32 ekind = GetEventKind(event), eclass = GetEventClass(event);
+ switch(eclass) {
+ case kEventClassWindow: {
+ WindowRef wid = 0;
+ GetEventParameter(event, kEventParamDirectObject, typeWindowRef, 0,
+ sizeof(WindowRef), 0, &wid);
+ QWidget *widget = qt_mac_find_window(wid);
+ if(!widget) {
+ handled_event = false;
+ } else if(ekind == kEventWindowGetClickModality) {
+ // Carbon will send us kEventWindowGetClickModality before every
+ // mouse press / release event. By returning 'true', we tell Carbon
+ // that we would like the event target to receive the mouse event even
+ // if the target is modally shaddowed. In Qt, this makes sense when we
+ // e.g. have a popup showing, as the popup will grab the event
+ // and perhaps use it to close itself.
+ // By also setting the current modal window back into the event, we
+ // help Carbon determining which window is supposed to be raised.
+ handled_event = qApp->activePopupWidget() ? true : false;
+ } else if(ekind == kEventWindowClose) {
+ widget->d_func()->close_helper(QWidgetPrivate::CloseWithSpontaneousEvent);
+ QMenuBar::macUpdateMenuBar();
+ } else if (ekind == kEventWindowTransitionCompleted) {
+ WindowTransitionAction transitionAction;
+ GetEventParameter(event, kEventParamWindowTransitionAction, typeWindowTransitionAction,
+ 0, sizeof(transitionAction), 0, &transitionAction);
+ if (transitionAction == kWindowHideTransitionAction)
+ widget->hide();
+ } else if(ekind == kEventWindowExpanded) {
+ Qt::WindowStates currState = Qt::WindowStates(widget->data->window_state);
+ Qt::WindowStates newState = currState;
+ if (currState & Qt::WindowMinimized)
+ newState &= ~Qt::WindowMinimized;
+ if (!(currState & Qt::WindowActive))
+ newState |= Qt::WindowActive;
+ if (newState != currState) {
+ // newState will differ from currState if the window
+ // was expanded after clicking on the jewels (as opposed
+ // to calling QWidget::setWindowState)
+ widget->data->window_state = newState;
+ QWindowStateChangeEvent e(currState);
+ QApplication::sendSpontaneousEvent(widget, &e);
+ }
+
+ QShowEvent qse;
+ QApplication::sendSpontaneousEvent(widget, &qse);
+ } else if(ekind == kEventWindowZoomed) {
+ WindowPartCode windowPart;
+ GetEventParameter(event, kEventParamWindowPartCode,
+ typeWindowPartCode, 0, sizeof(windowPart), 0, &windowPart);
+ if(windowPart == inZoomIn && widget->isMaximized()) {
+
+ widget->data->window_state = widget->data->window_state & ~Qt::WindowMaximized;
+ QWindowStateChangeEvent e(Qt::WindowStates(widget->data->window_state | Qt::WindowMaximized));
+ QApplication::sendSpontaneousEvent(widget, &e);
+ } else if(windowPart == inZoomOut && !widget->isMaximized()) {
+ widget->data->window_state = widget->data->window_state | Qt::WindowMaximized;
+ QWindowStateChangeEvent e(Qt::WindowStates(widget->data->window_state
+ & ~Qt::WindowMaximized));
+ QApplication::sendSpontaneousEvent(widget, &e);
+ }
+ extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
+ qt_button_down = 0;
+ } else if(ekind == kEventWindowCollapsed) {
+ if (!widget->isMinimized()) {
+ widget->data->window_state = widget->data->window_state | Qt::WindowMinimized;
+ QWindowStateChangeEvent e(Qt::WindowStates(widget->data->window_state & ~Qt::WindowMinimized));
+ QApplication::sendSpontaneousEvent(widget, &e);
+ }
+
+ // Deactivate this window:
+ if (widget->isActiveWindow() && !(widget->windowType() == Qt::Popup)) {
+ QWidget *w = 0;
+ if (widget->parentWidget())
+ w = widget->parentWidget()->window();
+ if (!w || (!w->isVisible() && !w->isMinimized())) {
+ for (WindowPtr wp = GetFrontWindowOfClass(kDocumentWindowClass, true);
+ wp; wp = GetNextWindowOfClass(wp, kDocumentWindowClass, true)) {
+ if ((w = qt_mac_find_window(wp)))
+ break;
+ }
+ }
+ if(!(w && w->isVisible() && !w->isMinimized()))
+ qApp->setActiveWindow(0);
+ }
+
+ //we send a hide to be like X11/Windows
+ QEvent e(QEvent::Hide);
+ QApplication::sendSpontaneousEvent(widget, &e);
+ extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
+ qt_button_down = 0;
+ } else if(ekind == kEventWindowToolbarSwitchMode) {
+ macSendToolbarChangeEvent(widget);
+ HIToolbarRef toolbar;
+ if (GetWindowToolbar(wid, &toolbar) == noErr) {
+ if (toolbar) {
+ // Let HIToolbar do its thang, but things like the OpenGL context
+ // needs to know about it.
+ CallNextEventHandler(er, event);
+ qt_event_request_window_change(widget);
+ widget->data->fstrut_dirty = true;
+ }
+ }
+ } else if(ekind == kEventWindowGetRegion) {
+ WindowRef window;
+ GetEventParameter(event, kEventParamDirectObject, typeWindowRef, 0,
+ sizeof(window), 0, &window);
+ WindowRegionCode wcode;
+ GetEventParameter(event, kEventParamWindowRegionCode, typeWindowRegionCode, 0,
+ sizeof(wcode), 0, &wcode);
+ if (wcode != kWindowOpaqueRgn){
+ // If the region is kWindowOpaqueRgn, don't call next
+ // event handler cause this will make the shadow of
+ // masked windows become offset. Unfortunately, we're not sure why.
+ CallNextEventHandler(er, event);
+ }
+ RgnHandle rgn;
+ GetEventParameter(event, kEventParamRgnHandle, typeQDRgnHandle, 0,
+ sizeof(rgn), 0, &rgn);
+
+ if(QWidgetPrivate::qt_widget_rgn(qt_mac_find_window(window), wcode, rgn, false))
+ SetEventParameter(event, kEventParamRgnHandle, typeQDRgnHandle, sizeof(rgn), &rgn);
+ } else if(ekind == kEventWindowProxyBeginDrag) {
+ QIconDragEvent e;
+ QApplication::sendSpontaneousEvent(widget, &e);
+ } else if(ekind == kEventWindowResizeCompleted) {
+ // Create a mouse up event, since such an event is not send by carbon to the
+ // application event handler (while a mouse down <b>is</b> on kEventWindowResizeStarted)
+ EventRef mouseUpEvent;
+ CreateEvent(0, kEventClassMouse, kEventMouseUp, 0, kEventAttributeUserEvent, &mouseUpEvent);
+ UInt16 mbutton = kEventMouseButtonPrimary;
+ SetEventParameter(mouseUpEvent, kEventParamMouseButton, typeMouseButton, sizeof(mbutton), &mbutton);
+ WindowRef window;
+ GetEventParameter(event, kEventParamDirectObject, typeWindowRef, 0, sizeof(window), 0, &window);
+ Rect dragRect;
+ GetWindowBounds(window, kWindowGrowRgn, &dragRect);
+ Point pos = {dragRect.bottom, dragRect.right};
+ SetEventParameter(mouseUpEvent, kEventParamMouseLocation, typeQDPoint, sizeof(pos), &pos);
+ SendEventToApplication(mouseUpEvent);
+ ReleaseEvent(mouseUpEvent);
+ } else if(ekind == kEventWindowBoundsChanging) {
+ UInt32 flags = 0;
+ GetEventParameter(event, kEventParamAttributes, typeUInt32, 0,
+ sizeof(flags), 0, &flags);
+ Rect nr;
+ GetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, 0,
+ sizeof(nr), 0, &nr);
+
+ QRect newRect(nr.left, nr.top, nr.right - nr.left, nr.bottom - nr.top);
+
+ QTLWExtra * const tlwExtra = widget->d_func()->maybeTopData();
+ if (tlwExtra && tlwExtra->isSetGeometry == 1) {
+ widget->d_func()->setGeometry_sys_helper(newRect.left(), newRect.top(), newRect.width(), newRect.height(), tlwExtra->isMove);
+ } else {
+ //implicitly removes the maximized bit
+ if((widget->data->window_state & Qt::WindowMaximized) &&
+ IsWindowInStandardState(wid, 0, 0)) {
+ widget->data->window_state &= ~Qt::WindowMaximized;
+ QWindowStateChangeEvent e(Qt::WindowStates(widget->data->window_state
+ | Qt::WindowMaximized));
+ QApplication::sendSpontaneousEvent(widget, &e);
+
+ }
+
+ handled_event = false;
+ const QRect oldRect = widget->data->crect;
+ if((flags & kWindowBoundsChangeOriginChanged)) {
+ if(nr.left != oldRect.x() || nr.top != oldRect.y()) {
+ widget->data->crect.moveTo(nr.left, nr.top);
+ QMoveEvent qme(widget->data->crect.topLeft(), oldRect.topLeft());
+ QApplication::sendSpontaneousEvent(widget, &qme);
+ }
+ }
+ if((flags & kWindowBoundsChangeSizeChanged)) {
+ if (widget->isWindow()) {
+ QSize newSize = QLayout::closestAcceptableSize(widget, newRect.size());
+ int dh = newSize.height() - newRect.height();
+ int dw = newSize.width() - newRect.width();
+ if (dw != 0 || dh != 0) {
+ handled_event = true; // We want to change the bounds, so we handle the event
+
+ // set the rect, so we can also do the resize down below (yes, we need to resize).
+ newRect.setBottom(newRect.bottom() + dh);
+ newRect.setRight(newRect.right() + dw);
+
+ nr.left = newRect.x();
+ nr.top = newRect.y();
+ nr.right = nr.left + newRect.width();
+ nr.bottom = nr.top + newRect.height();
+ SetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, sizeof(Rect), &nr);
+ }
+ }
+
+ if (oldRect.width() != newRect.width() || oldRect.height() != newRect.height()) {
+ widget->data->crect.setSize(newRect.size());
+ HIRect bounds = CGRectMake(0, 0, newRect.width(), newRect.height());
+
+ // If the WA_StaticContents attribute is set we can optimize the resize
+ // by only repainting the newly exposed area. We do this by disabling
+ // painting when setting the size of the view. The OS will invalidate
+ // the newly exposed area for us.
+ const bool staticContents = widget->testAttribute(Qt::WA_StaticContents);
+ const HIViewRef view = qt_mac_nativeview_for(widget);
+ if (staticContents)
+ HIViewSetDrawingEnabled(view, false);
+ HIViewSetFrame(view, &bounds);
+ if (staticContents)
+ HIViewSetDrawingEnabled(view, true);
+
+ QResizeEvent qre(newRect.size(), oldRect.size());
+ QApplication::sendSpontaneousEvent(widget, &qre);
+ qt_event_request_window_change(widget);
+ }
+ }
+ }
+ } else if (ekind == kEventWindowHidden) {
+ // Make sure that we also hide any visible sheets on our window.
+ // Cocoa does the right thing for us.
+ const QObjectList children = widget->children();
+ const int childCount = children.count();
+ for (int i = 0; i < childCount; ++i) {
+ QObject *obj = children.at(i);
+ if (obj->isWidgetType()) {
+ QWidget *widget = static_cast<QWidget *>(obj);
+ if (qt_mac_is_macsheet(widget) && widget->isVisible())
+ widget->hide();
+ }
+ }
+ } else {
+ handled_event = false;
+ }
+ break; }
+ case kEventClassMouse: {
+#if 0
+ return SendEventToApplication(event);
+#endif
+
+ bool send_to_app = false;
+ {
+ WindowPartCode wpc;
+ if (GetEventParameter(event, kEventParamWindowPartCode, typeWindowPartCode, 0,
+ sizeof(wpc), 0, &wpc) == noErr && wpc != inContent)
+ send_to_app = true;
+ }
+ if(!send_to_app) {
+ WindowRef window;
+ if(GetEventParameter(event, kEventParamWindowRef, typeWindowRef, 0,
+ sizeof(window), 0, &window) == noErr) {
+ HIViewRef hiview;
+ if(HIViewGetViewForMouseEvent(HIViewGetRoot(window), event, &hiview) == noErr) {
+ if(QWidget *w = QWidget::find((WId)hiview)) {
+#if 0
+ send_to_app = !w->isActiveWindow();
+#else
+ Q_UNUSED(w);
+ send_to_app = true;
+#endif
+ }
+ }
+ }
+ }
+ if(send_to_app)
+ return SendEventToApplication(event);
+ handled_event = false;
+ break; }
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+ case kEventClassGesture: {
+ // First, find the widget that was under
+ // the mouse when the gesture happened:
+ HIPoint screenLocation;
+ if (GetEventParameter(event, kEventParamMouseLocation, typeHIPoint, 0,
+ sizeof(screenLocation), 0, &screenLocation) != noErr) {
+ handled_event = false;
+ break;
+ }
+ QWidget *widget = QApplication::widgetAt(screenLocation.x, screenLocation.y);
+ if (!widget) {
+ handled_event = false;
+ break;
+ }
+
+ QNativeGestureEvent qNGEvent;
+ qNGEvent.position = QPoint(screenLocation.x, screenLocation.y);
+
+ switch (ekind) {
+ case kEventGestureStarted:
+ qNGEvent.gestureType = QNativeGestureEvent::GestureBegin;
+ break;
+ case kEventGestureEnded:
+ qNGEvent.gestureType = QNativeGestureEvent::GestureEnd;
+ break;
+ case kEventGestureRotate: {
+ CGFloat amount;
+ if (GetEventParameter(event, kEventParamRotationAmount, typeCGFloat, 0,
+ sizeof(amount), 0, &amount) != noErr) {
+ handled_event = false;
+ break;
+ }
+ qNGEvent.gestureType = QNativeGestureEvent::Rotate;
+ qNGEvent.percentage = float(-amount);
+ break; }
+ case kEventGestureSwipe: {
+ HIPoint swipeDirection;
+ if (GetEventParameter(event, kEventParamSwipeDirection, typeHIPoint, 0,
+ sizeof(swipeDirection), 0, &swipeDirection) != noErr) {
+ handled_event = false;
+ break;
+ }
+ qNGEvent.gestureType = QNativeGestureEvent::Swipe;
+ if (swipeDirection.x == 1)
+ qNGEvent.angle = 180.0f;
+ else if (swipeDirection.x == -1)
+ qNGEvent.angle = 0.0f;
+ else if (swipeDirection.y == 1)
+ qNGEvent.angle = 90.0f;
+ else if (swipeDirection.y == -1)
+ qNGEvent.angle = 270.0f;
+ break; }
+ case kEventGestureMagnify: {
+ CGFloat amount;
+ if (GetEventParameter(event, kEventParamMagnificationAmount, typeCGFloat, 0,
+ sizeof(amount), 0, &amount) != noErr) {
+ handled_event = false;
+ break;
+ }
+ qNGEvent.gestureType = QNativeGestureEvent::Zoom;
+ qNGEvent.percentage = float(amount);
+ break; }
+ }
+
+ QApplication::sendSpontaneousEvent(widget, &qNGEvent);
+ break; }
+#endif // gestures
+
+ default:
+ handled_event = false;
+ }
+ if(!handled_event) //let the event go through
+ return eventNotHandledErr;
+ return noErr; //we eat the event
+}
+
+// widget events
+static HIObjectClassRef widget_class = 0;
+static EventTypeSpec widget_events[] = {
+ { kEventClassHIObject, kEventHIObjectConstruct },
+ { kEventClassHIObject, kEventHIObjectDestruct },
+
+ { kEventClassControl, kEventControlDraw },
+ { kEventClassControl, kEventControlInitialize },
+ { kEventClassControl, kEventControlGetPartRegion },
+ { kEventClassControl, kEventControlGetClickActivation },
+ { kEventClassControl, kEventControlSetFocusPart },
+ { kEventClassControl, kEventControlDragEnter },
+ { kEventClassControl, kEventControlDragWithin },
+ { kEventClassControl, kEventControlDragLeave },
+ { kEventClassControl, kEventControlDragReceive },
+ { kEventClassControl, kEventControlOwningWindowChanged },
+ { kEventClassControl, kEventControlBoundsChanged },
+ { kEventClassControl, kEventControlGetSizeConstraints },
+ { kEventClassControl, kEventControlVisibilityChanged },
+
+ { kEventClassMouse, kEventMouseDown },
+ { kEventClassMouse, kEventMouseUp },
+ { kEventClassMouse, kEventMouseMoved },
+ { kEventClassMouse, kEventMouseDragged }
+};
+static EventHandlerUPP mac_widget_eventUPP = 0;
+static void cleanup_widget_eventUPP()
+{
+ DisposeEventHandlerUPP(mac_widget_eventUPP);
+ mac_widget_eventUPP = 0;
+}
+static const EventHandlerUPP make_widget_eventUPP()
+{
+ if(mac_widget_eventUPP)
+ return mac_widget_eventUPP;
+ qAddPostRoutine(cleanup_widget_eventUPP);
+ return mac_widget_eventUPP = NewEventHandlerUPP(QWidgetPrivate::qt_widget_event);
+}
+OSStatus QWidgetPrivate::qt_widget_event(EventHandlerCallRef er, EventRef event, void *)
+{
+ QScopedLoopLevelCounter loopLevelCounter(QApplicationPrivate::instance()->threadData);
+
+ bool handled_event = true;
+ UInt32 ekind = GetEventKind(event), eclass = GetEventClass(event);
+ switch(eclass) {
+ case kEventClassHIObject: {
+ HIViewRef view = 0;
+ GetEventParameter(event, kEventParamHIObjectInstance, typeHIObjectRef,
+ 0, sizeof(view), 0, &view);
+ if(ekind == kEventHIObjectConstruct) {
+ if(view) {
+ HIViewChangeFeatures(view, kHIViewAllowsSubviews, 0);
+ SetEventParameter(event, kEventParamHIObjectInstance,
+ typeVoidPtr, sizeof(view), &view);
+ }
+ } else if(ekind == kEventHIObjectDestruct) {
+ //nothing to really do.. or is there?
+ } else {
+ handled_event = false;
+ }
+ break; }
+ case kEventClassControl: {
+ QWidget *widget = 0;
+ HIViewRef hiview = 0;
+ if(GetEventParameter(event, kEventParamDirectObject, typeControlRef,
+ 0, sizeof(hiview), 0, &hiview) == noErr)
+ widget = QWidget::find((WId)hiview);
+ if (widget && widget->macEvent(er, event))
+ return noErr;
+ if(ekind == kEventControlDraw) {
+ if(widget && qt_isGenuineQWidget(hiview)) {
+
+ // if there is a window change event pending for any gl child wigets,
+ // send it immediately. (required for flicker-free resizing)
+ extern void qt_mac_send_posted_gl_updates(QWidget *widget);
+ qt_mac_send_posted_gl_updates(widget);
+
+ if (QApplicationPrivate::graphicsSystem() && !widget->d_func()->paintOnScreen()) {
+ widget->d_func()->syncBackingStore();
+ widget->d_func()->dirtyOnWidget = QRegion();
+ return noErr;
+ }
+
+ //requested rgn
+ RgnHandle rgn;
+ GetEventParameter(event, kEventParamRgnHandle, typeQDRgnHandle, 0, sizeof(rgn), 0, &rgn);
+ QRegion qrgn(qt_mac_convert_mac_region(rgn));
+
+ //update handles
+ GrafPtr qd = 0;
+ CGContextRef cg = 0;
+ if(GetEventParameter(event, kEventParamCGContextRef, typeCGContextRef, 0, sizeof(cg), 0, &cg) != noErr) {
+ Q_ASSERT(false);
+ }
+ widget->d_func()->hd = cg;
+ widget->d_func()->qd_hd = qd;
+ CGContextSaveGState(cg);
+
+#ifdef DEBUG_WIDGET_PAINT
+ const bool doDebug = true;
+ if(doDebug) {
+ qDebug("asked to draw %p[%p] [%s::%s] %p[%p] [%d] [%dx%d]", widget, hiview, widget->metaObject()->className(),
+ widget->objectName().local8Bit().data(), widget->parentWidget(),
+ (HIViewRef)(widget->parentWidget() ? qt_mac_nativeview_for(widget->parentWidget()) : (HIViewRef)0),
+ HIViewIsCompositingEnabled(hiview), qt_mac_posInWindow(widget).x(), qt_mac_posInWindow(widget).y());
+#if 0
+ QVector<QRect> region_rects = qrgn.rects();
+ qDebug("Region! %d", region_rects.count());
+ for(int i = 0; i < region_rects.count(); i++)
+ qDebug("%d %d %d %d", region_rects[i].x(), region_rects[i].y(),
+ region_rects[i].width(), region_rects[i].height());
+ region_rects = widget->d_func()->clp.rects();
+ qDebug("Widget Region! %d", region_rects.count());
+ for(int i = 0; i < region_rects.count(); i++)
+ qDebug("%d %d %d %d", region_rects[i].x(), region_rects[i].y(),
+ region_rects[i].width(), region_rects[i].height());
+#endif
+ }
+#endif
+ if (widget->isVisible() && widget->updatesEnabled()) { //process the actual paint event.
+ if(widget->testAttribute(Qt::WA_WState_InPaintEvent))
+ qWarning("QWidget::repaint: Recursive repaint detected");
+
+ QPoint redirectionOffset(0, 0);
+ QWidget *tl = widget->window();
+ if (tl) {
+ Qt::WindowFlags flags = tl->windowFlags();
+ if (flags & Qt::FramelessWindowHint
+ || (flags & Qt::CustomizeWindowHint && !(flags & Qt::WindowTitleHint))) {
+ if(tl->d_func()->extra && !tl->d_func()->extra->mask.isEmpty())
+ redirectionOffset += tl->d_func()->extra->mask.boundingRect().topLeft();
+ }
+ }
+
+ //setup the context
+ widget->setAttribute(Qt::WA_WState_InPaintEvent);
+ QPaintEngine *engine = widget->paintEngine();
+ if (engine)
+ engine->setSystemClip(qrgn);
+
+ //handle the erase
+ if (engine && (!widget->testAttribute(Qt::WA_NoSystemBackground)
+ && (widget->isWindow() || widget->autoFillBackground())
+ || widget->testAttribute(Qt::WA_TintedBackground)
+ || widget->testAttribute(Qt::WA_StyledBackground))) {
+#ifdef DEBUG_WIDGET_PAINT
+ if(doDebug)
+ qDebug(" Handling erase for [%s::%s]", widget->metaObject()->className(),
+ widget->objectName().local8Bit().data());
+#endif
+ if (!redirectionOffset.isNull())
+ widget->d_func()->setRedirected(widget, redirectionOffset);
+
+ bool was_unclipped = widget->testAttribute(Qt::WA_PaintUnclipped);
+ widget->setAttribute(Qt::WA_PaintUnclipped, false);
+ QPainter p(widget);
+ p.setClipping(false);
+ if(was_unclipped)
+ widget->setAttribute(Qt::WA_PaintUnclipped);
+ widget->d_func()->paintBackground(&p, qrgn, widget->isWindow() ? DrawAsRoot : 0);
+ if (widget->testAttribute(Qt::WA_TintedBackground)) {
+ QColor tint = widget->palette().window().color();
+ tint.setAlphaF(.6);
+ const QVector<QRect> &rects = qrgn.rects();
+ for (int i = 0; i < rects.size(); ++i)
+ p.fillRect(rects.at(i), tint);
+ }
+ p.end();
+ if (!redirectionOffset.isNull())
+ widget->d_func()->restoreRedirected();
+ }
+
+ if (widget->isWindow() && !widget->d_func()->isOpaque
+ && !widget->testAttribute(Qt::WA_MacBrushedMetal)) {
+ QRect qrgnRect = qrgn.boundingRect();
+ CGContextClearRect(cg, CGRectMake(qrgnRect.x(), qrgnRect.y(), qrgnRect.width(), qrgnRect.height()));
+ }
+
+
+ if(!HIObjectIsOfClass((HIObjectRef)hiview, kObjectQWidget))
+ CallNextEventHandler(er, event);
+
+ //send the paint
+ redirectionOffset += widget->data->wrect.topLeft(); // Map from system to qt coordinates
+ if (!redirectionOffset.isNull())
+ widget->d_func()->setRedirected(widget, redirectionOffset);
+ qrgn.translate(redirectionOffset);
+ QPaintEvent e(qrgn);
+ widget->d_func()->dirtyOnWidget = QRegion();
+#ifdef QT3_SUPPORT
+ e.setErased(true);
+#endif
+ QApplication::sendSpontaneousEvent(widget, &e);
+ if (!redirectionOffset.isNull())
+ widget->d_func()->restoreRedirected();
+
+ //cleanup
+ if (engine)
+ engine->setSystemClip(QRegion());
+
+ widget->setAttribute(Qt::WA_WState_InPaintEvent, false);
+ if(!widget->testAttribute(Qt::WA_PaintOutsidePaintEvent) && widget->paintingActive())
+ qWarning("QWidget: It is dangerous to leave painters active on a widget outside of the PaintEvent");
+ }
+
+ widget->d_func()->hd = 0;
+ widget->d_func()->qd_hd = 0;
+ CGContextRestoreGState(cg);
+ } else if(!HIObjectIsOfClass((HIObjectRef)hiview, kObjectQWidget)) {
+ CallNextEventHandler(er, event);
+ }
+ } else if(ekind == kEventControlInitialize) {
+ if(HIObjectIsOfClass((HIObjectRef)hiview, kObjectQWidget)) {
+ UInt32 features = kControlSupportsDragAndDrop | kControlSupportsClickActivation | kControlSupportsFocus;
+ SetEventParameter(event, kEventParamControlFeatures, typeUInt32, sizeof(features), &features);
+ } else {
+ handled_event = false;
+ }
+ } else if(ekind == kEventControlSetFocusPart) {
+ if(widget) {
+ ControlPartCode part;
+ GetEventParameter(event, kEventParamControlPart, typeControlPartCode, 0,
+ sizeof(part), 0, &part);
+ if(part == kControlFocusNoPart){
+ if (widget->hasFocus())
+ QApplicationPrivate::setFocusWidget(0, Qt::OtherFocusReason);
+ } else
+ widget->setFocus();
+ }
+ if(!HIObjectIsOfClass((HIObjectRef)hiview, kObjectQWidget))
+ CallNextEventHandler(er, event);
+ } else if(ekind == kEventControlGetClickActivation) {
+ ClickActivationResult clickT = kActivateAndIgnoreClick;
+ SetEventParameter(event, kEventParamClickActivation, typeClickActivationResult,
+ sizeof(clickT), &clickT);
+ } else if(ekind == kEventControlGetPartRegion) {
+ handled_event = false;
+ if(!HIObjectIsOfClass((HIObjectRef)hiview, kObjectQWidget) && CallNextEventHandler(er, event) == noErr) {
+ handled_event = true;
+ break;
+ }
+ if(widget && !widget->isWindow()) {
+ ControlPartCode part;
+ GetEventParameter(event, kEventParamControlPart, typeControlPartCode, 0,
+ sizeof(part), 0, &part);
+ if(part == kControlClickableMetaPart && widget->testAttribute(Qt::WA_TransparentForMouseEvents)) {
+ RgnHandle rgn;
+ GetEventParameter(event, kEventParamControlRegion, typeQDRgnHandle, 0,
+ sizeof(rgn), 0, &rgn);
+ SetEmptyRgn(rgn);
+ handled_event = true;
+ } else if(part == kControlStructureMetaPart || part == kControlClickableMetaPart) {
+ RgnHandle rgn;
+ GetEventParameter(event, kEventParamControlRegion, typeQDRgnHandle, 0,
+ sizeof(rgn), 0, &rgn);
+ SetRectRgn(rgn, 0, 0, widget->width(), widget->height());
+ if(QWidgetPrivate::qt_widget_rgn(widget, kWindowStructureRgn, rgn, false))
+ handled_event = true;
+ } else if(part == kControlOpaqueMetaPart) {
+ if(widget->d_func()->isOpaque) {
+ RgnHandle rgn;
+ GetEventParameter(event, kEventParamControlRegion, typeQDRgnHandle, 0,
+ sizeof(RgnHandle), 0, &rgn);
+ SetRectRgn(rgn, 0, 0, widget->width(), widget->height());
+ QWidgetPrivate::qt_widget_rgn(widget, kWindowStructureRgn, rgn, false);
+ SetEventParameter(event, kEventParamControlRegion, typeQDRgnHandle,
+ sizeof(RgnHandle), &rgn);
+ handled_event = true;
+ }
+ }
+ }
+ } else if(ekind == kEventControlOwningWindowChanged) {
+ if(!HIObjectIsOfClass((HIObjectRef)hiview, kObjectQWidget))
+ CallNextEventHandler(er, event);
+ if(widget && qt_mac_window_for(hiview)) {
+ WindowRef foo = 0;
+ GetEventParameter(event, kEventParamControlCurrentOwningWindow, typeWindowRef, 0,
+ sizeof(foo), 0, &foo);
+ widget->d_func()->initWindowPtr();
+ }
+ if (widget)
+ qt_event_request_window_change(widget);
+ } else if(ekind == kEventControlDragEnter || ekind == kEventControlDragWithin ||
+ ekind == kEventControlDragLeave || ekind == kEventControlDragReceive) {
+ // dnd are really handled in qdnd_mac.cpp,
+ // just modularize the code a little...
+ DragRef drag;
+ GetEventParameter(event, kEventParamDragRef, typeDragRef, 0, sizeof(drag), 0, &drag);
+ handled_event = false;
+ bool drag_allowed = false;
+
+ QWidget *dropWidget = widget;
+ if (qobject_cast<QFocusFrame *>(widget)){
+ // We might shadow widgets underneath the focus
+ // frame, so stay interrested, and let the dnd through
+ drag_allowed = true;
+ handled_event = true;
+ Point where;
+ GetDragMouse(drag, &where, 0);
+ dropWidget = QApplication::widgetAt(QPoint(where.h, where.v));
+
+ if (dropWidget != QDragManager::self()->currentTarget()) {
+ // We have to 'fake' enter and leave events for the shaddowed widgets:
+ if (ekind == kEventControlDragEnter) {
+ if (QDragManager::self()->currentTarget())
+ QDragManager::self()->currentTarget()->d_func()->qt_mac_dnd_event(kEventControlDragLeave, drag);
+ if (dropWidget) {
+ dropWidget->d_func()->qt_mac_dnd_event(kEventControlDragEnter, drag);
+ }
+ // Set dropWidget to zero, so qt_mac_dnd_event
+ // doesn't get called a second time below:
+ dropWidget = 0;
+ } else if (ekind == kEventControlDragLeave) {
+ dropWidget = QDragManager::self()->currentTarget();
+ if (dropWidget) {
+ dropWidget->d_func()->qt_mac_dnd_event(kEventControlDragLeave, drag);
+ }
+ // Set dropWidget to zero, so qt_mac_dnd_event
+ // doesn't get called a second time below:
+ dropWidget = 0;
+ }
+ }
+ }
+
+ // Send the dnd event to the widget:
+ if (dropWidget && dropWidget->d_func()->qt_mac_dnd_event(ekind, drag)) {
+ drag_allowed = true;
+ handled_event = true;
+ }
+
+ if (ekind == kEventControlDragEnter) {
+ // If we don't accept the enter event, we will
+ // receive no more drag events for this widget
+ const Boolean wouldAccept = drag_allowed ? true : false;
+ SetEventParameter(event, kEventParamControlWouldAcceptDrop, typeBoolean,
+ sizeof(wouldAccept), &wouldAccept);
+ }
+ } else if (ekind == kEventControlBoundsChanged) {
+ if (!widget || widget->isWindow() || widget->testAttribute(Qt::WA_Moved) || widget->testAttribute(Qt::WA_Resized)) {
+ handled_event = false;
+ } else {
+ // Sync our view in case some other (non-Qt) view is controlling us.
+ handled_event = true;
+ Rect newBounds;
+ GetEventParameter(event, kEventParamCurrentBounds,
+ typeQDRectangle, 0, sizeof(Rect), 0, &newBounds);
+ QRect rect(newBounds.left, newBounds.top,
+ newBounds.right - newBounds.left, newBounds.bottom - newBounds.top);
+
+ bool moved = widget->testAttribute(Qt::WA_Moved);
+ bool resized = widget->testAttribute(Qt::WA_Resized);
+ widget->setGeometry(rect);
+ widget->setAttribute(Qt::WA_Moved, moved);
+ widget->setAttribute(Qt::WA_Resized, resized);
+ qt_event_request_window_change(widget);
+ }
+ } else if (ekind == kEventControlGetSizeConstraints) {
+ if (!widget || !qt_isGenuineQWidget(widget)) {
+ handled_event = false;
+ } else {
+ handled_event = true;
+ QWidgetItem item(widget);
+ QSize size = item.minimumSize();
+ HISize hisize = { size.width(), size.height() };
+ SetEventParameter(event, kEventParamMinimumSize, typeHISize, sizeof(HISize), &hisize);
+ size = item.maximumSize();
+ hisize.width = size.width() + 2; // ### shouldn't have to add 2 (but it works).
+ hisize.height = size.height();
+ SetEventParameter(event, kEventParamMaximumSize, typeHISize, sizeof(HISize), &hisize);
+ }
+ } else if (ekind == kEventControlVisibilityChanged) {
+ handled_event = false;
+ if (widget) {
+ qt_event_request_window_change(widget);
+ if (!HIViewIsVisible(HIViewRef(widget->winId()))) {
+ extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
+ if (widget == qt_button_down)
+ qt_button_down = 0;
+ }
+ }
+ }
+ break; }
+ case kEventClassMouse: {
+ bool send_to_app = false;
+ extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp
+ if(qt_button_down)
+ send_to_app = true;
+ if(send_to_app) {
+ OSStatus err = SendEventToApplication(event);
+ if(err != noErr)
+ handled_event = false;
+ } else {
+ CallNextEventHandler(er, event);
+ }
+ break; }
+ default:
+ handled_event = false;
+ break;
+ }
+ if(!handled_event) //let the event go through
+ return eventNotHandledErr;
+ return noErr; //we eat the event
+}
+#endif
+
+OSViewRef qt_mac_create_widget(QWidget *widget, QWidgetPrivate *widgetPrivate, OSViewRef parent)
+{
+#ifdef QT_MAC_USE_COCOA
+ QMacCocoaAutoReleasePool pool;
+ QT_MANGLE_NAMESPACE(QCocoaView) *view = [[QT_MANGLE_NAMESPACE(QCocoaView) alloc] initWithQWidget:widget widgetPrivate:widgetPrivate];
+ if (view && parent)
+ [parent addSubview:view];
+ return view;
+#else
+ Q_UNUSED(widget);
+ Q_UNUSED(widgetPrivate);
+ if(!widget_class) {
+ OSStatus err = HIObjectRegisterSubclass(kObjectQWidget, kHIViewClassID, 0, make_widget_eventUPP(),
+ GetEventTypeCount(widget_events), widget_events,
+ 0, &widget_class);
+ if (err && err != hiObjectClassExistsErr)
+ qWarning("QWidget: Internal error (%d)", __LINE__);
+ }
+ HIViewRef ret = 0;
+ if(HIObjectCreate(kObjectQWidget, 0, (HIObjectRef*)&ret) != noErr)
+ qWarning("QWidget: Internal error (%d)", __LINE__);
+ if(ret && parent)
+ HIViewAddSubview(parent, ret);
+ return ret;
+#endif
+}
+
+void qt_mac_unregister_widget()
+{
+#ifndef QT_MAC_USE_COCOA
+ HIObjectUnregisterClass(widget_class);
+ widget_class = 0;
+#endif
+}
+
+void QWidgetPrivate::toggleDrawers(bool visible)
+{
+ for (int i = 0; i < children.size(); ++i) {
+ register QObject *object = children.at(i);
+ if (!object->isWidgetType())
+ continue;
+ QWidget *widget = static_cast<QWidget*>(object);
+ if(qt_mac_is_macdrawer(widget)) {
+ if(visible) {
+ if (!widget->testAttribute(Qt::WA_WState_ExplicitShowHide))
+ widget->show();
+ } else {
+ widget->hide();
+ widget->setAttribute(Qt::WA_WState_ExplicitShowHide, false);
+ }
+ }
+ }
+}
+
+/*****************************************************************************
+ QWidgetPrivate member functions
+ *****************************************************************************/
+bool QWidgetPrivate::qt_mac_update_sizer(QWidget *w, int up)
+{
+ // I'm not sure what "up" is
+ if(!w || !w->isWindow())
+ return false;
+
+ QTLWExtra *topData = w->d_func()->topData();
+ QWExtra *extraData = w->d_func()->extraData();
+ // topData->resizer is only 4 bits, so subtracting -1 from zero causes bad stuff
+ // to happen, prevent that here (you really want the thing hidden).
+ if (up >= 0 || topData->resizer != 0)
+ topData->resizer += up;
+ OSWindowRef windowRef = qt_mac_window_for(OSViewRef(w->winId()));
+ {
+#ifndef QT_MAC_USE_COCOA
+ WindowClass wclass;
+ GetWindowClass(windowRef, &wclass);
+ if(!(GetAvailableWindowAttributes(wclass) & kWindowResizableAttribute))
+ return true;
+#endif
+ }
+ bool remove_grip = (topData->resizer || (w->windowFlags() & Qt::FramelessWindowHint)
+ || (extraData->maxw && extraData->maxh &&
+ extraData->maxw == extraData->minw && extraData->maxh == extraData->minh));
+#ifndef QT_MAC_USE_COCOA
+ WindowAttributes attr;
+ GetWindowAttributes(windowRef, &attr);
+ if(remove_grip) {
+ if(attr & kWindowResizableAttribute) {
+ ChangeWindowAttributes(qt_mac_window_for(w), kWindowNoAttributes,
+ kWindowResizableAttribute);
+ ReshapeCustomWindow(qt_mac_window_for(w));
+ }
+ } else if(!(attr & kWindowResizableAttribute)) {
+ ChangeWindowAttributes(windowRef, kWindowResizableAttribute,
+ kWindowNoAttributes);
+ ReshapeCustomWindow(windowRef);
+ }
+#else
+ [windowRef setShowsResizeIndicator:!remove_grip];
+#endif
+ return true;
+}
+
+void QWidgetPrivate::qt_clean_root_win()
+{
+#ifdef QT_MAC_USE_COCOA
+ [qt_root_win release];
+#else
+ if(!qt_root_win)
+ return;
+ CFRelease(qt_root_win);
+#endif
+ qt_root_win = 0;
+}
+
+bool QWidgetPrivate::qt_create_root_win()
+{
+ if(qt_root_win)
+ return false;
+ const QSize desktopSize = qt_mac_desktopSize();
+ QRect desktopRect(QPoint(0, 0), desktopSize);
+#ifdef QT_MAC_USE_COCOA
+ qt_root_win = qt_mac_create_window(0, kOverlayWindowClass, NSBorderlessWindowMask, desktopRect);
+#else
+ WindowAttributes wattr = (kWindowCompositingAttribute | kWindowStandardHandlerAttribute);
+ qt_root_win = qt_mac_create_window(0, kOverlayWindowClass, wattr, desktopRect);
+#endif
+ if(!qt_root_win)
+ return false;
+ qAddPostRoutine(qt_clean_root_win);
+ return true;
+}
+
+bool QWidgetPrivate::qt_widget_rgn(QWidget *widget, short wcode, RgnHandle rgn, bool force = false)
+{
+ bool ret = false;
+#ifndef QT_MAC_USE_COCOA
+ switch(wcode) {
+ case kWindowStructureRgn: {
+ if(widget) {
+ if(widget->d_func()->extra && !widget->d_func()->extra->mask.isEmpty()) {
+ QRegion rin = qt_mac_convert_mac_region(rgn);
+ if(!rin.isEmpty()) {
+ QPoint rin_tl = rin.boundingRect().topLeft(); //in offset
+ rin.translate(-rin_tl.x(), -rin_tl.y()); //bring into same space as below
+ QRegion mask = widget->d_func()->extra->mask;
+ Qt::WindowFlags flags = widget->windowFlags();
+ if(widget->isWindow()
+ && !(flags & Qt::FramelessWindowHint
+ || (flags & Qt::CustomizeWindowHint && !(flags & Qt::WindowTitleHint)))) {
+ QRegion title;
+ {
+ QMacSmartQuickDrawRegion rgn(qt_mac_get_rgn());
+ GetWindowRegion(qt_mac_window_for(widget), kWindowTitleBarRgn, rgn);
+ title = qt_mac_convert_mac_region(rgn);
+ }
+ QRect br = title.boundingRect();
+ mask.translate(0, br.height()); //put the mask 'under' the title bar..
+ title.translate(-br.x(), -br.y());
+ mask += title;
+ }
+
+ QRegion cr = rin & mask;
+ cr.translate(rin_tl.x(), rin_tl.y()); //translate back to incoming space
+ CopyRgn(QMacSmartQuickDrawRegion(cr.toQDRgn()), rgn);
+ }
+ ret = true;
+ } else if(force) {
+ QRegion cr(widget->geometry());
+ CopyRgn(QMacSmartQuickDrawRegion(cr.toQDRgn()), rgn);
+ ret = true;
+ }
+ }
+ break; }
+ default: break;
+ }
+ //qDebug() << widget << ret << wcode << qt_mac_convert_mac_region(rgn);
+#else
+ Q_UNUSED(widget);
+ Q_UNUSED(wcode);
+ Q_UNUSED(rgn);
+ Q_UNUSED(force);
+#endif
+ return ret;
+}
+
+/*****************************************************************************
+ QWidget member functions
+ *****************************************************************************/
+void QWidgetPrivate::determineWindowClass()
+{
+ Q_Q(QWidget);
+#ifndef QT_MAC_USE_COCOA
+// ### COCOA:Interleave these better!
+
+ const Qt::WindowType type = q->windowType();
+ Qt::WindowFlags &flags = data.window_flags;
+ const bool popup = (type == Qt::Popup);
+ if (type == Qt::ToolTip || type == Qt::SplashScreen || popup)
+ flags |= Qt::FramelessWindowHint;
+
+ WindowClass wclass = kSheetWindowClass;
+ if(qt_mac_is_macdrawer(q))
+ 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))
+ 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
+ wclass = kDocumentWindowClass;
+
+ WindowGroupRef grp = 0;
+ WindowAttributes wattr = (kWindowCompositingAttribute | kWindowStandardHandlerAttribute);
+ if (q->testAttribute(Qt::WA_MacFrameworkScaled))
+ wattr |= kWindowFrameworkScaledAttribute;
+ if(qt_mac_is_macsheet(q)) {
+ //grp = GetWindowGroupOfClass(kMovableModalWindowClass);
+ wclass = kSheetWindowClass;
+ } else {
+ grp = GetWindowGroupOfClass(wclass);
+ // Shift things around a bit to get the correct window class based on the presence
+ // (or lack) of the border.
+ bool customize = flags & Qt::CustomizeWindowHint;
+ bool framelessWindow = (flags & Qt::FramelessWindowHint || (customize && !(flags & Qt::WindowTitleHint)));
+ if (framelessWindow) {
+ if(wclass == kDocumentWindowClass) {
+ wattr |= kWindowNoTitleBarAttribute;
+ } else if(wclass == kFloatingWindowClass) {
+ wattr |= kWindowNoTitleBarAttribute;
+ } else if (wclass == kMovableModalWindowClass) {
+ wclass = kModalWindowClass;
+ }
+ } else {
+ if(wclass != kModalWindowClass)
+ wattr |= kWindowResizableAttribute;
+ }
+ // Only add extra decorations (well, buttons) for widgets that can have them
+ // and have an actual border we can put them on.
+ if(wclass != kModalWindowClass && wclass != kMovableModalWindowClass
+ && wclass != kSheetWindowClass && wclass != kPlainWindowClass
+ && !framelessWindow && wclass != kDrawerWindowClass
+ && wclass != kHelpWindowClass) {
+ if (flags & Qt::WindowMaximizeButtonHint)
+ wattr |= kWindowFullZoomAttribute;
+ if (flags & Qt::WindowMinimizeButtonHint)
+ wattr |= kWindowCollapseBoxAttribute;
+ if (flags & Qt::WindowSystemMenuHint || flags & Qt::WindowCloseButtonHint)
+ wattr |= kWindowCloseBoxAttribute;
+ if (flags & Qt::MacWindowToolBarButtonHint)
+ wattr |= kWindowToolbarButtonAttribute;
+ } else {
+ // Clear these hints so that we aren't call them on invalid windows
+ flags &= ~(Qt::WindowMaximizeButtonHint | Qt::WindowMinimizeButtonHint
+ | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint);
+ }
+ }
+ if((popup || type == Qt::Tool) && !q->isModal())
+ wattr |= kWindowHideOnSuspendAttribute;
+ wattr |= kWindowLiveResizeAttribute;
+
+#ifdef DEBUG_WINDOW_CREATE
+#define ADD_DEBUG_WINDOW_NAME(x) { x, #x }
+ struct {
+ UInt32 tag;
+ const char *name;
+ } known_attribs[] = {
+ ADD_DEBUG_WINDOW_NAME(kWindowCompositingAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowStandardHandlerAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowMetalAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowHideOnSuspendAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowStandardHandlerAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowCollapseBoxAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowHorizontalZoomAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowVerticalZoomAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowResizableAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowNoActivatesAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowNoUpdatesAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowOpaqueForEventsAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowLiveResizeAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowCloseBoxAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowHideOnSuspendAttribute),
+ { 0, 0 }
+ }, known_classes[] = {
+ ADD_DEBUG_WINDOW_NAME(kHelpWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kPlainWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kDrawerWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kUtilityWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kToolbarWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kSheetWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kFloatingWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kUtilityWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kDocumentWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kToolbarWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kMovableModalWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kModalWindowClass),
+ { 0, 0 }
+ };
+ qDebug("Qt: internal: ************* Creating new window %p (%s::%s)", q, q->metaObject()->className(),
+ q->objectName().toLocal8Bit().constData());
+ bool found_class = false;
+ for(int i = 0; known_classes[i].name; i++) {
+ if(wclass == known_classes[i].tag) {
+ found_class = true;
+ qDebug("Qt: internal: ** Class: %s", known_classes[i].name);
+ break;
+ }
+ }
+ if(!found_class)
+ qDebug("Qt: internal: !! Class: Unknown! (%d)", (int)wclass);
+ if(wattr) {
+ 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);
+ }
+#endif
+
+ /* Just to be extra careful we will change to the kUtilityWindowClass if the
+ requested attributes cannot be used */
+ if((GetAvailableWindowAttributes(wclass) & wattr) != wattr) {
+ WindowClass tmp_class = wclass;
+ if(wclass == kToolbarWindowClass || wclass == kUtilityWindowClass)
+ wclass = kFloatingWindowClass;
+ if(tmp_class != wclass) {
+ if(!grp)
+ grp = GetWindowGroupOfClass(wclass);
+ wclass = tmp_class;
+ }
+ }
+ topData()->wclass = wclass;
+ topData()->wattr = wattr;
+#else
+ const Qt::WindowType type = q->windowType();
+ Qt::WindowFlags &flags = data.window_flags;
+ const bool popup = (type == Qt::Popup);
+ if (type == Qt::ToolTip || type == Qt::SplashScreen || popup)
+ flags |= Qt::FramelessWindowHint;
+
+ WindowClass wclass = kSheetWindowClass;
+ if(qt_mac_is_macdrawer(q))
+ 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)
+ 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
+ wclass = kDocumentWindowClass;
+
+ WindowAttributes wattr = NSBorderlessWindowMask;
+ if(qt_mac_is_macsheet(q)) {
+ //grp = GetWindowGroupOfClass(kMovableModalWindowClass);
+ wclass = kSheetWindowClass;
+ wattr = NSTitledWindowMask | NSResizableWindowMask;
+ } else {
+#ifndef QT_MAC_USE_COCOA
+ grp = GetWindowGroupOfClass(wclass);
+#endif
+ // Shift things around a bit to get the correct window class based on the presence
+ // (or lack) of the border.
+ bool customize = flags & Qt::CustomizeWindowHint;
+ bool framelessWindow = (flags & Qt::FramelessWindowHint || (customize && !(flags & Qt::WindowTitleHint)));
+ if (framelessWindow) {
+ if (wclass == kDocumentWindowClass) {
+ wclass = kSimpleWindowClass;
+ } else if (wclass == kFloatingWindowClass) {
+ wclass = kToolbarWindowClass;
+ } else if (wclass == kMovableModalWindowClass) {
+ wclass = kModalWindowClass;
+ }
+ } else {
+ wattr |= NSTitledWindowMask;
+ if (wclass != kModalWindowClass)
+ wattr |= NSResizableWindowMask;
+ }
+ // Only add extra decorations (well, buttons) for widgets that can have them
+ // and have an actual border we can put them on.
+ if (wclass != kModalWindowClass
+ && wclass != kSheetWindowClass && wclass != kPlainWindowClass
+ && !framelessWindow && wclass != kDrawerWindowClass
+ && wclass != kHelpWindowClass) {
+ if (flags & Qt::WindowMinimizeButtonHint)
+ wattr |= NSMiniaturizableWindowMask;
+ if (flags & Qt::WindowSystemMenuHint || flags & Qt::WindowCloseButtonHint)
+ wattr |= NSClosableWindowMask;
+ } else {
+ // Clear these hints so that we aren't call them on invalid windows
+ flags &= ~(Qt::WindowMaximizeButtonHint | Qt::WindowMinimizeButtonHint
+ | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint);
+ }
+ }
+ if (q->testAttribute(Qt::WA_MacBrushedMetal))
+ wattr |= NSTexturedBackgroundWindowMask;
+
+#ifdef DEBUG_WINDOW_CREATE
+#define ADD_DEBUG_WINDOW_NAME(x) { x, #x }
+ struct {
+ UInt32 tag;
+ const char *name;
+ } known_attribs[] = {
+ ADD_DEBUG_WINDOW_NAME(kWindowCompositingAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowStandardHandlerAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowMetalAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowHideOnSuspendAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowStandardHandlerAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowCollapseBoxAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowHorizontalZoomAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowVerticalZoomAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowResizableAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowNoActivatesAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowNoUpdatesAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowOpaqueForEventsAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowLiveResizeAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowCloseBoxAttribute),
+ ADD_DEBUG_WINDOW_NAME(kWindowHideOnSuspendAttribute),
+ { 0, 0 }
+ }, known_classes[] = {
+ ADD_DEBUG_WINDOW_NAME(kHelpWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kPlainWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kDrawerWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kUtilityWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kToolbarWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kSheetWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kFloatingWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kUtilityWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kDocumentWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kToolbarWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kMovableModalWindowClass),
+ ADD_DEBUG_WINDOW_NAME(kModalWindowClass),
+ { 0, 0 }
+ };
+ qDebug("Qt: internal: ************* Creating new window %p (%s::%s)", q, q->metaObject()->className(),
+ q->objectName().toLocal8Bit().constData());
+ bool found_class = false;
+ for(int i = 0; known_classes[i].name; i++) {
+ if(wclass == known_classes[i].tag) {
+ found_class = true;
+ qDebug("Qt: internal: ** Class: %s", known_classes[i].name);
+ break;
+ }
+ }
+ if(!found_class)
+ qDebug("Qt: internal: !! Class: Unknown! (%d)", (int)wclass);
+ if(wattr) {
+ 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);
+ }
+#endif
+
+#ifndef QT_MAC_USE_COCOA
+ /* Just to be extra careful we will change to the kUtilityWindowClass if the
+ requested attributes cannot be used */
+ if((GetAvailableWindowAttributes(wclass) & wattr) != wattr) {
+ WindowClass tmp_class = wclass;
+ if(wclass == kToolbarWindowClass || wclass == kUtilityWindowClass)
+ wclass = kFloatingWindowClass;
+ if(tmp_class != wclass) {
+ if(!grp)
+ grp = GetWindowGroupOfClass(wclass);
+ wclass = tmp_class;
+ }
+ }
+#endif
+#endif
+ topData()->wclass = wclass;
+ topData()->wattr = wattr;
+}
+
+#ifndef QT_MAC_USE_COCOA // This is handled in Cocoa via our category.
+void QWidgetPrivate::initWindowPtr()
+{
+ Q_Q(QWidget);
+ OSWindowRef windowRef = qt_mac_window_for(qt_mac_nativeview_for(q)); //do not create!
+ if(!windowRef)
+ return;
+ QWidget *window = q->window(), *oldWindow = 0;
+ if(GetWindowProperty(windowRef, kWidgetCreatorQt, kWidgetPropertyQWidget, sizeof(oldWindow), 0, &oldWindow) == noErr) {
+ Q_ASSERT(window == oldWindow);
+ return;
+ }
+
+ if(SetWindowProperty(windowRef, kWidgetCreatorQt, kWidgetPropertyQWidget, sizeof(window), &window) != noErr)
+ qWarning("Qt:Internal error (%s:%d)", __FILE__, __LINE__); //no real way to recover
+ if(!q->windowType() != Qt::Desktop) { //setup an event callback handler on the window
+ InstallWindowEventHandler(windowRef, make_win_eventUPP(), GetEventTypeCount(window_events),
+ window_events, static_cast<void *>(qApp), &window_event);
+ }
+}
+
+void QWidgetPrivate::finishCreateWindow_sys_Carbon(OSWindowRef windowRef)
+{
+ Q_Q(QWidget);
+ const Qt::WindowType type = q->windowType();
+ Qt::WindowFlags &flags = data.window_flags;
+ QWidget *parentWidget = q->parentWidget();
+
+ const bool desktop = (type == Qt::Desktop);
+ const bool dialog = (type == Qt::Dialog
+ || type == Qt::Sheet
+ || type == Qt::Drawer
+ || (flags & Qt::MSWindowsFixedSizeDialogHint));
+ QTLWExtra *topExtra = topData();
+ quint32 wattr = topExtra->wattr;
+ if (!desktop)
+ SetAutomaticControlDragTrackingEnabledForWindow(windowRef, true);
+ HIWindowChangeFeatures(windowRef, kWindowCanCollapse, 0);
+ if (wattr & kWindowHideOnSuspendAttribute)
+ HIWindowChangeAvailability(windowRef, kHIWindowExposeHidden, 0);
+ else
+ HIWindowChangeAvailability(windowRef, 0, kHIWindowExposeHidden);
+ if ((flags & Qt::WindowStaysOnTopHint))
+ ChangeWindowAttributes(windowRef, kWindowNoAttributes, kWindowHideOnSuspendAttribute);
+ if (qt_mac_is_macdrawer(q) && parentWidget)
+ SetDrawerParent(windowRef, qt_mac_window_for (parentWidget));
+ if (topExtra->group) {
+ qt_mac_release_window_group(topExtra->group);
+ topExtra->group = 0;
+ }
+ if (type == Qt::ToolTip)
+ qt_mac_set_window_group_to_tooltip(windowRef);
+ else if (type == Qt::Popup && (flags & Qt::WindowStaysOnTopHint))
+ qt_mac_set_window_group_to_popup(windowRef);
+ else if (flags & Qt::WindowStaysOnTopHint)
+ qt_mac_set_window_group_to_stays_on_top(windowRef, type);
+ else if (dialog)
+ SetWindowGroup(windowRef, GetWindowGroupOfClass(kMovableModalWindowClass));
+
+#ifdef DEBUG_WINDOW_CREATE
+ if (WindowGroupRef grpf = GetWindowGroup(windowRef)) {
+ QCFString cfname;
+ CopyWindowGroupName(grpf, &cfname);
+ SInt32 lvl;
+ GetWindowGroupLevel(grpf, &lvl);
+ const char *from = "Default";
+ if (topExtra && grpf == topData()->group)
+ from = "Created";
+ else if (grpf == grp)
+ from = "Copied";
+ qDebug("Qt: internal: With window group '%s' [%p] @ %d: %s",
+ static_cast<QString>(cfname).toLatin1().constData(), grpf, (int)lvl, from);
+ } else {
+ qDebug("Qt: internal: No window group!!!");
+ }
+ HIWindowAvailability hi_avail = 0;
+ if (HIWindowGetAvailability(windowRef, &hi_avail) == noErr) {
+ struct {
+ UInt32 tag;
+ const char *name;
+ } known_avail[] = {
+ ADD_DEBUG_WINDOW_NAME(kHIWindowExposeHidden),
+ { 0, 0 }
+ };
+ qDebug("Qt: internal: ** HIWindowAvailibility:");
+ for (int i = 0; hi_avail && known_avail[i].name; i++) {
+ if ((hi_avail & known_avail[i].tag) == known_avail[i].tag) {
+ hi_avail ^= known_avail[i].tag;
+ qDebug("Qt: internal: * %s", known_avail[i].name);
+ }
+ }
+ if (hi_avail)
+ qDebug("Qt: internal: !! Attributes: Unknown (%d)", (int)hi_avail);
+ }
+#undef ADD_DEBUG_WINDOW_NAME
+#endif
+ if (extra && !extra->mask.isEmpty())
+ ReshapeCustomWindow(windowRef);
+ SetWindowModality(windowRef, kWindowModalityNone, 0);
+ if (qt_mac_is_macdrawer(q))
+ SetDrawerOffsets(windowRef, 0.0, 25.0);
+ data.fstrut_dirty = true; // when we create a toplevel widget, the frame strut should be dirty
+ HIViewRef hiview = (HIViewRef)data.winid;
+ HIViewRef window_hiview = qt_mac_get_contentview_for(windowRef);
+ if(!hiview) {
+ hiview = qt_mac_create_widget(q, this, window_hiview);
+ setWinId((WId)hiview);
+ } else {
+ HIViewAddSubview(window_hiview, hiview);
+ }
+ if (hiview) {
+ Rect win_rect;
+ GetWindowBounds(qt_mac_window_for (window_hiview), kWindowContentRgn, &win_rect);
+ HIRect bounds = CGRectMake(0, 0, win_rect.right-win_rect.left, win_rect.bottom-win_rect.top);
+ HIViewSetFrame(hiview, &bounds);
+ HIViewSetVisible(hiview, true);
+ if (q->testAttribute(Qt::WA_DropSiteRegistered))
+ registerDropSite(true);
+ transferChildren();
+ }
+ initWindowPtr();
+
+ if (topExtra->posFromMove) {
+ updateFrameStrut();
+ const QRect &fStrut = frameStrut();
+ Rect r;
+ SetRect(&r, data.crect.left(), data.crect.top(), data.crect.right() + 1, data.crect.bottom() + 1);
+ SetRect(&r, r.left + fStrut.left(), r.top + fStrut.top(),
+ (r.left + fStrut.left() + data.crect.width()) - fStrut.right(),
+ (r.top + fStrut.top() + data.crect.height()) - fStrut.bottom());
+ SetWindowBounds(windowRef, kWindowContentRgn, &r);
+ topExtra->posFromMove = false;
+ }
+
+ if (q->testAttribute(Qt::WA_WState_WindowOpacitySet)){
+ q->setWindowOpacity(topExtra->opacity / 255.0f);
+ } else if (qt_mac_is_macsheet(q)){
+ SetThemeWindowBackground(qt_mac_window_for(q), kThemeBrushSheetBackgroundTransparent, true);
+ CGFloat alpha = 0;
+ GetWindowAlpha(qt_mac_window_for(q), &alpha);
+ if (alpha == 1){
+ // For some reason the 'SetThemeWindowBackground' does not seem
+ // to work. So we do this little hack until it hopefully starts to
+ // work in newer versions of mac OS.
+ q->setWindowOpacity(0.95f);
+ q->setAttribute(Qt::WA_WState_WindowOpacitySet, false);
+ }
+ } else{
+ // If the window has been recreated after beeing e.g. a sheet,
+ // make sure that we don't report a faulty opacity:
+ q->setWindowOpacity(1.0f);
+ q->setAttribute(Qt::WA_WState_WindowOpacitySet, false);
+ }
+
+ // Since we only now have a window, sync our state.
+ macUpdateHideOnSuspend();
+ macUpdateOpaqueSizeGrip();
+ macUpdateMetalAttribute();
+ macUpdateIgnoreMouseEvents();
+ setWindowTitle_helper(extra->topextra->caption);
+ setWindowIconText_helper(extra->topextra->iconText);
+ setWindowFilePath_helper(extra->topextra->filePath);
+ setWindowModified_sys(q->isWindowModified());
+ updateFrameStrut();
+ qt_mac_update_sizer(q);
+ applyMaxAndMinSizeOnWindow();
+}
+#else // QT_MAC_USE_COCOA
+void QWidgetPrivate::finishCreateWindow_sys_Cocoa(void * /*NSWindow * */ voidWindowRef)
+{
+ Q_Q(QWidget);
+ QMacCocoaAutoReleasePool pool;
+ NSWindow *windowRef = static_cast<NSWindow *>(voidWindowRef);
+ const Qt::WindowType type = q->windowType();
+ Qt::WindowFlags &flags = data.window_flags;
+ QWidget *parentWidget = q->parentWidget();
+
+ const bool popup = (type == Qt::Popup);
+ const bool dialog = (type == Qt::Dialog
+ || type == Qt::Sheet
+ || type == Qt::Drawer
+ || (flags & Qt::MSWindowsFixedSizeDialogHint));
+ QTLWExtra *topExtra = topData();
+
+ if ((popup || type == Qt::Tool || type == Qt::ToolTip) && !q->isModal()) {
+ [windowRef setHidesOnDeactivate:YES];
+ } else {
+ [windowRef setHidesOnDeactivate:NO];
+ }
+ [windowRef setHasShadow:YES];
+ Q_UNUSED(parentWidget);
+ Q_UNUSED(dialog);
+
+ data.fstrut_dirty = true; // when we create a toplevel widget, the frame strut should be dirty
+ OSViewRef nsview = (OSViewRef)data.winid;
+ OSViewRef window_contentview = qt_mac_get_contentview_for(windowRef);
+ if (!nsview) {
+ nsview = qt_mac_create_widget(q, this, window_contentview);
+ setWinId(WId(nsview));
+ } else {
+ [window_contentview addSubview:nsview];
+ }
+ if (nsview) {
+ NSRect bounds = [window_contentview bounds];
+ [nsview setFrame:bounds];
+ [nsview setHidden:NO];
+ if (q->testAttribute(Qt::WA_DropSiteRegistered))
+ registerDropSite(true);
+ transferChildren();
+ }
+
+ if (topExtra->posFromMove) {
+ updateFrameStrut();
+
+ const QRect &fStrut = frameStrut();
+ const QRect &crect = data.crect;
+ const QRect frameRect(QPoint(crect.left(), crect.top()),
+ QSize(fStrut.left() + fStrut.right() + crect.width(),
+ fStrut.top() + fStrut.bottom() + crect.height()));
+ NSRect cocoaFrameRect = NSMakeRect(frameRect.x(), flipYCoordinate(frameRect.bottom() + 1),
+ frameRect.width(), frameRect.height());
+ [windowRef setFrame:cocoaFrameRect display:NO];
+ topExtra->posFromMove = false;
+ }
+
+ if (q->testAttribute(Qt::WA_WState_WindowOpacitySet)){
+ q->setWindowOpacity(topExtra->opacity / 255.0f);
+ } else if (qt_mac_is_macsheet(q)){
+ CGFloat alpha = [qt_mac_window_for(q) alphaValue];
+ if (alpha >= 1.0) {
+ q->setWindowOpacity(0.95f);
+ q->setAttribute(Qt::WA_WState_WindowOpacitySet, false);
+ }
+ } else{
+ // If the window has been recreated after beeing e.g. a sheet,
+ // make sure that we don't report a faulty opacity:
+ q->setWindowOpacity(1.0f);
+ q->setAttribute(Qt::WA_WState_WindowOpacitySet, false);
+ }
+
+ macUpdateHideOnSuspend();
+ macUpdateOpaqueSizeGrip();
+ macUpdateIgnoreMouseEvents();
+ setWindowTitle_helper(extra->topextra->caption);
+ setWindowIconText_helper(extra->topextra->iconText);
+ setWindowModified_sys(q->isWindowModified());
+ updateFrameStrut();
+ syncCocoaMask();
+ macUpdateIsOpaque();
+ qt_mac_update_sizer(q);
+ applyMaxAndMinSizeOnWindow();
+}
+
+#endif // QT_MAC_USE_COCOA
+
+/*
+ Recreates widget window. Useful if immutable
+ properties for it has changed.
+ */
+void QWidgetPrivate::recreateMacWindow()
+{
+ Q_Q(QWidget);
+ OSViewRef myView = qt_mac_nativeview_for(q);
+ OSWindowRef oldWindow = qt_mac_window_for(myView);
+#ifndef QT_MAC_USE_COCOA
+ HIViewRemoveFromSuperview(myView);
+ determineWindowClass();
+ createWindow_sys();
+ if (QMainWindowLayout *mwl = qobject_cast<QMainWindowLayout *>(q->layout())) {
+ mwl->updateHIToolBarStatus();
+ }
+
+ if (IsWindowVisible(oldWindow))
+ show_sys();
+#else
+ QMacCocoaAutoReleasePool pool;
+ [myView removeFromSuperview];
+ determineWindowClass();
+ createWindow_sys();
+ if (NSToolbar *toolbar = [oldWindow toolbar]) {
+ OSWindowRef newWindow = qt_mac_window_for(myView);
+ [newWindow setToolbar:toolbar];
+ [toolbar setVisible:[toolbar isVisible]];
+ }
+ if ([oldWindow isVisible]){
+ if ([oldWindow isSheet])
+ [NSApp endSheet:oldWindow];
+ [oldWindow orderOut:oldWindow];
+ show_sys();
+ }
+#endif // QT_MAC_USE_COCOA
+
+ // Release the window after creating the new window, because releasing it early
+ // may cause the app to quit ("close on last window closed attribute")
+ qt_mac_destructWindow(oldWindow);
+}
+
+void QWidgetPrivate::createWindow_sys()
+{
+ Q_Q(QWidget);
+ Qt::WindowFlags &flags = data.window_flags;
+ QWidget *parentWidget = q->parentWidget();
+
+ QTLWExtra *topExtra = topData();
+ if (topExtra->embedded)
+ return; // Simply return because this view "is" the top window.
+ quint32 wattr = topExtra->wattr;
+
+ if(parentWidget && (parentWidget->window()->windowFlags() & Qt::WindowStaysOnTopHint)) // If our parent has Qt::WStyle_StaysOnTop, so must we
+ flags |= Qt::WindowStaysOnTopHint;
+
+ data.fstrut_dirty = true;
+
+ OSWindowRef windowRef = qt_mac_create_window(q, topExtra->wclass, wattr, data.crect);
+ if (windowRef == 0)
+ qWarning("QWidget: Internal error: %s:%d: If you reach this error please contact Qt Support and include the\n"
+ " WidgetFlags used in creating the widget.", __FILE__, __LINE__);
+#ifndef QT_MAC_USE_COCOA
+ finishCreateWindow_sys_Carbon(windowRef);
+#else
+ finishCreateWindow_sys_Cocoa(windowRef);
+#endif
+}
+
+void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyOldWindow)
+{
+ Q_Q(QWidget);
+ OSViewRef destroyid = 0;
+#ifndef QT_MAC_USE_COCOA
+ window_event = 0;
+#endif
+
+ Qt::WindowType type = q->windowType();
+ Qt::WindowFlags flags = data.window_flags;
+ QWidget *parentWidget = q->parentWidget();
+
+ bool topLevel = (flags & Qt::Window);
+ bool popup = (type == Qt::Popup);
+ bool dialog = (type == Qt::Dialog
+ || type == Qt::Sheet
+ || type == Qt::Drawer
+ || (flags & Qt::MSWindowsFixedSizeDialogHint));
+ bool desktop = (type == Qt::Desktop);
+
+ // Determine this early for top-levels so, we can use it later.
+ if (topLevel)
+ determineWindowClass();
+
+ if (desktop) {
+ QSize desktopSize = qt_mac_desktopSize();
+ q->setAttribute(Qt::WA_WState_Visible);
+ data.crect.setRect(0, 0, desktopSize.width(), desktopSize.height());
+ dialog = popup = false; // force these flags off
+ } else {
+ q->setAttribute(Qt::WA_WState_Visible, false);
+
+ if (topLevel && (type != Qt::Drawer)) {
+ if (QDesktopWidget *dsk = QApplication::desktop()) { // calc pos/size from screen
+ const bool wasResized = q->testAttribute(Qt::WA_Resized);
+ const bool wasMoved = q->testAttribute(Qt::WA_Moved);
+ int deskn = dsk->primaryScreen();
+ if (parentWidget && parentWidget->windowType() != Qt::Desktop)
+ deskn = dsk->screenNumber(parentWidget);
+ QRect screenGeo = dsk->screenGeometry(deskn);
+ if (!wasResized) {
+#ifndef QT_MAC_USE_COCOA
+ data.crect.setSize(QSize(screenGeo.width()/2, 4*screenGeo.height()/10));
+#else
+ NSRect newRect = [NSWindow frameRectForContentRect:NSMakeRect(0, 0,
+ screenGeo.width() / 2.,
+ 4 * screenGeo.height() / 10.)
+ styleMask:topData()->wattr];
+ data.crect.setSize(QSize(newRect.size.width, newRect.size.height));
+#endif
+ // Constrain to minimums and maximums we've set
+ if (extra->minw > 0)
+ data.crect.setWidth(qMax(extra->minw, data.crect.width()));
+ if (extra->minh > 0)
+ data.crect.setHeight(qMax(extra->minh, data.crect.height()));
+ if (extra->maxw > 0)
+ data.crect.setWidth(qMin(extra->maxw, data.crect.width()));
+ if (extra->maxh > 0)
+ data.crect.setHeight(qMin(extra->maxh, data.crect.height()));
+ }
+ if (!wasMoved && !q->testAttribute(Qt::WA_DontShowOnScreen))
+ data.crect.moveTopLeft(QPoint(screenGeo.width()/4,
+ 3 * screenGeo.height() / 10));
+ }
+ }
+ }
+
+
+ if(!window) // always initialize
+ initializeWindow=true;
+
+ hd = 0;
+ if(window) { // override the old window (with a new NSView)
+ OSViewRef nativeView = OSViewRef(window);
+ OSViewRef parent = 0;
+#ifndef QT_MAC_USE_COCOA
+ CFRetain(nativeView);
+#else
+ [nativeView retain];
+#endif
+ if (destroyOldWindow)
+ destroyid = qt_mac_nativeview_for(q);
+ bool transfer = false;
+ setWinId((WId)nativeView);
+#ifndef QT_MAC_USE_COCOA
+#ifndef HIViewInstallEventHandler
+ // Macro taken from the CarbonEvents Header on Tiger
+#define HIViewInstallEventHandler( target, handler, numTypes, list, userData, outHandlerRef ) \
+ InstallEventHandler( HIObjectGetEventTarget( (HIObjectRef) (target) ), (handler), (numTypes), (list), (userData), (outHandlerRef) )
+#endif
+ HIViewInstallEventHandler(nativeView, make_widget_eventUPP(), GetEventTypeCount(widget_events), widget_events, 0, 0);
+#endif
+ if(topLevel) {
+ for(int i = 0; i < 2; ++i) {
+ if(i == 1) {
+ if(!initializeWindow)
+ break;
+ createWindow_sys();
+ }
+ if(OSWindowRef windowref = qt_mac_window_for(nativeView)) {
+#ifndef QT_MAC_USE_COCOA
+ CFRetain(windowref);
+#else
+ [windowref retain];
+#endif
+ if (initializeWindow) {
+ parent = qt_mac_get_contentview_for(windowref);
+ } else {
+#ifndef QT_MAC_USE_COCOA
+ parent = HIViewGetSuperview(nativeView);
+#else
+ parent = [nativeView superview];
+#endif
+ }
+ break;
+ }
+ }
+ if(!parent)
+ transfer = true;
+ } else if (parentWidget) {
+ // I need to be added to my parent, therefore my parent needs an NSView
+ parentWidget->createWinId();
+ parent = qt_mac_nativeview_for(parentWidget);
+ }
+ if(parent != nativeView && parent) {
+#ifndef QT_MAC_USE_COCOA
+ HIViewAddSubview(parent, nativeView);
+#else
+ [parent addSubview:nativeView];
+#endif
+ }
+ if(transfer)
+ transferChildren();
+ data.fstrut_dirty = true; // we'll re calculate this later
+ q->setAttribute(Qt::WA_WState_Visible,
+#ifndef QT_MAC_USE_COCOA
+ HIViewIsVisible(nativeView)
+#else
+ ![nativeView isHidden]
+#endif
+ );
+ if(initializeWindow) {
+#ifndef QT_MAC_USE_COCOA
+ HIRect bounds = CGRectMake(data.crect.x(), data.crect.y(), data.crect.width(), data.crect.height());
+ HIViewSetFrame(nativeView, &bounds);
+ q->setAttribute(Qt::WA_WState_Visible, HIViewIsVisible(nativeView));
+#else
+ NSRect bounds = NSMakeRect(data.crect.x(), data.crect.y(), data.crect.width(), data.crect.height());
+ [nativeView setFrame:bounds];
+ q->setAttribute(Qt::WA_WState_Visible, [nativeView isHidden]);
+#endif
+ }
+#ifndef QT_MAC_USE_COCOA
+ initWindowPtr();
+#endif
+ } else if (desktop) { // desktop widget
+ if (!qt_root_win)
+ QWidgetPrivate::qt_create_root_win();
+ Q_ASSERT(qt_root_win);
+ WId rootWinID = 0;
+#ifndef QT_MAC_USE_COCOA
+ CFRetain(qt_root_win);
+ if(HIViewRef rootContentView = HIViewGetRoot(qt_root_win)) {
+ rootWinID = (WId)rootContentView;
+ CFRetain(rootContentView);
+ }
+#else
+ [qt_root_win retain];
+ if (OSViewRef rootContentView = [qt_root_win contentView]) {
+ rootWinID = (WId)rootContentView;
+ [rootContentView retain];
+ }
+#endif
+ setWinId(rootWinID);
+ } else if (topLevel) {
+ determineWindowClass();
+ if(OSViewRef osview = qt_mac_create_widget(q, this, 0)) {
+#ifndef QT_MAC_USE_COCOA
+ HIRect bounds = CGRectMake(data.crect.x(), data.crect.y(),
+ data.crect.width(), data.crect.height());
+ HIViewSetFrame(osview, &bounds);
+#else
+ NSRect bounds = NSMakeRect(data.crect.x(), flipYCoordinate(data.crect.y()),
+ data.crect.width(), data.crect.height());
+ [osview setFrame:bounds];
+#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))) {
+#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
+ NSRect bounds = NSMakeRect(data.crect.x(), data.crect.y(), data.crect.width(), data.crect.height());
+ [osview setFrame:bounds];
+ setWinId((WId)osview);
+#endif
+ if (q->testAttribute(Qt::WA_DropSiteRegistered))
+ registerDropSite(true);
+ }
+ }
+
+ updateIsOpaque();
+ if (q->hasFocus())
+ setFocus_sys();
+ if (!topLevel && initializeWindow)
+ setWSGeometry();
+ if (destroyid)
+ qt_mac_destructView(destroyid);
+ if (q->testAttribute(Qt::WA_AcceptTouchEvents))
+ registerTouchWindow();
+}
+
+/*!
+ Returns the QuickDraw handle of the widget. Use of this function is not
+ portable. This function will return 0 if QuickDraw is not supported, or
+ if the handle could not be created.
+
+ \warning This function is only available on Mac OS X.
+*/
+
+Qt::HANDLE
+QWidget::macQDHandle() const
+{
+#ifndef QT_MAC_USE_COCOA
+ return d_func()->qd_hd;
+#else
+ return 0;
+#endif
+}
+
+/*!
+ Returns the CoreGraphics handle of the widget. Use of this function is
+ not portable. This function will return 0 if no painter context can be
+ established, or if the handle could not be created.
+
+ \warning This function is only available on Mac OS X.
+*/
+Qt::HANDLE
+QWidget::macCGHandle() const
+{
+ return handle();
+}
+
+void QWidget::destroy(bool destroyWindow, bool destroySubWindows)
+{
+ Q_D(QWidget);
+ if (!isWindow() && parentWidget())
+ parentWidget()->d_func()->invalidateBuffer(d->effectiveRectFor(geometry()));
+ d->deactivateWidgetCleanup();
+ qt_mac_event_release(this);
+ if(testAttribute(Qt::WA_WState_Created)) {
+ QMacCocoaAutoReleasePool pool;
+ setAttribute(Qt::WA_WState_Created, false);
+ QObjectList chldrn = children();
+ for(int i = 0; i < chldrn.size(); i++) { // destroy all widget children
+ QObject *obj = chldrn.at(i);
+ if(obj->isWidgetType())
+ static_cast<QWidget*>(obj)->destroy(destroySubWindows, destroySubWindows);
+ }
+ if(mac_mouse_grabber == this)
+ releaseMouse();
+ if(mac_keyboard_grabber == this)
+ releaseKeyboard();
+ if(acceptDrops())
+ setAcceptDrops(false);
+
+ if(testAttribute(Qt::WA_ShowModal)) // just be sure we leave modal
+ QApplicationPrivate::leaveModal(this);
+ else if((windowType() == Qt::Popup))
+ qApp->d_func()->closePopup(this);
+ if (destroyWindow) {
+ if(OSViewRef hiview = qt_mac_nativeview_for(this)) {
+ OSWindowRef window = 0;
+ NSDrawer *drawer = nil;
+#ifdef QT_MAC_USE_COCOA
+ if (qt_mac_is_macdrawer(this)) {
+ drawer = qt_mac_drawer_for(this);
+ } else
+#endif
+ if (isWindow())
+ window = qt_mac_window_for(hiview);
+
+ // Because of how "destruct" works, we have to do just a normal release for the root_win.
+ if (window && window == qt_root_win) {
+#ifndef QT_MAC_USE_COCOA
+ CFRelease(hiview);
+#else
+ [hiview release];
+#endif
+ } else {
+ qt_mac_destructView(hiview);
+ }
+ if (drawer)
+ qt_mac_destructDrawer(drawer);
+ if (window)
+ qt_mac_destructWindow(window);
+ }
+ }
+ QT_TRY {
+ d->setWinId(0);
+ } QT_CATCH (const std::bad_alloc &) {
+ // swallow - destructors must not throw
+ }
+ }
+}
+
+void QWidgetPrivate::transferChildren()
+{
+ Q_Q(QWidget);
+ if (!q->testAttribute(Qt::WA_WState_Created))
+ return; // Can't add any views anyway
+
+ QObjectList chlist = q->children();
+ for (int i = 0; i < chlist.size(); ++i) {
+ QObject *obj = chlist.at(i);
+ if (obj->isWidgetType()) {
+ QWidget *w = (QWidget *)obj;
+ if (!w->isWindow()) {
+ // This seems weird, no need to call it in a loop right?
+ if (!topData()->caption.isEmpty())
+ setWindowTitle_helper(extra->topextra->caption);
+ if (w->testAttribute(Qt::WA_WState_Created)) {
+#ifndef QT_MAC_USE_COCOA
+ HIViewAddSubview(qt_mac_nativeview_for(q), qt_mac_nativeview_for(w));
+#else
+ // New NSWindows get an extra reference when drops are
+ // registered (at least in 10.5) which means that we may
+ // access the window later and get a crash (becasue our
+ // widget is dead). Work around this be having the drop
+ // site disabled until it is part of the new hierarchy.
+ bool oldRegistered = w->testAttribute(Qt::WA_DropSiteRegistered);
+ w->setAttribute(Qt::WA_DropSiteRegistered, false);
+ [qt_mac_nativeview_for(q) addSubview:qt_mac_nativeview_for(w)];
+ w->setAttribute(Qt::WA_DropSiteRegistered, oldRegistered);
+#endif
+ }
+ }
+ }
+ }
+}
+
+void QWidgetPrivate::setParent_sys(QWidget *parent, Qt::WindowFlags f)
+{
+ Q_Q(QWidget);
+ QMacCocoaAutoReleasePool pool;
+ QTLWExtra *topData = maybeTopData();
+ bool wasCreated = q->testAttribute(Qt::WA_WState_Created);
+#ifdef QT_MAC_USE_COCOA
+ bool wasWindow = q->isWindow();
+#endif
+ OSViewRef old_id = 0;
+
+ if (q->isVisible() && q->parentWidget() && parent != q->parentWidget())
+ q->parentWidget()->d_func()->invalidateBuffer(effectiveRectFor(q->geometry()));
+
+ // Maintain the glWidgets list on parent change: remove "our" gl widgets
+ // from the list on the old parent and grandparents.
+ if (glWidgets.isEmpty() == false) {
+ QWidget *current = q->parentWidget();
+ while (current) {
+ for (QList<QWidgetPrivate::GlWidgetInfo>::const_iterator it = glWidgets.constBegin();
+ it != glWidgets.constEnd(); ++it)
+ current->d_func()->glWidgets.removeAll(*it);
+
+ if (current->isWindow())
+ break;
+ current = current->parentWidget();
+ }
+ }
+
+#ifndef QT_MAC_USE_COCOA
+ EventHandlerRef old_window_event = 0;
+#else
+ bool oldToolbarVisible = false;
+ NSDrawer *oldDrawer = nil;
+ NSToolbar *oldToolbar = 0;
+#endif
+ if (wasCreated && !(q->windowType() == Qt::Desktop)) {
+ old_id = qt_mac_nativeview_for(q);
+#ifndef QT_MAC_USE_COCOA
+ old_window_event = window_event;
+#else
+ OSWindowRef oldWindow = qt_mac_window_for(old_id);
+ if (qt_mac_is_macdrawer(q)) {
+ oldDrawer = qt_mac_drawer_for(q);
+ }
+ if (wasWindow) {
+ oldToolbar = [oldWindow toolbar];
+ oldToolbarVisible = [oldToolbar isVisible];
+ }
+#endif
+ }
+ QWidget* oldtlw = q->window();
+
+ 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)
+ q->setWindowOpacity(1.0f);
+
+ 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
+ // (but we recreate the winId for the widget being reparented, again for compatibility)
+ if (wasCreated || (!q->isWindow() && parent->testAttribute(Qt::WA_WState_Created))) {
+ 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 (!wasCreated) {
+ if (QMainWindowLayout *mwl = qobject_cast<QMainWindowLayout *>(q->layout())) {
+ mwl->updateHIToolBarStatus();
+ }
+ }
+#else
+ // Simply transfer our toolbar over. Everything should stay put, unlike in Carbon.
+ if (oldToolbar && !(f & Qt::FramelessWindowHint)) {
+ OSWindowRef newWindow = qt_mac_window_for(q);
+ [newWindow setToolbar:oldToolbar];
+ [oldToolbar setVisible:oldToolbarVisible];
+ }
+#endif
+ }
+ }
+ if (q->isWindow() || (!parent || parent->isVisible()) || explicitlyHidden)
+ q->setAttribute(Qt::WA_WState_Hidden);
+ q->setAttribute(Qt::WA_WState_ExplicitShowHide, explicitlyHidden);
+
+ if (wasCreated) {
+ transferChildren();
+#ifndef QT_MAC_USE_COCOA
+ // If we were a unified window, We just transfered our toolbars out of the unified toolbar.
+ // So redo the status one more time. It apparently is not an issue with Cocoa.
+ if (q->isWindow()) {
+ if (QMainWindowLayout *mwl = qobject_cast<QMainWindowLayout *>(q->layout())) {
+ mwl->updateHIToolBarStatus();
+ }
+ }
+#endif
+
+ if (topData &&
+ (!topData->caption.isEmpty() || !topData->filePath.isEmpty()))
+ setWindowTitle_helper(q->windowTitle());
+ }
+
+ if (q->testAttribute(Qt::WA_AcceptDrops)
+ || (!q->isWindow() && q->parentWidget()
+ && q->parentWidget()->testAttribute(Qt::WA_DropSiteRegistered)))
+ q->setAttribute(Qt::WA_DropSiteRegistered, true);
+
+ //cleanup
+#ifndef QT_MAC_USE_COCOA
+ if (old_window_event)
+ RemoveEventHandler(old_window_event);
+#endif
+ if (old_id) { //don't need old window anymore
+ OSWindowRef window = (oldtlw == q) ? qt_mac_window_for(old_id) : 0;
+ qt_mac_destructView(old_id);
+
+#ifdef QT_MAC_USE_COCOA
+ if (oldDrawer) {
+ qt_mac_destructDrawer(oldDrawer);
+ } else
+#endif
+ if (window)
+ qt_mac_destructWindow(window);
+ }
+
+ // Maintain the glWidgets list on parent change: add "our" gl widgets
+ // to the list on the new parent and grandparents.
+ if (glWidgets.isEmpty() == false) {
+ QWidget *current = q->parentWidget();
+ while (current) {
+ current->d_func()->glWidgets += glWidgets;
+ 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)) {
+ QPoint p = pos + data->crect.topLeft();
+ return isWindow() ? p : parentWidget()->mapToGlobal(p);
+ }
+#ifndef QT_MAC_USE_COCOA
+ QPoint tmp = d->mapToWS(pos);
+ HIPoint hi_pos = CGPointMake(tmp.x(), tmp.y());
+ HIViewConvertPoint(&hi_pos, qt_mac_nativeview_for(this), 0);
+ Rect win_rect;
+ GetWindowBounds(qt_mac_window_for(this), kWindowStructureRgn, &win_rect);
+ return QPoint((int)hi_pos.x+win_rect.left, (int)hi_pos.y+win_rect.top);
+#else
+ QPoint tmp = d->mapToWS(pos);
+ NSPoint hi_pos = NSMakePoint(tmp.x(), tmp.y());
+ hi_pos = [qt_mac_nativeview_for(this) convertPoint:hi_pos toView:nil];
+ NSRect win_rect = [qt_mac_window_for(this) frame];
+ hi_pos.x += win_rect.origin.x;
+ hi_pos.y += win_rect.origin.y;
+ // If we aren't the desktop we need to flip, if you flip the desktop on itself, you get the other problem.
+ return ((window()->windowFlags() & Qt::Desktop) == Qt::Desktop) ? QPointF(hi_pos.x, hi_pos.y).toPoint()
+ : flipPoint(hi_pos).toPoint();
+#endif
+}
+
+QPoint QWidget::mapFromGlobal(const QPoint &pos) const
+{
+ Q_D(const QWidget);
+ if (!testAttribute(Qt::WA_WState_Created)) {
+ QPoint p = isWindow() ? pos : parentWidget()->mapFromGlobal(pos);
+ return p - data->crect.topLeft();
+ }
+#ifndef QT_MAC_USE_COCOA
+ Rect win_rect;
+ GetWindowBounds(qt_mac_window_for(this), kWindowStructureRgn, &win_rect);
+ HIPoint hi_pos = CGPointMake(pos.x()-win_rect.left, pos.y()-win_rect.top);
+ HIViewConvertPoint(&hi_pos, 0, qt_mac_nativeview_for(this));
+ return d->mapFromWS(QPoint((int)hi_pos.x, (int)hi_pos.y));
+#else
+ NSRect win_rect = [qt_mac_window_for(this) frame];
+ // The Window point is in "Cocoa coordinates," but the view is in "Qt coordinates"
+ // so make sure to keep them in sync.
+ NSPoint hi_pos = NSMakePoint(pos.x()-win_rect.origin.x,
+ flipYCoordinate(pos.y())-win_rect.origin.y);
+ hi_pos = [qt_mac_nativeview_for(this) convertPoint:hi_pos fromView:0];
+ return d->mapFromWS(QPoint(qRound(hi_pos.x), qRound(hi_pos.y)));
+#endif
+}
+
+void QWidgetPrivate::updateSystemBackground()
+{
+}
+
+void QWidgetPrivate::setCursor_sys(const QCursor &)
+{
+#ifndef QT_MAC_USE_COCOA
+ qt_mac_update_cursor();
+#else
+ Q_Q(QWidget);
+ if (q->testAttribute(Qt::WA_WState_Created)) {
+ [qt_mac_window_for(q) invalidateCursorRectsForView:qt_mac_nativeview_for(q)];
+ }
+#endif
+}
+
+void QWidgetPrivate::unsetCursor_sys()
+{
+#ifndef QT_MAC_USE_COCOA
+ qt_mac_update_cursor();
+#else
+ Q_Q(QWidget);
+ if (q->testAttribute(Qt::WA_WState_Created)) {
+ [qt_mac_window_for(q) invalidateCursorRectsForView:qt_mac_nativeview_for(q)];
+ }
+#endif
+}
+
+void QWidgetPrivate::setWindowTitle_sys(const QString &caption)
+{
+ Q_Q(QWidget);
+ if (q->isWindow()) {
+#ifndef QT_MAC_USE_COCOA
+ SetWindowTitleWithCFString(qt_mac_window_for(q), QCFString(caption));
+#else
+ QMacCocoaAutoReleasePool pool;
+ [qt_mac_window_for(q) setTitle:qt_mac_QStringToNSString(caption)];
+#endif
+ }
+}
+
+void QWidgetPrivate::setWindowModified_sys(bool mod)
+{
+ Q_Q(QWidget);
+ if (q->isWindow() && q->testAttribute(Qt::WA_WState_Created)) {
+#ifndef QT_MAC_USE_COCOA
+ SetWindowModified(qt_mac_window_for(q), mod);
+#else
+ [qt_mac_window_for(q) setDocumentEdited:mod];
+#endif
+ }
+}
+
+void QWidgetPrivate::setWindowFilePath_sys(const QString &filePath)
+{
+ Q_Q(QWidget);
+#ifdef QT_MAC_USE_COCOA
+ QMacCocoaAutoReleasePool pool;
+ QFileInfo fi(filePath);
+ [qt_mac_window_for(q) setRepresentedFilename:fi.exists() ? qt_mac_QStringToNSString(filePath) : @""];
+#else
+ bool validRef = false;
+ FSRef ref;
+ bzero(&ref, sizeof(ref));
+ OSStatus status;
+
+ if (!filePath.isEmpty()) {
+ status = FSPathMakeRef(reinterpret_cast<const UInt8 *>(filePath.toUtf8().constData()), &ref, 0);
+ validRef = (status == noErr);
+ }
+ // Set the proxy regardless, since this is our way of clearing it as well, but ignore the
+ // return value as well.
+ if (validRef) {
+ status = HIWindowSetProxyFSRef(qt_mac_window_for(q), &ref);
+ } else {
+ status = RemoveWindowProxy(qt_mac_window_for(q));
+ }
+ if (status != noErr)
+ qWarning("QWidget::setWindowFilePath: Error setting proxyicon for path (%s):%ld",
+ qPrintable(filePath), status);
+#endif
+}
+
+void QWidgetPrivate::setWindowIcon_sys(bool forceReset)
+{
+ Q_Q(QWidget);
+
+ if (!q->testAttribute(Qt::WA_WState_Created))
+ return;
+
+ QTLWExtra *topData = this->topData();
+ if (topData->iconPixmap && !forceReset) // already set
+ return;
+
+ QIcon icon = q->windowIcon();
+ QPixmap *pm = 0;
+ if (!icon.isNull()) {
+ // now create the extra
+ if (!topData->iconPixmap) {
+ pm = new QPixmap(icon.pixmap(QSize(22, 22)));
+ topData->iconPixmap = pm;
+ } else {
+ pm = topData->iconPixmap;
+ }
+ }
+ if (q->isWindow()) {
+#ifndef QT_MAC_USE_COCOA
+ IconRef previousIcon = 0;
+ if (icon.isNull()) {
+ RemoveWindowProxy(qt_mac_window_for(q));
+ previousIcon = topData->windowIcon;
+ topData->windowIcon = 0;
+ } else {
+ WindowClass wclass;
+ GetWindowClass(qt_mac_window_for(q), &wclass);
+
+ if (wclass == kDocumentWindowClass) {
+ IconRef newIcon = qt_mac_create_iconref(*pm);
+ previousIcon = topData->windowIcon;
+ topData->windowIcon = newIcon;
+ SetWindowProxyIcon(qt_mac_window_for(q), newIcon);
+ }
+ }
+
+ // Release the previous icon if it was set by this function.
+ if (previousIcon != 0)
+ ReleaseIconRef(previousIcon);
+#else
+ QMacCocoaAutoReleasePool pool;
+ NSButton *iconButton = [qt_mac_window_for(q) standardWindowButton:NSWindowDocumentIconButton];
+ if (icon.isNull()) {
+ [iconButton setImage:nil];
+ } else {
+ NSImage *image = static_cast<NSImage *>(qt_mac_create_nsimage(*pm));
+ [iconButton setImage:image];
+ [image release];
+ }
+#endif
+ }
+}
+
+void QWidgetPrivate::setWindowIconText_sys(const QString &iconText)
+{
+ Q_Q(QWidget);
+ if(q->isWindow() && !iconText.isEmpty()) {
+#ifndef QT_MAC_USE_COCOA
+ SetWindowAlternateTitle(qt_mac_window_for(q), QCFString(iconText));
+#else
+ QMacCocoaAutoReleasePool pool;
+ [qt_mac_window_for(q) setMiniwindowTitle:qt_mac_QStringToNSString(iconText)];
+#endif
+ }
+}
+
+void QWidget::grabMouse()
+{
+ if(isVisible() && !qt_nograb()) {
+ if(mac_mouse_grabber)
+ mac_mouse_grabber->releaseMouse();
+ mac_mouse_grabber=this;
+ }
+}
+
+void QWidget::grabMouse(const QCursor &)
+{
+ if(isVisible() && !qt_nograb()) {
+ if(mac_mouse_grabber)
+ mac_mouse_grabber->releaseMouse();
+ mac_mouse_grabber=this;
+ }
+}
+
+void QWidget::releaseMouse()
+{
+ if(!qt_nograb() && mac_mouse_grabber == this)
+ mac_mouse_grabber = 0;
+}
+
+void QWidget::grabKeyboard()
+{
+ if(!qt_nograb()) {
+ if(mac_keyboard_grabber)
+ mac_keyboard_grabber->releaseKeyboard();
+ mac_keyboard_grabber = this;
+ }
+}
+
+void QWidget::releaseKeyboard()
+{
+ if(!qt_nograb() && mac_keyboard_grabber == this)
+ mac_keyboard_grabber = 0;
+}
+
+QWidget *QWidget::mouseGrabber()
+{
+ return mac_mouse_grabber;
+}
+
+QWidget *QWidget::keyboardGrabber()
+{
+ return mac_keyboard_grabber;
+}
+
+void QWidget::activateWindow()
+{
+ QWidget *tlw = window();
+ if(!tlw->isVisible() || !tlw->isWindow() || (tlw->windowType() == Qt::Desktop))
+ return;
+ qt_event_remove_activate();
+
+ QWidget *fullScreenWidget = tlw;
+ QWidget *parentW = tlw;
+ // Find the oldest parent or the parent with fullscreen, whichever comes first.
+ while (parentW) {
+ fullScreenWidget = parentW->window();
+ if (fullScreenWidget->windowState() & Qt::WindowFullScreen)
+ break;
+ parentW = fullScreenWidget->parentWidget();
+ }
+
+ if (fullScreenWidget->windowType() != Qt::ToolTip) {
+ qt_mac_set_fullscreen_mode((fullScreenWidget->windowState() & Qt::WindowFullScreen) &&
+ qApp->desktop()->screenNumber(this) == 0);
+ }
+
+ bool windowActive;
+ OSWindowRef win = qt_mac_window_for(tlw);
+#ifndef QT_MAC_USE_COCOA
+ windowActive = IsWindowActive(win);
+#else
+ QMacCocoaAutoReleasePool pool;
+ windowActive = [win isKeyWindow];
+#endif
+ if ((tlw->windowType() == Qt::Popup)
+ || (tlw->windowType() == Qt::Tool)
+ || qt_mac_is_macdrawer(tlw)
+ || windowActive) {
+#ifndef QT_MAC_USE_COCOA
+ ActivateWindow(win, true);
+#else
+ [win makeKeyWindow];
+#endif
+ qApp->setActiveWindow(tlw);
+ } else if(!isMinimized()) {
+#ifndef QT_MAC_USE_COCOA
+ SelectWindow(win);
+#else
+ [win makeKeyAndOrderFront:win];
+#endif
+ }
+}
+
+QWindowSurface *QWidgetPrivate::createDefaultWindowSurface_sys()
+{
+ return new QMacWindowSurface(q_func());
+}
+
+void QWidgetPrivate::update_sys(const QRect &r)
+{
+ Q_Q(QWidget);
+ if (r == q->rect()) {
+ if (updateRedirectedToGraphicsProxyWidget(q, r))
+ return;
+ dirtyOnWidget += r;
+#ifndef QT_MAC_USE_COCOA
+ HIViewSetNeedsDisplay(qt_mac_nativeview_for(q), true);
+#else
+ [qt_mac_nativeview_for(q) setNeedsDisplay:YES];
+#endif
+ return;
+ }
+
+ int x = r.x(), y = r.y(), w = r.width(), h = r.height();
+ if (w < 0)
+ w = q->data->crect.width() - x;
+ if (h < 0)
+ h = q->data->crect.height() - y;
+ if (w && h) {
+ const QRect updateRect = QRect(x, y, w, h);
+ if (updateRedirectedToGraphicsProxyWidget(q, updateRect))
+ return;
+#ifndef QT_MAC_USE_COCOA
+ dirtyOnWidget += updateRect;
+ HIRect r = CGRectMake(x, y, w, h);
+ HIViewSetNeedsDisplayInRect(qt_mac_nativeview_for(q), &r, true);
+#else
+ [qt_mac_nativeview_for(q) setNeedsDisplayInRect:NSMakeRect(x, y, w, h)];
+#endif
+ }
+}
+
+void QWidgetPrivate::update_sys(const QRegion &rgn)
+{
+ Q_Q(QWidget);
+ if (updateRedirectedToGraphicsProxyWidget(q, rgn))
+ return;
+ dirtyOnWidget += rgn;
+#ifndef QT_MAC_USE_COCOA
+ RgnHandle rgnHandle = rgn.toQDRgnForUpdate_sys();
+ if (rgnHandle)
+ 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.
+ const QRect &boundingRect = rgn.boundingRect();
+ [qt_mac_nativeview_for(q) setNeedsDisplayInRect:NSMakeRect(boundingRect.x(),
+ boundingRect.y(), boundingRect.width(),
+ boundingRect.height())];
+#endif
+}
+
+bool QWidgetPrivate::isRealWindow() const
+{
+ return q_func()->isWindow() && !topData()->embedded;
+}
+
+void QWidgetPrivate::show_sys()
+{
+ Q_Q(QWidget);
+ if ((q->windowType() == Qt::Desktop)) //desktop is always visible
+ return;
+
+ invalidateBuffer(q->rect());
+ if (q->testAttribute(Qt::WA_OutsideWSRange))
+ return;
+ QMacCocoaAutoReleasePool pool;
+ q->setAttribute(Qt::WA_Mapped);
+ if (q->testAttribute(Qt::WA_DontShowOnScreen))
+ return;
+
+ bool realWindow = isRealWindow();
+ if (realWindow && !q->testAttribute(Qt::WA_Moved)) {
+ 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.
+ 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();
+ OSWindowRef window = qt_mac_window_for(q);
+#ifndef QT_MAC_USE_COCOA
+ SizeWindow(window, q->width(), q->height(), true);
+#endif
+
+#ifdef QT_MAC_USE_COCOA
+ // Make sure that we end up sending a repaint event to
+ // the widget if the window has been visible one before:
+ [qt_mac_get_contentview_for(window) setNeedsDisplay:YES];
+#endif
+ if(qt_mac_is_macsheet(q)) {
+ qt_event_request_showsheet(q);
+ } else if(qt_mac_is_macdrawer(q)) {
+#ifndef QT_MAC_USE_COCOA
+ OpenDrawer(window, kWindowEdgeDefault, false);
+#else
+ NSDrawer *drawer = qt_mac_drawer_for(q);
+ [drawer openOnEdge:[drawer preferredEdge]];
+#endif
+ } else {
+#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];
+
+ // If this window is app modal, we need to start spinning
+ // a modal session for it. Interrupting
+ // the event dispatcher will make this happend:
+ if (data.window_modality == Qt::ApplicationModal)
+ QEventDispatcherMac::instance()->interrupt();
+#endif
+ if (q->windowType() == Qt::Popup) {
+ if (q->focusWidget())
+ q->focusWidget()->d_func()->setFocus_sys();
+ else
+ setFocus_sys();
+ }
+ toggleDrawers(true);
+ }
+ if (isCurrentlyMinimized) { //show in collapsed state
+#ifndef QT_MAC_USE_COCOA
+ CollapseWindow(window, true);
+#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);
+#else
+ [qt_mac_nativeview_for(q) setHidden:NO];
+
+#endif
+ }
+
+ if (!QWidget::mouseGrabber()){
+ QWidget *enterWidget = QApplication::widgetAt(QCursor::pos());
+ QApplicationPrivate::dispatchEnterLeave(enterWidget, qt_mouseover);
+ qt_mouseover = enterWidget;
+ }
+
+ qt_event_request_window_change(q);
+}
+
+
+QPoint qt_mac_nativeMapFromParent(const QWidget *child, const QPoint &pt)
+{
+#ifndef QT_MAC_USE_COCOA
+ CGPoint nativePoint = CGPointMake(pt.x(), pt.y());
+ HIViewConvertPoint(&nativePoint, qt_mac_nativeview_for(child->parentWidget()),
+ qt_mac_nativeview_for(child));
+#else
+ NSPoint nativePoint = [qt_mac_nativeview_for(child) convertPoint:NSMakePoint(pt.x(), pt.y()) fromView:qt_mac_nativeview_for(child->parentWidget())];
+#endif
+ return QPoint(nativePoint.x, nativePoint.y);
+}
+
+
+void QWidgetPrivate::hide_sys()
+{
+ Q_Q(QWidget);
+ if((q->windowType() == Qt::Desktop)) //you can't hide the desktop!
+ return;
+
+ QMacCocoaAutoReleasePool pool;
+ if(q->isWindow()) {
+ 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)
+ ShowHide(window, false);
+ else
+ HideSheetWindow(window);
+#else
+ [NSApp endSheet:window];
+ [window orderOut:window];
+#endif
+ } else if(qt_mac_is_macdrawer(q)) {
+#ifndef QT_MAC_USE_COCOA
+ CloseDrawer(window, false);
+#else
+ [qt_mac_drawer_for(q) close];
+#endif
+ } else {
+#ifndef QT_MAC_USE_COCOA
+ ShowHide(window, false);
+#else
+ [window orderOut:window];
+#endif
+ toggleDrawers(false);
+#ifndef QT_MAC_USE_COCOA
+ // Clear modality (because it seems something that we've always done).
+ if (data.window_modality != Qt::NonModal) {
+ SetWindowModality(window, kWindowModalityNone,
+ q->parentWidget() ? qt_mac_window_for(q->parentWidget()->window()) : 0);
+ }
+#endif
+ }
+ 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(kDocumentWindowClass, true);
+ wp; wp = GetNextWindowOfClass(wp, kDocumentWindowClass, true)) {
+ if((w = qt_mac_find_window(wp)))
+ break;
+ }
+ if (!w){
+ for(WindowPtr wp = GetFrontWindowOfClass(kSimpleWindowClass, true);
+ 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);
+#else
+ [qt_mac_window_for(w) makeKeyWindow];
+#endif
+ }
+ }
+ } else {
+ invalidateBuffer(q->rect());
+#ifndef QT_MAC_USE_COCOA
+ HIViewSetVisible(qt_mac_nativeview_for(q), false);
+#else
+ [qt_mac_nativeview_for(q) setHidden:YES];
+#endif
+ }
+
+ if (!QWidget::mouseGrabber()){
+ QWidget *enterWidget = QApplication::widgetAt(QCursor::pos());
+ QApplicationPrivate::dispatchEnterLeave(enterWidget, qt_mouseover);
+ qt_mouseover = enterWidget;
+ }
+
+ qt_event_request_window_change(q);
+ deactivateWidgetCleanup();
+ qt_mac_event_release(q);
+}
+
+void QWidget::setWindowState(Qt::WindowStates newstate)
+{
+ Q_D(QWidget);
+ bool needShow = false;
+ Qt::WindowStates oldstate = windowState();
+ if (oldstate == newstate)
+ return;
+
+#ifdef QT_MAC_USE_COCOA
+ QMacCocoaAutoReleasePool pool;
+#endif
+ bool needSendStateChange = true;
+ if(isWindow()) {
+ if((oldstate & Qt::WindowFullScreen) != (newstate & Qt::WindowFullScreen)) {
+ if(newstate & Qt::WindowFullScreen) {
+ if(QTLWExtra *tlextra = d->topData()) {
+ if(tlextra->normalGeometry.width() < 0) {
+ if(!testAttribute(Qt::WA_Resized))
+ adjustSize();
+ tlextra->normalGeometry = geometry();
+ }
+ tlextra->savedFlags = windowFlags();
+ }
+ needShow = isVisible();
+ const QRect fullscreen(qApp->desktop()->screenGeometry(qApp->desktop()->screenNumber(this)));
+ setParent(parentWidget(), Qt::Window | Qt::FramelessWindowHint | (windowFlags() & 0xffff0000)); //save
+ setGeometry(fullscreen);
+ if(!qApp->desktop()->screenNumber(this))
+ qt_mac_set_fullscreen_mode(true);
+ } else {
+ needShow = isVisible();
+ setParent(parentWidget(), d->topData()->savedFlags);
+ setGeometry(d->topData()->normalGeometry);
+ if(!qApp->desktop()->screenNumber(this))
+ qt_mac_set_fullscreen_mode(false);
+ d->topData()->normalGeometry.setRect(0, 0, -1, -1);
+ }
+ }
+
+ d->createWinId();
+
+ OSWindowRef window = qt_mac_window_for(this);
+ if((oldstate & Qt::WindowMinimized) != (newstate & Qt::WindowMinimized)) {
+ if (newstate & Qt::WindowMinimized) {
+#ifndef QT_MAC_USE_COCOA
+ CollapseWindow(window, true);
+#else
+ [window miniaturize:window];
+#endif
+ } else {
+#ifndef QT_MAC_USE_COCOA
+ CollapseWindow(window, false);
+#else
+ [window deminiaturize:window];
+#endif
+ }
+ needSendStateChange = oldstate == windowState(); // Collapse didn't change our flags.
+ }
+
+ if((newstate & Qt::WindowMaximized) && !((newstate & Qt::WindowFullScreen))) {
+ if(QTLWExtra *tlextra = d->topData()) {
+ if(tlextra->normalGeometry.width() < 0) {
+ if(!testAttribute(Qt::WA_Resized))
+ adjustSize();
+ tlextra->normalGeometry = geometry();
+ }
+ }
+ } else if(!(newstate & Qt::WindowFullScreen)) {
+// d->topData()->normalGeometry = QRect(0, 0, -1, -1);
+ }
+
+#ifdef DEBUG_WINDOW_STATE
+#define WSTATE(x) qDebug("%s -- %s --> %s", #x, (oldstate & x) ? "true" : "false", (newstate & x) ? "true" : "false")
+ WSTATE(Qt::WindowMinimized);
+ WSTATE(Qt::WindowMaximized);
+ WSTATE(Qt::WindowFullScreen);
+#undef WSTATE
+#endif
+ if(!(newstate & (Qt::WindowMinimized|Qt::WindowFullScreen)) &&
+ ((oldstate & Qt::WindowFullScreen) || (oldstate & Qt::WindowMinimized) ||
+ (oldstate & Qt::WindowMaximized) != (newstate & Qt::WindowMaximized))) {
+ if(newstate & Qt::WindowMaximized) {
+ data->fstrut_dirty = true;
+#ifndef QT_MAC_USE_COCOA
+ HIToolbarRef toolbarRef;
+ if (GetWindowToolbar(window, &toolbarRef) == noErr && toolbarRef
+ && !isVisible() && !IsWindowToolbarVisible(window)) {
+ // HIToolbar, needs to be shown so that it's in the structure window
+ // Typically this is part of a main window and will get shown
+ // during the show, but it's will make the maximize all wrong.
+ ShowHideWindowToolbar(window, true, false);
+ d->updateFrameStrut(); // In theory the dirty would work, but it's optimized out if the window is not visible :(
+ }
+ Rect bounds;
+ QDesktopWidget *dsk = QApplication::desktop();
+ QRect avail = dsk->availableGeometry(dsk->screenNumber(this));
+ SetRect(&bounds, avail.x(), avail.y(), avail.x() + avail.width(), avail.y() + avail.height());
+ if(QWExtra *extra = d->extraData()) {
+ if(bounds.right - bounds.left > extra->maxw)
+ bounds.right = bounds.left + extra->maxw;
+ if(bounds.bottom - bounds.top > extra->maxh)
+ bounds.bottom = bounds.top + extra->maxh;
+ }
+ if(d->topData()) {
+ QRect fs = d->frameStrut();
+ bounds.left += fs.left();
+ if(bounds.right < avail.x()+avail.width())
+ bounds.right = qMin<short>((uint)avail.x()+avail.width(), bounds.right+fs.left());
+ if(bounds.bottom < avail.y()+avail.height())
+ bounds.bottom = qMin<short>((uint)avail.y()+avail.height(), bounds.bottom+fs.top());
+ bounds.top += fs.top();
+ bounds.right -= fs.right();
+ bounds.bottom -= fs.bottom();
+ }
+ QRect orect(geometry().x(), geometry().y(), width(), height()),
+ nrect(bounds.left, bounds.top, bounds.right - bounds.left,
+ bounds.bottom - bounds.top);
+ if(orect != nrect) { // the new rect differ from the old
+ Point idealSize = { nrect.height(), nrect.width() };
+ ZoomWindowIdeal(window, inZoomOut, &idealSize);
+ }
+#else
+ NSToolbar *toolbarRef = [window toolbar];
+ if (toolbarRef && !isVisible() && ![toolbarRef isVisible]) {
+ // HIToolbar, needs to be shown so that it's in the structure window
+ // Typically this is part of a main window and will get shown
+ // during the show, but it's will make the maximize all wrong.
+ // ### Not sure this is right for NSToolbar...
+ [toolbarRef setVisible:true];
+// ShowHideWindowToolbar(window, true, false);
+ d->updateFrameStrut(); // In theory the dirty would work, but it's optimized out if the window is not visible :(
+ }
+ // Everything should be handled by Cocoa.
+ [window zoom:window];
+#endif
+ needSendStateChange = oldstate == windowState(); // Zoom didn't change flags.
+ } else if(oldstate & Qt::WindowMaximized) {
+#ifndef QT_MAC_USE_COCOA
+ Point idealSize;
+ ZoomWindowIdeal(window, inZoomIn, &idealSize);
+#else
+ [window zoom:window];
+#endif
+ if(QTLWExtra *tlextra = d->topData()) {
+ setGeometry(tlextra->normalGeometry);
+ tlextra->normalGeometry.setRect(0, 0, -1, -1);
+ }
+ }
+ }
+ }
+
+ data->window_state = newstate;
+
+ if(needShow)
+ show();
+
+ if(newstate & Qt::WindowActive)
+ activateWindow();
+
+ qt_event_request_window_change(this);
+ if (needSendStateChange) {
+ QWindowStateChangeEvent e(oldstate);
+ QApplication::sendEvent(this, &e);
+ }
+}
+
+void QWidgetPrivate::setFocus_sys()
+{
+ Q_Q(QWidget);
+ if (q->testAttribute(Qt::WA_WState_Created)) {
+#ifdef QT_MAC_USE_COCOA
+ QMacCocoaAutoReleasePool pool;
+ NSView *view = qt_mac_nativeview_for(q);
+ [[view window] makeFirstResponder:view];
+#else
+ SetKeyboardFocus(qt_mac_window_for(q), qt_mac_nativeview_for(q), 1);
+#endif
+ }
+}
+
+void QWidgetPrivate::raise_sys()
+{
+ Q_Q(QWidget);
+ if((q->windowType() == Qt::Desktop))
+ return;
+
+#if QT_MAC_USE_COCOA
+ QMacCocoaAutoReleasePool pool;
+ if (isRealWindow()) {
+ // Calling orderFront shows the window on Cocoa too.
+ if (!q->testAttribute(Qt::WA_DontShowOnScreen) && q->isVisible()) {
+ [qt_mac_window_for(q) orderFront:qt_mac_window_for(q)];
+ }
+ if (qt_mac_raise_process) { //we get to be the active process now
+ ProcessSerialNumber psn;
+ GetCurrentProcess(&psn);
+ SetFrontProcessWithOptions(&psn, kSetFrontProcessFrontWindowOnly);
+ }
+ } else {
+ // Cocoa doesn't really have an idea of Z-ordering, but you can
+ // fake it by changing the order of it. But beware, removing an
+ // NSView will also remove it as the first responder. So we re-set
+ // the first responder just in case:
+ NSView *view = qt_mac_nativeview_for(q);
+ NSView *parentView = [view superview];
+ NSResponder *firstResponder = [[view window] firstResponder];
+ [view removeFromSuperview];
+ [parentView addSubview:view];
+ [[view window] makeFirstResponder:firstResponder];
+ }
+#else
+ if(q->isWindow()) {
+ //raise this window
+ BringToFront(qt_mac_window_for(q));
+ if(qt_mac_raise_process) { //we get to be the active process now
+ ProcessSerialNumber psn;
+ GetCurrentProcess(&psn);
+ SetFrontProcessWithOptions(&psn, kSetFrontProcessFrontWindowOnly);
+ }
+ } else if(q->parentWidget()) {
+ HIViewSetZOrder(qt_mac_nativeview_for(q), kHIViewZOrderAbove, 0);
+ qt_event_request_window_change(q);
+ }
+#endif
+}
+
+void QWidgetPrivate::lower_sys()
+{
+ Q_Q(QWidget);
+ if((q->windowType() == Qt::Desktop))
+ return;
+#ifdef QT_MAC_USE_COCOA
+ QMacCocoaAutoReleasePool pool;
+ if (isRealWindow()) {
+ OSWindowRef window = qt_mac_window_for(q);
+ [window orderBack:window];
+ } else {
+ // Cocoa doesn't really have an idea of Z-ordering, but you can
+ // fake it by changing the order of it. In this case
+ // we put the item at the beginning of the list, but that means
+ // we must re-insert everything since we cannot modify the list directly.
+ NSView *myview = qt_mac_nativeview_for(q);
+ NSView *parentView = [myview superview];
+ NSArray *tmpViews = [parentView subviews];
+ NSMutableArray *subviews = [[NSMutableArray alloc] initWithCapacity:[tmpViews count]];
+ [subviews addObjectsFromArray:tmpViews];
+ NSResponder *firstResponder = [[myview window] firstResponder];
+ // Implicit assumption that myViewIndex is included in subviews, that's why I'm not checking
+ // myViewIndex.
+ NSUInteger index = 0;
+ NSUInteger myViewIndex = 0;
+ bool foundMyView = false;
+ for (NSView *subview in subviews) {
+ [subview removeFromSuperview];
+ if (subview == myview) {
+ foundMyView = true;
+ myViewIndex = index;
+ }
+ ++index;
+ }
+ [parentView addSubview:myview];
+ if (foundMyView)
+ [subviews removeObjectAtIndex:myViewIndex];
+ for (NSView *subview in subviews)
+ [parentView addSubview:subview];
+ [subviews release];
+ [[myview window] makeFirstResponder:firstResponder];
+ }
+#else
+ if(q->isWindow()) {
+ SendBehind(qt_mac_window_for(q), 0);
+ } else if(q->parentWidget()) {
+ invalidateBuffer(q->rect());
+ HIViewSetZOrder(qt_mac_nativeview_for(q), kHIViewZOrderBelow, 0);
+ qt_event_request_window_change(q);
+ }
+#endif
+}
+
+void QWidgetPrivate::stackUnder_sys(QWidget *w)
+{
+ // stackUnder
+ Q_Q(QWidget);
+ if(!w || q->isWindow() || (q->windowType() == Qt::Desktop))
+ return;
+#ifdef QT_MAC_USE_COCOA
+ // Do the same trick as lower_sys() and put this widget before the widget passed in.
+ QMacCocoaAutoReleasePool pool;
+ NSView *myview = qt_mac_nativeview_for(q);
+ NSView *wView = qt_mac_nativeview_for(w);
+ NSView *parentView = [myview superview];
+ NSArray *tmpViews = [parentView subviews];
+ NSMutableArray *subviews = [[NSMutableArray alloc] initWithCapacity:[tmpViews count]];
+ [subviews addObjectsFromArray:tmpViews];
+ // Implicit assumption that myViewIndex and wViewIndex is included in subviews,
+ // that's why I'm not checking myViewIndex.
+ NSUInteger index = 0;
+ NSUInteger myViewIndex = 0;
+ NSUInteger wViewIndex = 0;
+ for (NSView *subview in subviews) {
+ [subview removeFromSuperview];
+ if (subview == myview)
+ myViewIndex = index;
+ else if (subview == wView)
+ wViewIndex = index;
+ ++index;
+ }
+
+ index = 0;
+ for (NSView *subview in subviews) {
+ if (index == myViewIndex)
+ continue;
+ if (index == wViewIndex)
+ [parentView addSubview:myview];
+ [parentView addSubview:subview];
+ ++index;
+ }
+ [subviews release];
+#else
+ QWidget *p = q->parentWidget();
+ if(!p || p != w->parentWidget())
+ return;
+ invalidateBuffer(q->rect());
+ HIViewSetZOrder(qt_mac_nativeview_for(q), kHIViewZOrderBelow, qt_mac_nativeview_for(w));
+ qt_event_request_window_change(q);
+#endif
+}
+
+/*
+ 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
+ and QWidgetPrivate::isOpaque flags.
+*/
+static void qt_mac_update_widget_posisiton(QWidget *q, QRect oldRect, QRect newRect)
+{
+#ifndef QT_MAC_USE_COCOA
+ HIRect bounds = CGRectMake(newRect.x(), newRect.y(),
+ newRect.width(), newRect.height());
+
+ const HIViewRef view = qt_mac_nativeview_for(q);
+ const bool isMove = (oldRect.topLeft() != newRect.topLeft());
+ const bool isResize = (oldRect.size() != newRect.size());
+
+// qDebug() << oldRect << newRect << isMove << isResize << q->testAttribute(Qt::WA_OpaquePaintEvent) << q->testAttribute(Qt::WA_StaticContents);
+ QWidgetPrivate *qd = qt_widget_private(q);
+
+ // Perform a normal (complete repaint) update in some cases:
+ if (
+ // move-by-scroll requires QWidgetPrivate::isOpaque set
+ (isMove && q->testAttribute(Qt::WA_OpaquePaintEvent) == false) ||
+
+ // limited update on resize requires WA_StaticContents.
+ (isResize && q->testAttribute(Qt::WA_StaticContents) == false) ||
+
+ // one of the rects are invalid
+ (oldRect.isValid() == false || newRect.isValid() == false) ||
+
+ // the position update is a part of a drag-and-drop operation
+ QDragManager::self()->object ||
+
+ // we are on Panther (no HIViewSetNeedsDisplayInRect)
+ QSysInfo::MacintoshVersion < QSysInfo::MV_10_4
+ ){
+ HIViewSetFrame(view, &bounds);
+ return;
+ }
+
+ const int dx = newRect.x() - oldRect.x();
+ const int dy = newRect.y() - oldRect.y();
+
+ if (isMove) {
+ // HIViewScrollRect silently fails if we try to scroll anything under the grow box.
+ // Check if there's one present within the widget rect, and if there is fall back
+ // to repainting the entire widget.
+ QWidget const * const parentWidget = q->parentWidget();
+ const HIViewRef parentView = qt_mac_nativeview_for(parentWidget);
+ HIViewRef nativeSizeGrip = 0;
+ if (q->testAttribute(Qt::WA_WState_Created))
+ HIViewFindByID(HIViewGetRoot(HIViewGetWindow(HIViewRef(q->winId()))), kHIViewWindowGrowBoxID, &nativeSizeGrip);
+ if (nativeSizeGrip) {
+ QWidget * const window = q->window();
+
+ const int sizeGripSize = 20;
+ const QRect oldWidgetRect = QRect(q->mapTo(window, QPoint(0, 0)), QSize(oldRect.width(), oldRect.height()));
+ const QRect newWidgetRect = QRect(q->mapTo(window, QPoint(0, 0)), QSize(newRect.width(), newRect.height()));
+ const QRect sizeGripRect = QRect(window->rect().bottomRight() - QPoint(sizeGripSize, sizeGripSize),
+ window->rect().bottomRight());
+
+ if (sizeGripRect.intersects(oldWidgetRect) || sizeGripRect.intersects(newWidgetRect)) {
+ HIViewSetFrame(view, &bounds);
+ return;
+ }
+ }
+
+ // Don't scroll anything outside the parent widget rect.
+ const QRect scrollRect = (oldRect | newRect) & parentWidget->rect();
+ const HIRect scrollBounds =
+ CGRectMake(scrollRect.x(), scrollRect.y(), scrollRect.width(), scrollRect.height());
+
+ // We cannot scroll when the widget has a mask as that would
+ // scroll the masked out areas too
+ if (qd->extra && qd->extra->hasMask) {
+ HIViewMoveBy(view, dx, dy);
+ return;
+ }
+
+ OSStatus err = HIViewScrollRect(parentView, &scrollBounds, dx, dy);
+ if (err != noErr) {
+ HIViewSetNeedsDisplay(view, true);
+ qWarning("QWidget: Internal error (%s:%d)", __FILE__, __LINE__);
+ }
+ }
+ // Set the view bounds with drawing disabled to prevent repaints.
+ HIViewSetDrawingEnabled(view, false);
+ HIViewSetFrame(view, &bounds);
+ HIViewSetDrawingEnabled(view, true);
+
+ // Update any newly exposed areas due to resizing.
+ const int startx = oldRect.width();
+ const int stopx = newRect.width();
+ const int starty = oldRect.height();
+ const int stopy = newRect.height();
+
+ const HIRect verticalSlice = CGRectMake(startx, 0, stopx , stopy);
+ HIViewSetNeedsDisplayInRect(view, &verticalSlice, true);
+ 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());
+ [qt_mac_nativeview_for(q) setFrame:bounds];
+#endif
+}
+
+/*
+ Helper function for non-toplevel widgets. Helps to map Qt's 32bit
+ coordinate system to OS X's 16bit coordinate system.
+
+ Sets the geometry of the widget to data.crect, but clipped to sizes
+ that OS X can handle. Unmaps widgets that are completely outside the
+ valid range.
+
+ Maintains data.wrect, which is the geometry of the OS X widget,
+ measured in this widget's coordinate system.
+
+ if the parent is not clipped, parentWRect is empty, otherwise
+ parentWRect is the geometry of the parent's OS X rect, measured in
+ parent's coord sys
+*/
+void QWidgetPrivate::setWSGeometry(bool dontShow, const QRect &oldRect)
+{
+ Q_Q(QWidget);
+ Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
+ Q_UNUSED(oldRect);
+ /*
+ There are up to four different coordinate systems here:
+ Qt coordinate system for this widget.
+ X coordinate system for this widget (relative to wrect).
+ Qt coordinate system for parent
+ X coordinate system for parent (relative to parent's wrect).
+ */
+ 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) {
+#ifndef QT_MAC_USE_COCOA
+ HIViewRef parentView = HIViewGetSuperview(qt_mac_nativeview_for(q));
+#else
+ NSView *parentView = [qt_mac_nativeview_for(q) superview];
+#endif
+ if (parentView) {
+#ifndef QT_MAC_USE_COCOA
+ HIRect tmpRect;
+ HIViewGetFrame(parentView, &tmpRect);
+#else
+ NSRect tmpRect = [parentView frame];
+#endif
+ parentWRect = QRect(tmpRect.origin.x, tmpRect.origin.y,
+ tmpRect.size.width, tmpRect.size.height);
+ } else {
+ const QRect wrectRange(-WRECT_MAX,-WRECT_MAX, 2*WRECT_MAX, 2*WRECT_MAX);
+ parentWRect = wrectRange;
+ }
+ } else {
+ 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)) {
+ xrect &= parentWRect;
+ wrect = xrect;
+ //translate from parent's to my Qt coord sys
+ wrect.translate(-data.crect.topLeft());
+ }
+ //translate from parent's Qt coords to parent's X coords
+ xrect.translate(-parentWRect.topLeft());
+
+ } else {
+ // parent is not clipped, we may or may not have to clip
+
+ if (data.wrect.isValid() && QRect(QPoint(),data.crect.size()).contains(data.wrect)) {
+ // This is where the main optimization is: we are already
+ // clipped, and if our clip is still valid, we can just
+ // move our window, and do not need to move or clip
+ // children
+
+ QRect vrect = xrect & q->parentWidget()->rect();
+ vrect.translate(-data.crect.topLeft()); //the part of me that's visible through parent, in my Qt coords
+ if (data.wrect.contains(vrect)) {
+ xrect = data.wrect;
+ xrect.translate(data.crect.topLeft());
+#ifndef QT_MAC_USE_COCOA
+ HIRect bounds = CGRectMake(xrect.x(), xrect.y(),
+ xrect.width(), xrect.height());
+ HIViewSetFrame(qt_mac_nativeview_for(q), &bounds);
+#else
+ NSRect bounds = NSMakeRect(xrect.x(), xrect.y(),
+ xrect.width(), xrect.height());
+ [qt_mac_nativeview_for(q) setFrame:bounds];
+#endif
+ if (q->testAttribute(Qt::WA_OutsideWSRange)) {
+ q->setAttribute(Qt::WA_OutsideWSRange, false);
+ if (!dontShow) {
+ q->setAttribute(Qt::WA_Mapped);
+#ifndef QT_MAC_USE_COCOA
+ HIViewSetVisible(qt_mac_nativeview_for(q), true);
+#else
+ [qt_mac_nativeview_for(q) setHidden:NO];
+#endif
+ }
+ }
+ return;
+ }
+ }
+
+ const QRect validRange(-XCOORD_MAX,-XCOORD_MAX, 2*XCOORD_MAX, 2*XCOORD_MAX);
+ if (!validRange.contains(xrect)) {
+ // we are too big, and must clip
+ QPoint screenOffset(0, 0); // offset of the part being on screen
+ const QWidget *parentWidget = q->parentWidget();
+ while (parentWidget && !parentWidget->isWindow()) {
+ screenOffset -= parentWidget->data->crect.topLeft();
+ parentWidget = parentWidget->parentWidget();
+ }
+ QRect cropRect(screenOffset.x() - WRECT_MAX,
+ screenOffset.y() - WRECT_MAX,
+ 2*WRECT_MAX,
+ 2*WRECT_MAX);
+
+ xrect &=cropRect;
+ wrect = xrect;
+ wrect.translate(-data.crect.topLeft()); // translate wrect in my Qt coordinates
+ }
+ }
+
+ // unmap if we are outside the valid window system coord system
+ bool outsideRange = !xrect.isValid();
+ bool mapWindow = false;
+ if (q->testAttribute(Qt::WA_OutsideWSRange) != outsideRange) {
+ q->setAttribute(Qt::WA_OutsideWSRange, outsideRange);
+ if (outsideRange) {
+#ifndef QT_MAC_USE_COCOA
+ HIViewSetVisible(qt_mac_nativeview_for(q), false);
+#else
+ [qt_mac_nativeview_for(q) setHidden:YES];
+#endif
+ q->setAttribute(Qt::WA_Mapped, false);
+ } else if (!q->isHidden()) {
+ mapWindow = true;
+ }
+ }
+
+ if (outsideRange)
+ return;
+
+ bool jump = (data.wrect != wrect);
+ data.wrect = wrect;
+
+
+ // and now recursively for all children...
+ // ### can be optimized
+ for (int i = 0; i < children.size(); ++i) {
+ QObject *object = children.at(i);
+ if (object->isWidgetType()) {
+ QWidget *w = static_cast<QWidget *>(object);
+ if (!w->isWindow() && w->testAttribute(Qt::WA_WState_Created))
+ w->d_func()->setWSGeometry();
+ }
+ }
+
+ qt_mac_update_widget_posisiton(q, oldRect, xrect);
+
+ if (jump)
+ q->update();
+
+ if (mapWindow && !dontShow) {
+ q->setAttribute(Qt::WA_Mapped);
+#ifndef QT_MAC_USE_COCOA
+ HIViewSetVisible(qt_mac_nativeview_for(q), true);
+#else
+ [qt_mac_nativeview_for(q) setHidden:NO];
+#endif
+ }
+}
+
+void QWidgetPrivate::adjustWithinMaxAndMinSize(int &w, int &h)
+{
+ if (QWExtra *extra = extraData()) {
+ w = qMin(w, extra->maxw);
+ h = qMin(h, extra->maxh);
+ w = qMax(w, extra->minw);
+ h = qMax(h, extra->minh);
+
+ // Deal with size increment
+ if (QTLWExtra *top = topData()) {
+ if(top->incw) {
+ w = w/top->incw;
+ w *= top->incw;
+ }
+ if(top->inch) {
+ h = h/top->inch;
+ h *= top->inch;
+ }
+ }
+ }
+
+ if (isRealWindow()) {
+ w = qMax(0, w);
+ h = qMax(0, h);
+ }
+}
+
+void QWidgetPrivate::applyMaxAndMinSizeOnWindow()
+{
+ Q_Q(QWidget);
+ const float max_f(20000);
+#ifndef QT_MAC_USE_COCOA
+#define SF(x) ((x > max_f) ? max_f : x)
+ HISize max = CGSizeMake(SF(extra->maxw), SF(extra->maxh));
+ HISize min = CGSizeMake(SF(extra->minw), SF(extra->minh));
+#undef SF
+ SetWindowResizeLimits(qt_mac_window_for(q), &min, &max);
+#else
+#define SF(x) ((x > max_f) ? max_f : x)
+ NSSize max = NSMakeSize(SF(extra->maxw), SF(extra->maxh));
+ NSSize min = NSMakeSize(SF(extra->minw), SF(extra->minh));
+#undef SF
+ [qt_mac_window_for(q) setContentMinSize:min];
+ [qt_mac_window_for(q) setContentMaxSize:max];
+#endif
+}
+
+void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
+{
+ Q_Q(QWidget);
+ Q_ASSERT(q->testAttribute(Qt::WA_WState_Created));
+
+ if(q->windowType() == Qt::Desktop)
+ return;
+
+ QMacCocoaAutoReleasePool pool;
+ bool realWindow = isRealWindow();
+
+ if (realWindow && !q->testAttribute(Qt::WA_DontShowOnScreen)){
+ adjustWithinMaxAndMinSize(w, h);
+#ifndef QT_MAC_USE_COCOA
+ if (w != 0 && h != 0) {
+ topData()->isSetGeometry = 1;
+ topData()->isMove = isMove;
+ Rect r; SetRect(&r, x, y, x + w, y + h);
+ SetWindowBounds(qt_mac_window_for(q), kWindowContentRgn, &r);
+ topData()->isSetGeometry = 0;
+ } else {
+ setGeometry_sys_helper(x, y, w, h, isMove);
+ }
+#else
+ 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()),
+ QSize(fStrut.left() + fStrut.right() + w,
+ fStrut.top() + fStrut.bottom() + h));
+ NSRect cocoaFrameRect = NSMakeRect(frameRect.x(), flipYCoordinate(frameRect.bottom() + 1),
+ frameRect.width(), frameRect.height());
+ // The setFrame call will trigger a 'windowDidResize' notification for the corresponding
+ // NSWindow. The pending flag is set, so that the resize event can be send as non-spontaneous.
+ if (isResize)
+ 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];
+ } 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];
+ cocoaFrameRect.origin.y -= 1;
+ [window setFrameOrigin:cocoaFrameRect.origin];
+ }
+#endif
+ } else {
+ setGeometry_sys_helper(x, y, w, h, isMove);
+ }
+}
+
+void QWidgetPrivate::setGeometry_sys_helper(int x, int y, int w, int h, bool isMove)
+{
+ Q_Q(QWidget);
+ bool realWindow = isRealWindow();
+
+ QPoint oldp = q->pos();
+ QSize olds = q->size();
+ const bool isResize = (olds != QSize(w, h));
+
+ if (!realWindow && !isResize && QPoint(x, y) == oldp)
+ return;
+
+ if (isResize)
+ data.window_state = data.window_state & ~Qt::WindowMaximized;
+
+ const bool visible = q->isVisible();
+ data.crect = QRect(x, y, w, h);
+
+ if (realWindow) {
+ adjustWithinMaxAndMinSize(w, h);
+ qt_mac_update_sizer(q);
+
+#ifndef QT_MAC_USE_COCOA
+ if (q->windowFlags() & Qt::WindowMaximizeButtonHint) {
+ OSWindowRef window = qt_mac_window_for(q);
+ if (extra->maxw && extra->maxh && extra->maxw == extra->minw
+ && extra->maxh == extra->minh) {
+ ChangeWindowAttributes(window, kWindowNoAttributes, kWindowFullZoomAttribute);
+ } else {
+ ChangeWindowAttributes(window, kWindowFullZoomAttribute, kWindowNoAttributes);
+ }
+ }
+ HIRect bounds = CGRectMake(0, 0, w, h);
+ HIViewSetFrame(qt_mac_nativeview_for(q), &bounds);
+#else
+ [qt_mac_nativeview_for(q) setFrame:NSMakeRect(0, 0, w, h)];
+#endif
+ } else {
+ const QRect oldRect(oldp, olds);
+ if (!isResize && QApplicationPrivate::graphicsSystem())
+ moveRect(oldRect, x - oldp.x(), y - oldp.y());
+ setWSGeometry(false, oldRect);
+ if (isResize && QApplicationPrivate::graphicsSystem()) {
+ invalidateBuffer(q->rect());
+ if (extra && !graphicsEffect && !extra->mask.isEmpty()) {
+ QRegion oldRegion(extra->mask.translated(oldp));
+ oldRegion &= oldRect;
+ q->parentWidget()->d_func()->invalidateBuffer(oldRegion);
+ } else {
+ q->parentWidget()->d_func()->invalidateBuffer(effectiveRectFor(oldRect));
+ }
+ }
+ }
+
+ if(isMove || isResize) {
+ if(!visible) {
+ if(isMove && q->pos() != oldp)
+ q->setAttribute(Qt::WA_PendingMoveEvent, true);
+ if(isResize)
+ q->setAttribute(Qt::WA_PendingResizeEvent, true);
+ } else {
+ if(isResize) { //send the resize event..
+ QResizeEvent e(q->size(), olds);
+ QApplication::sendEvent(q, &e);
+ }
+ if(isMove && q->pos() != oldp) { //send the move event..
+ QMoveEvent e(q->pos(), oldp);
+ QApplication::sendEvent(q, &e);
+ }
+ }
+ }
+ qt_event_request_window_change(q);
+}
+
+void QWidgetPrivate::setConstraints_sys()
+{
+ updateMaximizeButton_sys();
+ applyMaxAndMinSizeOnWindow();
+}
+
+void QWidgetPrivate::updateMaximizeButton_sys()
+{
+ Q_Q(QWidget);
+ if (q->data->window_flags & Qt::CustomizeWindowHint)
+ return;
+
+ OSWindowRef window = qt_mac_window_for(q);
+ QTLWExtra * tlwExtra = topData();
+#ifdef QT_MAC_USE_COCOA
+ QMacCocoaAutoReleasePool pool;
+ NSButton *maximizeButton = [window standardWindowButton:NSWindowZoomButton];
+#endif
+ if (extra->maxw && extra->maxh
+ && extra->maxw == extra->minw
+ && extra->maxh == extra->minh) {
+ // The window has a fixed size, so gray out the maximize button:
+ if (!tlwExtra->savedWindowAttributesFromMaximized) {
+#ifndef QT_MAC_USE_COCOA
+ GetWindowAttributes(window,
+ (WindowAttributes*)&extra->topextra->savedWindowAttributesFromMaximized);
+
+#else
+ tlwExtra->savedWindowAttributesFromMaximized = (![maximizeButton isHidden] && [maximizeButton isEnabled]);
+#endif
+ }
+#ifndef QT_MAC_USE_COCOA
+ ChangeWindowAttributes(window, kWindowNoAttributes, kWindowFullZoomAttribute);
+#else
+ [maximizeButton setEnabled:NO];
+#endif
+
+
+ } else {
+ if (tlwExtra->savedWindowAttributesFromMaximized) {
+#ifndef QT_MAC_USE_COCOA
+ ChangeWindowAttributes(window,
+ extra->topextra->savedWindowAttributesFromMaximized,
+ kWindowNoAttributes);
+#else
+ [maximizeButton setEnabled:YES];
+#endif
+ tlwExtra->savedWindowAttributesFromMaximized = 0;
+ }
+ }
+
+
+}
+
+void QWidgetPrivate::scroll_sys(int dx, int dy)
+{
+ if (QApplicationPrivate::graphicsSystem() && !paintOnScreen()) {
+ scrollChildren(dx, dy);
+ scrollRect(q_func()->rect(), dx, dy);
+ } else {
+ scroll_sys(dx, dy, QRect());
+ }
+}
+
+void QWidgetPrivate::scroll_sys(int dx, int dy, const QRect &r)
+{
+ Q_Q(QWidget);
+
+ if (QApplicationPrivate::graphicsSystem() && !paintOnScreen()) {
+ scrollRect(r, dx, dy);
+ return;
+ }
+
+ const bool valid_rect = r.isValid();
+ if (!q->updatesEnabled() && (valid_rect || q->children().isEmpty()))
+ return;
+
+ qt_event_request_window_change(q);
+
+#ifdef QT_MAC_USE_COCOA
+ QMacCocoaAutoReleasePool pool;
+#endif
+
+ if(!valid_rect) { // scroll children
+ QPoint pd(dx, dy);
+ QWidgetList moved;
+ QObjectList chldrn = q->children();
+ for(int i = 0; i < chldrn.size(); i++) { //first move all children
+ QObject *obj = chldrn.at(i);
+ if(obj->isWidgetType()) {
+ QWidget *w = (QWidget*)obj;
+ if(!w->isWindow()) {
+ w->data->crect = QRect(w->pos() + pd, w->size());
+ if (w->testAttribute(Qt::WA_WState_Created)) {
+#ifndef QT_MAC_USE_COCOA
+ HIRect bounds = CGRectMake(w->data->crect.x(), w->data->crect.y(),
+ w->data->crect.width(), w->data->crect.height());
+ HIViewRef hiview = qt_mac_nativeview_for(w);
+ const bool opaque = q->testAttribute(Qt::WA_OpaquePaintEvent);
+
+ if (opaque)
+ HIViewSetDrawingEnabled(hiview, false);
+ HIViewSetFrame(hiview, &bounds);
+ if (opaque)
+ HIViewSetDrawingEnabled(hiview, true);
+#else
+ [qt_mac_nativeview_for(w)
+ setFrame:NSMakeRect(w->data->crect.x(), w->data->crect.y(),
+ w->data->crect.width(), w->data->crect.height())];
+#endif
+ }
+ moved.append(w);
+ }
+ }
+ }
+ //now send move events (do not do this in the above loop, breaks QAquaFocusWidget)
+ for(int i = 0; i < moved.size(); i++) {
+ QWidget *w = moved.at(i);
+ QMoveEvent e(w->pos(), w->pos() - pd);
+ QApplication::sendEvent(w, &e);
+ }
+ }
+
+ if (!q->testAttribute(Qt::WA_WState_Created) || !q->isVisible())
+ return;
+
+ OSViewRef view = qt_mac_nativeview_for(q);
+#ifndef QT_MAC_USE_COCOA
+ HIRect scrollrect = CGRectMake(r.x(), r.y(), r.width(), r.height());
+ OSStatus err = _HIViewScrollRectWithOptions(view, valid_rect ? &scrollrect : 0, dx, dy, kHIViewScrollRectAdjustInvalid);
+ if (err) {
+ // The only parameter that can go wrong, is the rect.
+ qWarning("QWidget::scroll: Your rectangle was too big for the widget, clipping rect");
+ scrollrect = CGRectMake(qMax(r.x(), 0), qMax(r.y(), 0),
+ qMin(r.width(), q->width()), qMin(r.height(), q->height()));
+ _HIViewScrollRectWithOptions(view, valid_rect ? &scrollrect : 0, dx, dy, kHIViewScrollRectAdjustInvalid);
+ }
+#else
+ NSRect scrollRect = valid_rect ? NSMakeRect(r.x(), r.y(), r.width(), r.height())
+ : NSMakeRect(0, 0, q->width(), q->height());
+
+
+ // calc the updateRect
+ NSRect deltaXRect = { {0, 0}, {0, 0} };
+ NSRect deltaYRect = { {0, 0}, {0, 0} };
+ if (dy != 0) {
+ deltaYRect.size.width = scrollRect.size.width;
+ if (dy > 0) {
+ deltaYRect.size.height = dy;
+ } else {
+ deltaYRect.size.height = -dy;
+ deltaYRect.origin.y = scrollRect.size.height + dy;
+ }
+ }
+ if (dx != 0) {
+ deltaXRect.size.height = scrollRect.size.height;
+ if (dx > 0) {
+ deltaXRect.size.width = dx;
+ } else {
+ deltaXRect.size.width = -dx;
+ deltaXRect.origin.x = scrollRect.size.width + dx;
+ }
+ }
+
+ NSSize deltaSize = NSMakeSize(dx, dy);
+ [view translateRectsNeedingDisplayInRect:scrollRect by:deltaSize];
+ [view scrollRect:scrollRect by:deltaSize];
+ [view setNeedsDisplayInRect:deltaXRect];
+ [view setNeedsDisplayInRect:deltaYRect];
+#endif // QT_MAC_USE_COCOA
+}
+
+int QWidget::metric(PaintDeviceMetric m) const
+{
+ switch(m) {
+ case PdmHeightMM:
+ return qRound(metric(PdmHeight) * 25.4 / qreal(metric(PdmDpiY)));
+ case PdmWidthMM:
+ return qRound(metric(PdmWidth) * 25.4 / qreal(metric(PdmDpiX)));
+ case PdmHeight:
+ case PdmWidth: {
+#ifndef QT_MAC_USE_COCOA
+ HIRect rect;
+ HIViewGetFrame(qt_mac_nativeview_for(this), &rect);
+#else
+ NSRect rect = [qt_mac_nativeview_for(this) frame];
+#endif
+ if(m == PdmWidth)
+ return (int)rect.size.width;
+ return (int)rect.size.height; }
+ case PdmDepth:
+ return 32;
+ case PdmNumColors:
+ return INT_MAX;
+ case PdmDpiX:
+ case PdmPhysicalDpiX: {
+ Q_D(const QWidget);
+ if (d->extra && d->extra->customDpiX)
+ return d->extra->customDpiX;
+ else if (d->parent)
+ return static_cast<QWidget *>(d->parent)->metric(m);
+ extern float qt_mac_defaultDpi_x(); //qpaintdevice_mac.cpp
+ return int(qt_mac_defaultDpi_x()); }
+ case PdmDpiY:
+ case PdmPhysicalDpiY: {
+ Q_D(const QWidget);
+ if (d->extra && d->extra->customDpiY)
+ return d->extra->customDpiY;
+ else if (d->parent)
+ return static_cast<QWidget *>(d->parent)->metric(m);
+ extern float qt_mac_defaultDpi_y(); //qpaintdevice_mac.cpp
+ return int(qt_mac_defaultDpi_y()); }
+ default: //leave this so the compiler complains when new ones are added
+ qWarning("QWidget::metric: Unhandled parameter %d", m);
+ return QPaintDevice::metric(m);
+ }
+ return 0;
+}
+
+void QWidgetPrivate::createSysExtra()
+{
+#ifdef QT_MAC_USE_COCOA
+ extra->imageMask = 0;
+#endif
+}
+
+void QWidgetPrivate::deleteSysExtra()
+{
+#ifdef QT_MAC_USE_COCOA
+ if (extra->imageMask)
+ CFRelease(extra->imageMask);
+#endif
+}
+
+void QWidgetPrivate::createTLSysExtra()
+{
+ extra->topextra->resizer = 0;
+ extra->topextra->isSetGeometry = 0;
+ extra->topextra->isMove = 0;
+ extra->topextra->wattr = 0;
+ extra->topextra->wclass = 0;
+ extra->topextra->group = 0;
+ extra->topextra->windowIcon = 0;
+ extra->topextra->savedWindowAttributesFromMaximized = 0;
+}
+
+void QWidgetPrivate::deleteTLSysExtra()
+{
+#ifndef QT_MAC_USE_COCOA
+ if(extra->topextra->group) {
+ qt_mac_release_window_group(extra->topextra->group);
+ extra->topextra->group = 0;
+ }
+#endif
+}
+
+void QWidgetPrivate::updateFrameStrut()
+{
+ Q_Q(QWidget);
+
+ QWidgetPrivate *that = const_cast<QWidgetPrivate*>(this);
+
+ that->data.fstrut_dirty = false;
+ QTLWExtra *top = that->topData();
+
+#if QT_MAC_USE_COCOA
+ // 1 Get the window frame
+ OSWindowRef oswnd = qt_mac_window_for(q);
+ NSRect frameW = [oswnd frame];
+ // 2 Get the content frame - so now
+ NSRect frameC = [oswnd contentRectForFrameRect:frameW];
+ top->frameStrut.setCoords(frameC.origin.x - frameW.origin.x,
+ (frameW.origin.y + frameW.size.height) - (frameC.origin.y + frameC.size.height),
+ (frameW.origin.x + frameW.size.width) - (frameC.origin.x + frameC.size.width),
+ frameC.origin.y - frameW.origin.y);
+#else
+ Rect window_r;
+ GetWindowStructureWidths(qt_mac_window_for(q), &window_r);
+ top->frameStrut.setCoords(window_r.left, window_r.top, window_r.right, window_r.bottom);
+#endif
+}
+
+void QWidgetPrivate::registerDropSite(bool on)
+{
+ Q_Q(QWidget);
+ 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);
+ if (on && [view isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaView) class]]) {
+ [static_cast<QT_MANGLE_NAMESPACE(QCocoaView) *>(view) registerDragTypes];
+ }
+#endif
+}
+
+void QWidgetPrivate::registerTouchWindow()
+{
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
+ if (QSysInfo::MacintoshVersion < QSysInfo::MV_10_6)
+ return;
+ Q_Q(QWidget);
+ if (!q->testAttribute(Qt::WA_WState_Created))
+ return;
+#ifndef QT_MAC_USE_COCOA
+ // Needs implementation!
+#else
+ NSView *view = qt_mac_nativeview_for(q);
+ [view setAcceptsTouchEvents:YES];
+#endif
+#endif
+}
+
+void QWidgetPrivate::setMask_sys(const QRegion ®ion)
+{
+ Q_UNUSED(region);
+#ifndef QT_MAC_USE_COCOA
+ Q_Q(QWidget);
+ if (q->isWindow())
+ ReshapeCustomWindow(qt_mac_window_for(q));
+ else
+ HIViewReshapeStructure(qt_mac_nativeview_for(q));
+#else
+ if (extra->mask.isEmpty()) {
+ extra->maskBits = QImage();
+ finishCocoaMaskSetup();
+ } else {
+ syncCocoaMask();
+ }
+
+#endif
+}
+
+void QWidgetPrivate::setWindowOpacity_sys(qreal level)
+{
+ Q_Q(QWidget);
+
+ if (!q->isWindow())
+ return;
+
+ level = qBound(0.0, level, 1.0);
+ topData()->opacity = (uchar)(level * 255);
+ if (!q->testAttribute(Qt::WA_WState_Created))
+ return;
+
+ OSWindowRef oswindow = qt_mac_window_for(q);
+#if QT_MAC_USE_COCOA
+ [oswindow setAlphaValue:level];
+#else
+ SetWindowAlpha(oswindow, level);
+#endif
+}
+
+#ifdef QT_MAC_USE_COCOA
+void QWidgetPrivate::syncCocoaMask()
+{
+ Q_Q(QWidget);
+ if (!q->testAttribute(Qt::WA_WState_Created) || !extra)
+ return;
+
+ if (extra->hasMask && extra->maskBits.size() != q->size()) {
+ extra->maskBits = QImage(q->size(), QImage::Format_Mono);
+ extra->maskBits.fill(QColor(Qt::color1).rgba());
+ extra->maskBits.setNumColors(2);
+ extra->maskBits.setColor(0, QColor(Qt::color0).rgba());
+ extra->maskBits.setColor(1, QColor(Qt::color1).rgba());
+ QPainter painter(&extra->maskBits);
+ painter.setBrush(Qt::color1);
+ painter.setPen(Qt::NoPen);
+ painter.drawRects(extra->mask.rects());
+ painter.end();
+ finishCocoaMaskSetup();
+ }
+}
+
+void QWidgetPrivate::finishCocoaMaskSetup()
+{
+ Q_Q(QWidget);
+
+ if (!q->testAttribute(Qt::WA_WState_Created) || !extra)
+ return;
+
+ // Technically this is too late to release, because the data behind the image
+ // has already been released. But it's more tidy to do it here.
+ // If you are seeing a crash, consider doing a CFRelease before changing extra->maskBits.
+ if (extra->imageMask) {
+ CFRelease(extra->imageMask);
+ extra->imageMask = 0;
+ }
+
+ if (!extra->maskBits.isNull()) {
+ QCFType<CGDataProviderRef> dataProvider = CGDataProviderCreateWithData(0,
+ extra->maskBits.bits(),
+ extra->maskBits.numBytes(),
+ 0); // shouldn't need to release.
+ CGFloat decode[2] = {1, 0};
+ extra->imageMask = CGImageMaskCreate(extra->maskBits.width(), extra->maskBits.height(),
+ 1, 1, extra->maskBits.bytesPerLine(), dataProvider,
+ decode, false);
+ }
+ if (q->isWindow()) {
+ NSWindow *window = qt_mac_window_for(q);
+ [window setOpaque:(extra->imageMask == 0)];
+ [window invalidateShadow];
+ }
+ [qt_mac_nativeview_for(q) setNeedsDisplay:YES];
+}
+#endif
+
+struct QPaintEngineCleanupHandler
+{
+ inline QPaintEngineCleanupHandler() : engine(0) {}
+ inline ~QPaintEngineCleanupHandler() { delete engine; }
+ QPaintEngine *engine;
+};
+
+Q_GLOBAL_STATIC(QPaintEngineCleanupHandler, engineHandler)
+
+QPaintEngine *QWidget::paintEngine() const
+{
+ QPaintEngine *&pe = engineHandler()->engine;
+ if (!pe)
+ pe = new QCoreGraphicsPaintEngine();
+ if (pe->isActive()) {
+ QPaintEngine *engine = new QCoreGraphicsPaintEngine();
+ engine->setAutoDestruct(true);
+ return engine;
+ }
+ return pe;
+}
+
+void QWidgetPrivate::setModal_sys()
+{
+ Q_Q(QWidget);
+ if (!q->testAttribute(Qt::WA_WState_Created) || !q->isWindow())
+ return;
+ const QWidget * const windowParent = q->window()->parentWidget();
+ const QWidget * const primaryWindow = windowParent ? windowParent->window() : 0;
+ OSWindowRef windowRef = qt_mac_window_for(q);
+
+#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.
+ if (!alreadySheet) {
+ // NB: the following call will call setModal_sys recursivly:
+ recreateMacWindow();
+ windowRef = qt_mac_window_for(q);
+ }
+ if ([windowRef isKindOfClass:[NSPanel class]]){
+ // If the primary window of the sheet parent is a child of a modal dialog,
+ // the sheet parent should not be modally shaddowed.
+ // This goes for the sheet as well:
+ OSWindowRef ref = primaryWindow ? qt_mac_window_for(primaryWindow) : 0;
+ bool isDialog = ref ? [ref isKindOfClass:[NSPanel class]] : false;
+ 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.
+ if (alreadySheet){
+ // NB: the following call will call setModal_sys recursivly:
+ recreateMacWindow();
+ windowRef = qt_mac_window_for(q);
+ }
+ if (q->windowModality() == Qt::ApplicationModal) {
+ [windowRef setLevel:NSModalPanelWindowLevel];
+ } else if (primaryWindow && primaryWindow->windowModality() == Qt::ApplicationModal) {
+ // INVARIANT: Our window is a dialog that has a dialog parent that is
+ // application modal, or . This means that q is supposed to be on top of this
+ // 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;
+ const bool modal = q->testAttribute(Qt::WA_ShowModal);
+
+ WindowClass old_wclass;
+ GetWindowClass(windowRef, &old_wclass);
+
+ if (modal || primaryWindowModal) {
+ if (q->windowModality() == Qt::WindowModal
+ || (primaryWindow && primaryWindow->windowModality() == Qt::WindowModal)){
+ // Window should be window-modal (which implies a sheet).
+ if (old_wclass != kSheetWindowClass){
+ // We cannot convert a created window to a sheet.
+ // So we recreate the window:
+ recreateMacWindow();
+ return;
+ }
+ } else {
+ // Window should be application-modal (which implies NOT using a sheet).
+ if (old_wclass == kSheetWindowClass){
+ // We cannot convert a sheet to a window.
+ // So we recreate the window:
+ recreateMacWindow();
+ return;
+ } else if (!(q->data->window_flags & Qt::CustomizeWindowHint)) {
+ if (old_wclass == kDocumentWindowClass || old_wclass == kFloatingWindowClass || old_wclass == kUtilityWindowClass){
+ // Only change the class to kMovableModalWindowClass if the no explicit jewels
+ // are set (kMovableModalWindowClass can't contain them), and the current window class
+ // can be converted to modal (according to carbon doc). Mind the order of
+ // HIWindowChangeClass and ChangeWindowAttributes.
+ WindowGroupRef group = GetWindowGroup(windowRef);
+ HIWindowChangeClass(windowRef, kMovableModalWindowClass);
+ quint32 tmpWattr = kWindowCloseBoxAttribute | kWindowHorizontalZoomAttribute;
+ ChangeWindowAttributes(windowRef, tmpWattr, kWindowNoAttributes);
+ ChangeWindowAttributes(windowRef, kWindowNoAttributes, tmpWattr);
+ // If the window belongs to a qt-created group, set that group once more:
+ if (data.window_flags & Qt::WindowStaysOnTopHint
+ || q->windowType() == Qt::Popup
+ || q->windowType() == Qt::ToolTip)
+ SetWindowGroup(windowRef, group);
+ }
+ // Popups are usually handled "special" and are never modal.
+ Qt::WindowType winType = q->windowType();
+ if (winType != Qt::Popup && winType != Qt::ToolTip)
+ SetWindowModality(windowRef, kWindowModalityAppModal, 0);
+ }
+ }
+ } else if (windowRef) {
+ if (old_wclass == kSheetWindowClass){
+ // Converting a sheet to a window is complex. It's easier to recreate:
+ recreateMacWindow();
+ return;
+ }
+
+ SetWindowModality(windowRef, kWindowModalityNone, 0);
+ if (!(q->data->window_flags & Qt::CustomizeWindowHint)) {
+ if (q->window()->d_func()->topData()->wattr |= kWindowCloseBoxAttribute)
+ ChangeWindowAttributes(windowRef, kWindowCloseBoxAttribute, kWindowNoAttributes);
+ if (q->window()->d_func()->topData()->wattr |= kWindowHorizontalZoomAttribute)
+ ChangeWindowAttributes(windowRef, kWindowHorizontalZoomAttribute, kWindowNoAttributes);
+ if (q->window()->d_func()->topData()->wattr |= kWindowCollapseBoxAttribute)
+ ChangeWindowAttributes(windowRef, kWindowCollapseBoxAttribute, kWindowNoAttributes);
+ }
+
+ WindowClass newClass = q->window()->d_func()->topData()->wclass;
+ if (old_wclass != newClass && newClass != 0){
+ WindowGroupRef group = GetWindowGroup(windowRef);
+ HIWindowChangeClass(windowRef, newClass);
+ // If the window belongs to a qt-created group, set that group once more:
+ if (data.window_flags & Qt::WindowStaysOnTopHint
+ || q->windowType() == Qt::Popup
+ || q->windowType() == Qt::ToolTip)
+ SetWindowGroup(windowRef, group);
+ }
+ }
+
+ // Make sure that HIWindowChangeClass didn't remove drag support
+ // or reset the opaque size grip setting:
+ SetAutomaticControlDragTrackingEnabledForWindow(windowRef, true);
+ macUpdateOpaqueSizeGrip();
+#endif
+}
+
+void QWidgetPrivate::macUpdateHideOnSuspend()
+{
+ Q_Q(QWidget);
+ if (!q->testAttribute(Qt::WA_WState_Created) || !q->isWindow() || q->windowType() != Qt::Tool)
+ return;
+#ifndef QT_MAC_USE_COCOA
+ if(q->testAttribute(Qt::WA_MacAlwaysShowToolWindow))
+ ChangeWindowAttributes(qt_mac_window_for(q), 0, kWindowHideOnSuspendAttribute);
+ else
+ ChangeWindowAttributes(qt_mac_window_for(q), kWindowHideOnSuspendAttribute, 0);
+#else
+ if(q->testAttribute(Qt::WA_MacAlwaysShowToolWindow))
+ [qt_mac_window_for(q) setHidesOnDeactivate:NO];
+ else
+ [qt_mac_window_for(q) setHidesOnDeactivate:YES];
+#endif
+}
+
+void QWidgetPrivate::macUpdateOpaqueSizeGrip()
+{
+ Q_Q(QWidget);
+
+ if (!q->testAttribute(Qt::WA_WState_Created) || !q->isWindow())
+ return;
+
+#ifndef QT_MAC_USE_COCOA // Growbox is always transparent on Cocoa. Can emulate with setting a QSizeGrip
+ HIViewRef growBox;
+ HIViewFindByID(HIViewGetRoot(qt_mac_window_for(q)), kHIViewWindowGrowBoxID, &growBox);
+ if (!growBox)
+ return;
+ HIGrowBoxViewSetTransparent(growBox, !q->testAttribute(Qt::WA_MacOpaqueSizeGrip));
+#endif
+}
+
+void QWidgetPrivate::macUpdateSizeAttribute()
+{
+ Q_Q(QWidget);
+ QEvent event(QEvent::MacSizeChange);
+ QApplication::sendEvent(q, &event);
+ for (int i = 0; i < children.size(); ++i) {
+ QWidget *w = qobject_cast<QWidget *>(children.at(i));
+ if (w && (!w->isWindow() || w->testAttribute(Qt::WA_WindowPropagation))
+ && !q->testAttribute(Qt::WA_MacMiniSize) // no attribute set? inherit from parent
+ && !w->testAttribute(Qt::WA_MacSmallSize)
+ && !w->testAttribute(Qt::WA_MacNormalSize))
+ w->d_func()->macUpdateSizeAttribute();
+ }
+ resolveFont();
+}
+
+void QWidgetPrivate::macUpdateIgnoreMouseEvents()
+{
+#ifndef QT_MAC_USE_COCOA // This is handled inside the mouse handler on Cocoa.
+ Q_Q(QWidget);
+ if (!q->testAttribute(Qt::WA_WState_Created))
+ return;
+
+ if(q->isWindow())
+ {
+ if(q->testAttribute(Qt::WA_TransparentForMouseEvents))
+ ChangeWindowAttributes(qt_mac_window_for(q), kWindowIgnoreClicksAttribute, 0);
+ else
+ ChangeWindowAttributes(qt_mac_window_for(q), 0, kWindowIgnoreClicksAttribute);
+ ReshapeCustomWindow(qt_mac_window_for(q));
+ } else {
+#ifndef kHIViewFeatureIgnoresClicks
+#define kHIViewFeatureIgnoresClicks kHIViewIgnoresClicks
+#endif
+ if(q->testAttribute(Qt::WA_TransparentForMouseEvents))
+ HIViewChangeFeatures(qt_mac_nativeview_for(q), kHIViewFeatureIgnoresClicks, 0);
+ else
+ HIViewChangeFeatures(qt_mac_nativeview_for(q), 0, kHIViewFeatureIgnoresClicks);
+ HIViewReshapeStructure(qt_mac_nativeview_for(q));
+ }
+#endif
+}
+
+void QWidgetPrivate::macUpdateMetalAttribute()
+{
+ Q_Q(QWidget);
+ bool realWindow = isRealWindow();
+ if (!q->testAttribute(Qt::WA_WState_Created) || !realWindow)
+ return;
+
+ if (realWindow) {
+#if QT_MAC_USE_COCOA
+ // Cocoa doesn't let us change the style mask once it's been changed
+ // So, that means we need to recreate the window.
+ OSWindowRef cocoaWindow = qt_mac_window_for(q);
+ if ([cocoaWindow styleMask] & NSTexturedBackgroundWindowMask)
+ return;
+ recreateMacWindow();
+#else
+ QMainWindowLayout *layout = qobject_cast<QMainWindowLayout *>(q->layout());
+ if (q->testAttribute(Qt::WA_MacBrushedMetal)) {
+ if (layout)
+ layout->updateHIToolBarStatus();
+ ChangeWindowAttributes(qt_mac_window_for(q), kWindowMetalAttribute, 0);
+ ChangeWindowAttributes(qt_mac_window_for(q), kWindowMetalNoContentSeparatorAttribute, 0);
+ } else {
+ ChangeWindowAttributes(qt_mac_window_for(q), 0, kWindowMetalNoContentSeparatorAttribute);
+ ChangeWindowAttributes(qt_mac_window_for(q), 0, kWindowMetalAttribute);
+ if (layout)
+ layout->updateHIToolBarStatus();
+ }
+#endif
+ }
+}
+
+void QWidgetPrivate::setEnabled_helper_sys(bool enable)
+{
+#ifdef QT_MAC_USE_COCOA
+ Q_Q(QWidget);
+ NSView *view = qt_mac_nativeview_for(q);
+ if ([view isKindOfClass:[NSControl class]])
+ [static_cast<NSControl *>(view) setEnabled:enable];
+#else
+ Q_UNUSED(enable);
+#endif
+}
+
+QT_END_NAMESPACE