1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 /****************************************************************************

    43 **

    44 ** Copyright (c) 2007-2008, Apple, Inc.

    45 **

    46 ** All rights reserved.

    47 **

    48 ** Redistribution and use in source and binary forms, with or without

    49 ** modification, are permitted provided that the following conditions are met:

    50 **

    51 **   * Redistributions of source code must retain the above copyright notice,

    52 **     this list of conditions and the following disclaimer.

    53 **

    54 **   * Redistributions in binary form must reproduce the above copyright notice,

    55 **     this list of conditions and the following disclaimer in the documentation

    56 **     and/or other materials provided with the distribution.

    57 **

    58 **   * Neither the name of Apple, Inc. nor the names of its contributors

    59 **     may be used to endorse or promote products derived from this software

    60 **     without specific prior written permission.

    61 **

    62 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

    63 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

    64 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

    65 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

    66 ** CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    67 ** EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    68 ** PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    69 ** PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

    70 ** LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

    71 ** NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

    72 ** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    73 **

    74 ****************************************************************************/

    75 

    76 #include <private/qt_mac_p.h>

    77 #include <private/qeventdispatcher_mac_p.h>

    78 

    79 #include "qapplication.h"

    80 #include "qapplication_p.h"

    81 #include "qbitmap.h"

    82 #include "qcursor.h"

    83 #include "qdesktopwidget.h"

    84 #include "qevent.h"

    85 #include "qfileinfo.h"

    86 #include "qimage.h"

    87 #include "qlayout.h"

    88 #include "qmenubar.h"

    89 #include <private/qbackingstore_p.h>

    90 #include <private/qwindowsurface_mac_p.h>

    91 #include <private/qpaintengine_mac_p.h>

    92 #include "qpainter.h"

    93 #include "qstyle.h"

    94 #include "qtimer.h"

    95 #include "qfocusframe.h"

    96 #include "qdebug.h"

    97 #include <private/qmainwindowlayout_p.h>

    98 

    99 #include <private/qabstractscrollarea_p.h>

   100 #include <qabstractscrollarea.h>

   101 #include <ApplicationServices/ApplicationServices.h>

   102 #include <limits.h>

   103 #include <private/qt_cocoa_helpers_mac_p.h>

   104 #include <private/qcocoaview_mac_p.h>

   105 #include <private/qcocoawindow_mac_p.h>

   106 #include <private/qcocoawindowdelegate_mac_p.h>

   107 #include <private/qcocoapanel_mac_p.h>

   108 

   109 #include "qwidget_p.h"

   110 #include "qevent_p.h"

   111 #include "qdnd_p.h"

   112 #include <QtGui/qgraphicsproxywidget.h>

   113 

   114 QT_BEGIN_NAMESPACE

   115 

   116 #define XCOORD_MAX 16383

   117 #define WRECT_MAX 8191

   118 

   119 #ifndef QT_MAC_USE_COCOA

   120 

   121 extern "C" {

   122     extern OSStatus _HIViewScrollRectWithOptions(HIViewRef, const HIRect *, CGFloat, CGFloat,

   123                                                  OptionBits) __attribute__ ((weak));

   124 }

   125 #define kHIViewScrollRectAdjustInvalid 1

   126 #define kHIViewScrollRectDontInvalidateRevealedArea 2

   127 #endif

   128 

   129 

   130 /*****************************************************************************

   131   QWidget debug facilities

   132  *****************************************************************************/

   133 //#define DEBUG_WINDOW_RGNS

   134 //#define DEBUG_WINDOW_CREATE

   135 //#define DEBUG_WINDOW_STATE

   136 //#define DEBUG_WIDGET_PAINT

   137 

   138 /*****************************************************************************

   139   QWidget globals

   140  *****************************************************************************/

   141 #ifndef QT_MAC_USE_COCOA

   142 typedef QHash<Qt::WindowFlags, WindowGroupRef> WindowGroupHash;

   143 Q_GLOBAL_STATIC(WindowGroupHash, qt_mac_window_groups)

   144 const UInt32 kWidgetCreatorQt = kEventClassQt;

   145 enum {

   146     kWidgetPropertyQWidget = 'QWId' //QWidget *

   147 };

   148 #endif

   149 

   150 static bool qt_mac_raise_process = true;

   151 static OSWindowRef qt_root_win = 0;

   152 QWidget *mac_mouse_grabber = 0;

   153 QWidget *mac_keyboard_grabber = 0;

   154 

   155 #ifndef QT_MAC_USE_COCOA

   156 #ifdef QT_NAMESPACE

   157 

   158 // produce the string "com.trolltech.qt-namespace.widget", where "namespace" is the contents of QT_NAMESPACE.

   159 #define SS(x) #x

   160 #define S0(x) SS(x)

   161 #define S "com.trolltech.qt-" S0(QT_NAMESPACE) ".widget"

   162 

   163 static CFStringRef kObjectQWidget = CFSTR(S);

   164 

   165 #undef SS

   166 #undef S0

   167 #undef S

   168 

   169 #else

   170 static CFStringRef kObjectQWidget = CFSTR("com.trolltech.qt.widget");

   171 #endif // QT_NAMESPACE

   172 #endif // QT_MAC_USE_COCOA

   173 

   174 /*****************************************************************************

   175   Externals

   176  *****************************************************************************/

   177 extern QWidget *qt_mac_modal_blocked(QWidget *); //qapplication_mac.mm

   178 extern void qt_event_request_activate(QWidget *); //qapplication_mac.mm

   179 extern bool qt_event_remove_activate(); //qapplication_mac.mm

   180 extern void qt_mac_event_release(QWidget *w); //qapplication_mac.mm

   181 extern void qt_event_request_showsheet(QWidget *); //qapplication_mac.mm

   182 extern void qt_event_request_window_change(QWidget *); //qapplication_mac.mm

   183 extern QPointer<QWidget> qt_mouseover; //qapplication_mac.mm

   184 extern IconRef qt_mac_create_iconref(const QPixmap &); //qpixmap_mac.cpp

   185 extern void qt_mac_set_cursor(const QCursor *, const QPoint &); //qcursor_mac.mm

   186 extern void qt_mac_update_cursor(); //qcursor_mac.mm

   187 extern bool qt_nograb();

   188 extern CGImageRef qt_mac_create_cgimage(const QPixmap &, bool); //qpixmap_mac.cpp

   189 extern RgnHandle qt_mac_get_rgn(); //qregion_mac.cpp

   190 extern QRegion qt_mac_convert_mac_region(RgnHandle rgn); //qregion_mac.cpp

   191 

   192 /*****************************************************************************

   193   QWidget utility functions

   194  *****************************************************************************/

   195 void Q_GUI_EXPORT qt_mac_set_raise_process(bool b) { qt_mac_raise_process = b; }

   196 static QSize qt_mac_desktopSize()

   197 {

   198     int w = 0, h = 0;

   199     CGDisplayCount cg_count;

   200     CGGetActiveDisplayList(0, 0, &cg_count);

   201     QVector<CGDirectDisplayID> displays(cg_count);

   202     CGGetActiveDisplayList(cg_count, displays.data(), &cg_count);

   203     Q_ASSERT(cg_count == (CGDisplayCount)displays.size());

   204     for(int i = 0; i < (int)cg_count; ++i) {

   205         CGRect r = CGDisplayBounds(displays.at(i));

   206         w = qMax<int>(w, qRound(r.origin.x + r.size.width));

   207         h = qMax<int>(h, qRound(r.origin.y + r.size.height));

   208     }

   209     return QSize(w, h);

   210 }

   211 

   212 #ifdef QT_MAC_USE_COCOA

   213 static NSDrawer *qt_mac_drawer_for(const QWidget *widget)

   214 {

   215     // This only goes one level below the content view so start with the window.

   216     // This works fine for straight Qt stuff, but runs into problems if we are

   217     // embedding, but if that's the case, they probably want to be using

   218     // NSDrawer directly.

   219     NSView *widgetView = reinterpret_cast<NSView *>(widget->window()->winId());

   220     NSArray *windows = [NSApp windows];

   221     for (NSWindow *window in windows) {

   222         NSArray *drawers = [window drawers];

   223         for (NSDrawer *drawer in drawers) {

   224             NSArray *views = [[drawer contentView] subviews];

   225             for (NSView *view in views) {

   226                 if (view == widgetView)

   227                     return drawer;

   228             }

   229         }

   230     }

   231     return 0;

   232 }

   233 #endif

   234 

   235 static void qt_mac_destructView(OSViewRef view)

   236 {

   237 #ifdef QT_MAC_USE_COCOA

   238     [view removeFromSuperview];

   239     [view release];

   240 #else

   241     HIViewRemoveFromSuperview(view);

   242     CFRelease(view);

   243 #endif

   244 }

   245 

   246 static void qt_mac_destructWindow(OSWindowRef window)

   247 {

   248 #ifdef QT_MAC_USE_COCOA

   249     if ([window isVisible] && [window isSheet]){

   250         [NSApp endSheet:window];

   251         [window orderOut:window];

   252     }

   253 

   254     [[QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate] resignDelegateForWindow:window];

   255     [window release];

   256 #else

   257     // Remove property to clean up memory:

   258     RemoveWindowProperty(window, kWidgetCreatorQt, kWidgetPropertyQWidget);

   259     CFRelease(window);

   260 #endif

   261 }

   262 

   263 static void qt_mac_destructDrawer(NSDrawer *drawer)

   264 {

   265 #ifdef QT_MAC_USE_COCOA

   266     [[QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate] resignDelegateForDrawer:drawer];

   267     [drawer release];

   268 #else

   269     Q_UNUSED(drawer);

   270 #endif

   271 }

   272 

   273 bool qt_mac_can_clickThrough(const QWidget *w)

   274 {

   275     static int qt_mac_carbon_clickthrough = -1;

   276     if (qt_mac_carbon_clickthrough < 0)

   277         qt_mac_carbon_clickthrough = !qgetenv("QT_MAC_NO_COCOA_CLICKTHROUGH").isEmpty();

   278     bool ret = !qt_mac_carbon_clickthrough;

   279     for ( ; w; w = w->parentWidget()) {

   280         if (w->testAttribute(Qt::WA_MacNoClickThrough)) {

   281             ret = false;

   282             break;

   283         }

   284     }

   285     return ret;

   286 }

   287 

   288 bool qt_mac_is_macsheet(const QWidget *w)

   289 {

   290     if (!w)

   291         return false;

   292 

   293     Qt::WindowModality modality = w->windowModality();

   294     if (modality == Qt::ApplicationModal)

   295         return false;

   296     return w->parentWidget() && (modality == Qt::WindowModal || w->windowType() == Qt::Sheet);

   297 }

   298 

   299 bool qt_mac_is_macdrawer(const QWidget *w)

   300 {

   301     return (w && w->parentWidget() && w->windowType() == Qt::Drawer);

   302 }

   303 

   304 bool qt_mac_insideKeyWindow(const QWidget *w)

   305 {

   306 #ifdef QT_MAC_USE_COCOA

   307     return [[reinterpret_cast<NSView *>(w->winId()) window] isKeyWindow];

   308 #else

   309     Q_UNUSED(w);

   310 #endif

   311     return false;

   312 }

   313 

   314 bool qt_mac_set_drawer_preferred_edge(QWidget *w, Qt::DockWidgetArea where) //users of Qt for Mac OS X can use this..

   315 {

   316     if(!qt_mac_is_macdrawer(w))

   317         return false;

   318 

   319 #if QT_MAC_USE_COCOA

   320     NSDrawer *drawer = qt_mac_drawer_for(w);

   321     if (!drawer)

   322         return false;

   323 	NSRectEdge	edge;

   324     if (where & Qt::LeftDockWidgetArea)

   325         edge = NSMinXEdge;

   326     else if (where & Qt::RightDockWidgetArea)

   327         edge = NSMaxXEdge;

   328     else if (where & Qt::TopDockWidgetArea)

   329 		edge = NSMaxYEdge;

   330     else if (where & Qt::BottomDockWidgetArea)

   331         edge = NSMinYEdge;

   332     else

   333         return false;

   334 

   335     if (edge == [drawer preferredEdge]) //no-op

   336         return false;

   337 

   338     if (w->isVisible()) {

   339 	    [drawer close];

   340 	    [drawer openOnEdge:edge];

   341 	}

   342 	[drawer setPreferredEdge:edge];

   343 #else

   344     OSWindowRef window = qt_mac_window_for(w);

   345     OptionBits edge;

   346     if(where & Qt::LeftDockWidgetArea)

   347         edge = kWindowEdgeLeft;

   348     else if(where & Qt::RightDockWidgetArea)

   349         edge = kWindowEdgeRight;

   350     else if(where & Qt::TopDockWidgetArea)

   351         edge = kWindowEdgeTop;

   352     else if(where & Qt::BottomDockWidgetArea)

   353         edge = kWindowEdgeBottom;

   354     else

   355         return false;

   356 

   357     if(edge == GetDrawerPreferredEdge(window)) //no-op

   358         return false;

   359 

   360     //do it

   361     SetDrawerPreferredEdge(window, edge);

   362     if(w->isVisible()) {

   363         CloseDrawer(window, false);

   364         OpenDrawer(window, edge, true);

   365     }

   366 #endif

   367     return true;

   368 }

   369 

   370 #ifndef QT_MAC_USE_COCOA

   371 Q_GUI_EXPORT

   372 #endif

   373 QPoint qt_mac_posInWindow(const QWidget *w)

   374 {

   375     QPoint ret = w->data->wrect.topLeft();

   376     while(w && !w->isWindow()) {

   377         ret += w->pos();

   378         w =  w->parentWidget();

   379     }

   380     return ret;

   381 }

   382 

   383 //find a QWidget from a OSWindowRef

   384 QWidget *qt_mac_find_window(OSWindowRef window)

   385 {

   386 #ifdef QT_MAC_USE_COCOA

   387     return [window QT_MANGLE_NAMESPACE(qt_qwidget)];

   388 #else

   389     if(!window)

   390         return 0;

   391 

   392     QWidget *ret;

   393     if(GetWindowProperty(window, kWidgetCreatorQt, kWidgetPropertyQWidget, sizeof(ret), 0, &ret) == noErr)

   394         return ret;

   395     return 0;

   396 #endif

   397 }

   398 

   399 inline static void qt_mac_set_fullscreen_mode(bool b)

   400 {

   401     extern bool qt_mac_app_fullscreen; //qapplication_mac.mm

   402     if(qt_mac_app_fullscreen == b)

   403         return;

   404     qt_mac_app_fullscreen = b;

   405     if (b) {

   406         SetSystemUIMode(kUIModeAllSuppressed, 0);

   407     } else {

   408         SetSystemUIMode(kUIModeNormal, 0);

   409     }

   410 }

   411 

   412 Q_GUI_EXPORT OSViewRef qt_mac_nativeview_for(const QWidget *w)

   413 {

   414     return reinterpret_cast<OSViewRef>(w->data->winid);

   415 }

   416 

   417 Q_GUI_EXPORT OSViewRef qt_mac_get_contentview_for(OSWindowRef w)

   418 {

   419 #ifdef QT_MAC_USE_COCOA

   420     return [w contentView];

   421 #else

   422     HIViewRef contentView = 0;

   423     OSStatus err = GetRootControl(w, &contentView);  // Returns the window's content view (Apple QA1214)

   424     if (err == errUnknownControl) {

   425         contentView = HIViewGetRoot(w);

   426     } else if (err != noErr) {

   427         qWarning("Qt:Could not get content or root view of window! %s:%d [%ld]",

   428                  __FILE__, __LINE__, err);

   429     }

   430     return contentView;

   431 #endif

   432 }

   433 

   434 bool qt_mac_sendMacEventToWidget(QWidget *widget, EventRef ref)

   435 {

   436     return widget->macEvent(0, ref);

   437 }

   438 

   439 Q_GUI_EXPORT OSWindowRef qt_mac_window_for(OSViewRef view)

   440 {

   441 #ifdef QT_MAC_USE_COCOA

   442     if (view)

   443         return [view window];

   444     return 0;

   445 #else

   446     return HIViewGetWindow(view);

   447 #endif

   448 }

   449 

   450 static bool qt_isGenuineQWidget(OSViewRef ref)

   451 {

   452 #ifdef QT_MAC_USE_COCOA

   453     return [ref isKindOfClass:[QT_MANGLE_NAMESPACE(QCocoaView) class]];

   454 #else

   455     return HIObjectIsOfClass(HIObjectRef(ref), kObjectQWidget);

   456 #endif

   457 }

   458 

   459 bool qt_isGenuineQWidget(const QWidget *window)

   460 {

   461     return window && qt_isGenuineQWidget(OSViewRef(window->winId()));

   462 }

   463 

   464 Q_GUI_EXPORT OSWindowRef qt_mac_window_for(const QWidget *w)

   465 {

   466     OSViewRef hiview = qt_mac_nativeview_for(w);

   467     if (hiview){

   468         OSWindowRef window = qt_mac_window_for(hiview);

   469         if (!window && qt_isGenuineQWidget(hiview)) {

   470             QWidget *myWindow = w->window();

   471             // This is a workaround for NSToolbar. When a widget is hidden

   472             // by clicking the toolbar button, Cocoa reparents the widgets

   473             // to another window (but Qt doesn't know about it).

   474             // When we start showing them, it reparents back,

   475             // but at this point it's window is nil, but the window it's being brought

   476             // into (the Qt one) is for sure created.

   477             // This stops the hierarchy moving under our feet.

   478             if (myWindow != w && qt_mac_window_for(qt_mac_nativeview_for(myWindow)))

   479                 return qt_mac_window_for(qt_mac_nativeview_for(myWindow));

   480 

   481             myWindow->d_func()->createWindow_sys();

   482             // Reget the hiview since the "create window could potentially move the view (I guess).

   483             hiview = qt_mac_nativeview_for(w);

   484             window = qt_mac_window_for(hiview);

   485         }

   486         return window;

   487     }

   488     return 0;

   489 }

   490 #ifndef QT_MAC_USE_COCOA

   491 /*  Checks if the current group is a 'stay on top' group. If so, the

   492     group gets removed from the hash table */

   493 static void qt_mac_release_stays_on_top_group(WindowGroupRef group)

   494 {

   495     for (WindowGroupHash::iterator it = qt_mac_window_groups()->begin(); it != qt_mac_window_groups()->end(); ++it) {

   496         if (it.value() == group) {

   497             qt_mac_window_groups()->remove(it.key());

   498             return;

   499         }

   500     }

   501 }

   502 

   503 /* Use this function instead of ReleaseWindowGroup, this will be sure to release the

   504    stays on top window group (created with qt_mac_get_stays_on_top_group below) */

   505 static void qt_mac_release_window_group(WindowGroupRef group)

   506 {

   507     ReleaseWindowGroup(group);

   508     if (GetWindowGroupRetainCount(group) == 0)

   509         qt_mac_release_stays_on_top_group(group);

   510 }

   511 #define ReleaseWindowGroup(x) Are you sure you wanted to do that? (you wanted qt_mac_release_window_group)

   512 

   513 SInt32 qt_mac_get_group_level(WindowClass wclass)

   514 {

   515     SInt32 group_level;

   516     CGWindowLevel tmpLevel;

   517     GetWindowGroupLevelOfType(GetWindowGroupOfClass(wclass), kWindowGroupLevelActive, &tmpLevel);

   518     group_level = tmpLevel;

   519     return group_level;

   520 }

   521 #endif

   522 

   523 #ifndef QT_MAC_USE_COCOA

   524 static void qt_mac_set_window_group(OSWindowRef window, Qt::WindowFlags flags, int level)

   525 {

   526     WindowGroupRef group = 0;

   527     if (qt_mac_window_groups()->contains(flags)) {

   528         group = qt_mac_window_groups()->value(flags);

   529         RetainWindowGroup(group);

   530     } else {

   531         CreateWindowGroup(kWindowActivationScopeNone, &group);

   532         SetWindowGroupLevel(group, level);

   533         SetWindowGroupParent(group, GetWindowGroupOfClass(kAllWindowClasses));

   534         qt_mac_window_groups()->insert(flags, group);

   535     }

   536     SetWindowGroup(window, group);

   537 }

   538 

   539 inline static void qt_mac_set_window_group_to_stays_on_top(OSWindowRef window, Qt::WindowType type)

   540 {

   541     // We create one static stays on top window group so that

   542     // all stays on top (aka popups) will fall into the same

   543     // group and be able to be raise()'d with releation to one another (from

   544     // within the same window group).

   545     qt_mac_set_window_group(window, type|Qt::WindowStaysOnTopHint, qt_mac_get_group_level(kOverlayWindowClass));

   546 }

   547 

   548 inline static void qt_mac_set_window_group_to_tooltip(OSWindowRef window)

   549 {

   550     // Since new groups are created for 'stays on top' windows, the

   551     // same must be done for tooltips. Otherwise, tooltips would be drawn

   552     // below 'stays on top' widgets even tough they are on the same level.

   553     // Also, add 'two' to the group level to make sure they also get on top of popups.

   554     qt_mac_set_window_group(window, Qt::ToolTip, qt_mac_get_group_level(kHelpWindowClass)+2);

   555 }

   556 

   557 inline static void qt_mac_set_window_group_to_popup(OSWindowRef window)

   558 {

   559     // In Qt, a popup is seen as a 'stay on top' window.

   560     // Since new groups are created for 'stays on top' windows, the

   561     // same must be done for popups. Otherwise, popups would be drawn

   562     // below 'stays on top' windows. Add 1 to get above pure stay-on-top windows.

   563     qt_mac_set_window_group(window, Qt::Popup, qt_mac_get_group_level(kOverlayWindowClass)+1);

   564 }

   565 #endif

   566 

   567 inline static bool updateRedirectedToGraphicsProxyWidget(QWidget *widget, const QRect &rect)

   568 {

   569     if (!widget)

   570         return false;

   571 

   572 #ifndef QT_NO_GRAPHICSVIEW

   573     QWidget *tlw = widget->window();

   574     QWExtra *extra = qt_widget_private(tlw)->extra;

   575     if (extra && extra->proxyWidget) {

   576         extra->proxyWidget->update(rect.translated(widget->mapTo(tlw, QPoint())));

   577         return true;

   578     }

   579 #endif

   580 

   581     return false;

   582 }

   583 

   584 inline static bool updateRedirectedToGraphicsProxyWidget(QWidget *widget, const QRegion &rgn)

   585 {

   586     if (!widget)

   587         return false;

   588 

   589 #ifndef QT_NO_GRAPHICSVIEW

   590     QWidget *tlw = widget->window();

   591     QWExtra *extra = qt_widget_private(tlw)->extra;

   592     if (extra && extra->proxyWidget) {

   593         const QPoint offset(widget->mapTo(tlw, QPoint()));

   594         const QVector<QRect> rects = rgn.rects();

   595         for (int i = 0; i < rects.size(); ++i)

   596             extra->proxyWidget->update(rects.at(i).translated(offset));

   597         return true;

   598     }

   599 #endif

   600 

   601     return false;

   602 }

   603 

   604 void QWidgetPrivate::macUpdateIsOpaque()

   605 {

   606     Q_Q(QWidget);

   607     if (!q->testAttribute(Qt::WA_WState_Created))

   608         return;

   609 #ifndef QT_MAC_USE_COCOA

   610     HIViewFeatures bits;

   611     HIViewRef hiview = qt_mac_nativeview_for(q);

   612     HIViewGetFeatures(hiview, &bits);

   613     if ((bits & kHIViewIsOpaque) == isOpaque)

   614         return;

   615     if (isOpaque) {

   616         HIViewChangeFeatures(hiview, kHIViewIsOpaque, 0);

   617     } else {

   618         HIViewChangeFeatures(hiview, 0, kHIViewIsOpaque);

   619     }

   620     if (q->isVisible())

   621         HIViewReshapeStructure(qt_mac_nativeview_for(q));

   622 #else

   623     if (isRealWindow() && !q->testAttribute(Qt::WA_MacBrushedMetal)) {

   624         bool opaque = isOpaque;

   625         if (extra && extra->imageMask)

   626             opaque = false; // we are never opaque when we have a mask.

   627         [qt_mac_window_for(q) setOpaque:opaque];

   628     }

   629 #endif

   630 }

   631 #ifdef QT_MAC_USE_COCOA

   632 static OSWindowRef qt_mac_create_window(QWidget *widget, WindowClass wclass,

   633                                         NSUInteger wattr, const QRect &crect)

   634 {

   635     // Determine if we need to add in our "custom window" attribute. Cocoa is rather clever

   636     // in deciding if we need the maximize button or not (i.e., it's resizeable, so you

   637     // must need a maximize button). So, the only buttons we have control over are the

   638     // close and minimize buttons. If someone wants to customize and NOT have the maximize

   639     // button, then we have to do our hack. We only do it for these cases because otherwise

   640     // the window looks different when activated. This "QtMacCustomizeWindow" attribute is

   641     // intruding on a public space and WILL BREAK in the future.

   642     // One can hope that there is a more public API available by that time.

   643     Qt::WindowFlags flags = widget ? widget->windowFlags() : Qt::WindowFlags(0);

   644     if ((flags & Qt::CustomizeWindowHint)) {

   645         if ((flags & (Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint

   646                       | Qt::WindowMinimizeButtonHint | Qt::WindowTitleHint))

   647             && !(flags & Qt::WindowMaximizeButtonHint))

   648             wattr |= QtMacCustomizeWindow;

   649     }

   650 

   651     // If we haven't created the desktop widget, you have to pass the rectangle

   652     // in "cocoa coordinates" (i.e., top points to the lower left coordinate).

   653     // Otherwise, we do the conversion for you. Since we are the only ones that

   654     // create the desktop widget, this is OK (but confusing).

   655     NSRect geo = NSMakeRect(crect.left(),

   656                             (qt_root_win != 0) ? flipYCoordinate(crect.bottom() + 1) : crect.top(),

   657                             crect.width(), crect.height());

   658     QMacCocoaAutoReleasePool pool;

   659     OSWindowRef window;

   660     switch (wclass) {

   661     case kMovableModalWindowClass:

   662     case kModalWindowClass:

   663     case kSheetWindowClass:

   664     case kFloatingWindowClass:

   665     case kOverlayWindowClass:

   666     case kHelpWindowClass: {

   667         NSPanel *panel;

   668         BOOL needFloating = NO;

   669         BOOL worksWhenModal = widget && (widget->windowType() == Qt::Popup);

   670         // Add in the extra flags if necessary.

   671         switch (wclass) {

   672         case kSheetWindowClass:

   673             wattr |= NSDocModalWindowMask;

   674             break;

   675         case kFloatingWindowClass:

   676         case kHelpWindowClass:

   677             needFloating = YES;

   678             wattr |= NSUtilityWindowMask;

   679             break;

   680         default:

   681             break;

   682         }

   683         panel = [[QT_MANGLE_NAMESPACE(QCocoaPanel) alloc] QT_MANGLE_NAMESPACE(qt_initWithQWidget):widget contentRect:geo styleMask:wattr];

   684         [panel setFloatingPanel:needFloating];

   685         [panel setWorksWhenModal:worksWhenModal];

   686         window = panel;

   687         break;

   688     }

   689     case kDrawerWindowClass: {

   690         NSDrawer *drawer = [[NSDrawer alloc] initWithContentSize:geo.size preferredEdge:NSMinXEdge];

   691         [[QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate] becomeDelegateForDrawer:drawer widget:widget];

   692         QWidget *parentWidget = widget->parentWidget();

   693         if (parentWidget)

   694             [drawer setParentWindow:qt_mac_window_for(parentWidget)];

   695         [drawer setLeadingOffset:0.0];

   696         [drawer setTrailingOffset:25.0];

   697         window = [[drawer contentView] window];  // Just to make sure we actually return a window

   698         break;

   699     }

   700     default:

   701         window = [[QT_MANGLE_NAMESPACE(QCocoaWindow) alloc] QT_MANGLE_NAMESPACE(qt_initWithQWidget):widget contentRect:geo styleMask:wattr];

   702         break;

   703     }

   704     qt_syncCocoaTitleBarButtons(window, widget);

   705     return window;

   706 }

   707 #else

   708 static OSWindowRef qt_mac_create_window(QWidget *, WindowClass wclass, WindowAttributes wattr,

   709                                         const QRect &crect)

   710 {

   711     OSWindowRef window;

   712     Rect geo;

   713     SetRect(&geo, crect.left(), crect.top(), crect.right() + 1, crect.bottom() + 1);

   714     OSStatus err;

   715     if(geo.right <= geo.left)		geo.right = geo.left + 1;

   716     if(geo.bottom <= geo.top)		geo.bottom = geo.top + 1;

   717     Rect null_rect;

   718 	SetRect(&null_rect, 0, 0, 1, 1);

   719     err = CreateNewWindow(wclass, wattr, &null_rect, &window);

   720     if(err == noErr) {

   721         err = SetWindowBounds(window, kWindowContentRgn, &geo);

   722         if(err != noErr)

   723             qWarning("QWidget: Internal error (%s:%d)", __FILE__, __LINE__);

   724     }

   725     return window;

   726 }

   727 

   728 // window events

   729 static EventTypeSpec window_events[] = {

   730     { kEventClassWindow, kEventWindowClose },

   731     { kEventClassWindow, kEventWindowExpanded },

   732     { kEventClassWindow, kEventWindowHidden },

   733     { kEventClassWindow, kEventWindowZoomed },

   734     { kEventClassWindow, kEventWindowCollapsed },

   735     { kEventClassWindow, kEventWindowToolbarSwitchMode },

   736     { kEventClassWindow, kEventWindowProxyBeginDrag },

   737     { kEventClassWindow, kEventWindowProxyEndDrag },

   738     { kEventClassWindow, kEventWindowResizeCompleted },

   739     { kEventClassWindow, kEventWindowBoundsChanging },

   740     { kEventClassWindow, kEventWindowGetRegion },

   741     { kEventClassWindow, kEventWindowGetClickModality },

   742     { kEventClassWindow, kEventWindowTransitionCompleted },

   743 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6

   744     { kEventClassGesture, kEventGestureStarted },

   745     { kEventClassGesture, kEventGestureEnded },

   746     { kEventClassGesture, kEventGestureMagnify },

   747     { kEventClassGesture, kEventGestureSwipe },

   748     { kEventClassGesture, kEventGestureRotate },

   749 #endif

   750     { kEventClassMouse, kEventMouseDown }

   751 };

   752 static EventHandlerUPP mac_win_eventUPP = 0;

   753 static void cleanup_win_eventUPP()

   754 {

   755     DisposeEventHandlerUPP(mac_win_eventUPP);

   756     mac_win_eventUPP = 0;

   757 }

   758 static const EventHandlerUPP make_win_eventUPP()

   759 {

   760     if(mac_win_eventUPP)

   761         return mac_win_eventUPP;

   762     qAddPostRoutine(cleanup_win_eventUPP);

   763     return mac_win_eventUPP = NewEventHandlerUPP(QWidgetPrivate::qt_window_event);

   764 }

   765 OSStatus QWidgetPrivate::qt_window_event(EventHandlerCallRef er, EventRef event, void *)

   766 {

   767     QScopedLoopLevelCounter loopLevelCounter(qApp->d_func()->threadData);

   768     bool handled_event = true;

   769     UInt32 ekind = GetEventKind(event), eclass = GetEventClass(event);

   770     switch(eclass) {

   771     case kEventClassWindow: {

   772         WindowRef wid = 0;

   773         GetEventParameter(event, kEventParamDirectObject, typeWindowRef, 0,

   774                           sizeof(WindowRef), 0, &wid);

   775         QWidget *widget = qt_mac_find_window(wid);

   776         if(!widget) {

   777             handled_event = false;

   778         } else if(ekind == kEventWindowGetClickModality) {

   779             // Carbon will send us kEventWindowGetClickModality before every

   780             // mouse press / release event. By returning 'true', we tell Carbon

   781             // that we would like the event target to receive the mouse event even

   782             // if the target is modally shaddowed. In Qt, this makes sense when we

   783             // e.g. have a popup showing, as the popup will grab the event

   784             // and perhaps use it to close itself.

   785             // By also setting the current modal window back into the event, we

   786             // help Carbon determining which window is supposed to be raised.

   787             handled_event = qApp->activePopupWidget() ? true : false;

   788         } else if(ekind == kEventWindowClose) {

   789             widget->d_func()->close_helper(QWidgetPrivate::CloseWithSpontaneousEvent);

   790             QMenuBar::macUpdateMenuBar();

   791         } else if (ekind == kEventWindowTransitionCompleted) {

   792             WindowTransitionAction transitionAction;

   793             GetEventParameter(event, kEventParamWindowTransitionAction, typeWindowTransitionAction,

   794                               0, sizeof(transitionAction), 0, &transitionAction);

   795             if (transitionAction == kWindowHideTransitionAction)

   796                 widget->hide();

   797         } else if(ekind == kEventWindowExpanded) {

   798             Qt::WindowStates currState = Qt::WindowStates(widget->data->window_state);

   799             Qt::WindowStates newState = currState;

   800             if (currState & Qt::WindowMinimized)

   801                 newState &= ~Qt::WindowMinimized;

   802             if (!(currState & Qt::WindowActive))

   803                 newState |= Qt::WindowActive;

   804             if (newState != currState) {

   805                 // newState will differ from currState if the window

   806                 // was expanded after clicking on the jewels (as opposed

   807                 // to calling QWidget::setWindowState)

   808                 widget->data->window_state = newState;

   809                 QWindowStateChangeEvent e(currState);

   810                 QApplication::sendSpontaneousEvent(widget, &e);

   811             }

   812 

   813             QShowEvent qse;

   814             QApplication::sendSpontaneousEvent(widget, &qse);

   815         } else if(ekind == kEventWindowZoomed) {

   816             WindowPartCode windowPart;

   817             GetEventParameter(event, kEventParamWindowPartCode,

   818                               typeWindowPartCode, 0, sizeof(windowPart), 0, &windowPart);

   819             if(windowPart == inZoomIn && widget->isMaximized()) {

   820 

   821                 widget->data->window_state = widget->data->window_state & ~Qt::WindowMaximized;

   822                 QWindowStateChangeEvent e(Qt::WindowStates(widget->data->window_state | Qt::WindowMaximized));

   823                 QApplication::sendSpontaneousEvent(widget, &e);

   824             } else if(windowPart == inZoomOut && !widget->isMaximized()) {

   825                 widget->data->window_state = widget->data->window_state | Qt::WindowMaximized;

   826                 QWindowStateChangeEvent e(Qt::WindowStates(widget->data->window_state

   827                                                            & ~Qt::WindowMaximized));

   828                 QApplication::sendSpontaneousEvent(widget, &e);

   829             }

   830             extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp

   831             qt_button_down = 0;

   832         } else if(ekind == kEventWindowCollapsed) {

   833             if (!widget->isMinimized()) {

   834                 widget->data->window_state = widget->data->window_state | Qt::WindowMinimized;

   835                 QWindowStateChangeEvent e(Qt::WindowStates(widget->data->window_state & ~Qt::WindowMinimized));

   836                 QApplication::sendSpontaneousEvent(widget, &e);

   837             }

   838 

   839             // Deactivate this window:

   840             if (widget->isActiveWindow() && !(widget->windowType() == Qt::Popup)) {

   841                 QWidget *w = 0;

   842                 if (widget->parentWidget())

   843                     w = widget->parentWidget()->window();

   844                 if (!w || (!w->isVisible() && !w->isMinimized())) {

   845                     for (WindowPtr wp = GetFrontWindowOfClass(kDocumentWindowClass, true);

   846                         wp; wp = GetNextWindowOfClass(wp, kDocumentWindowClass, true)) {

   847                         if ((w = qt_mac_find_window(wp)))

   848                             break;

   849                     }

   850                 }

   851                 if(!(w && w->isVisible() && !w->isMinimized()))

   852                     qApp->setActiveWindow(0);

   853             }

   854 

   855             //we send a hide to be like X11/Windows

   856             QEvent e(QEvent::Hide);

   857             QApplication::sendSpontaneousEvent(widget, &e);

   858             extern QPointer<QWidget> qt_button_down; //qapplication_mac.cpp

   859             qt_button_down = 0;

   860         } else if(ekind == kEventWindowToolbarSwitchMode) {

   861             macSendToolbarChangeEvent(widget);

   862             HIToolbarRef toolbar;

   863             if (GetWindowToolbar(wid, &toolbar) == noErr) {

   864                 if (toolbar) {

   865                     // Let HIToolbar do its thang, but things like the OpenGL context

   866                     // needs to know about it.

   867                     CallNextEventHandler(er, event);

   868                     qt_event_request_window_change(widget);

   869                     widget->data->fstrut_dirty = true;

   870                 }

   871             }

   872         } else if(ekind == kEventWindowGetRegion) {

   873             WindowRef window;

   874             GetEventParameter(event, kEventParamDirectObject, typeWindowRef, 0,

   875                               sizeof(window), 0, &window);

   876             WindowRegionCode wcode;

   877             GetEventParameter(event, kEventParamWindowRegionCode, typeWindowRegionCode, 0,

   878                               sizeof(wcode), 0, &wcode);

   879             if (wcode != kWindowOpaqueRgn){

   880                 // If the region is kWindowOpaqueRgn, don't call next

   881                 // event handler cause this will make the shadow of

   882                 // masked windows become offset. Unfortunately, we're not sure why.

   883                 CallNextEventHandler(er, event);

   884             }

   885 			RgnHandle rgn;

   886             GetEventParameter(event, kEventParamRgnHandle, typeQDRgnHandle, 0,

   887                               sizeof(rgn), 0, &rgn);

   888 

   889             if(QWidgetPrivate::qt_widget_rgn(qt_mac_find_window(window), wcode, rgn, false))

   890                 SetEventParameter(event, kEventParamRgnHandle, typeQDRgnHandle, sizeof(rgn), &rgn);

   891         } else if(ekind == kEventWindowProxyBeginDrag) {

   892             QIconDragEvent e;

   893             QApplication::sendSpontaneousEvent(widget, &e);

   894         } else if(ekind == kEventWindowResizeCompleted) {

   895             // Create a mouse up event, since such an event is not send by carbon to the

   896             // application event handler (while a mouse down <b>is</b> on kEventWindowResizeStarted)

   897             EventRef mouseUpEvent;

   898             CreateEvent(0, kEventClassMouse, kEventMouseUp, 0, kEventAttributeUserEvent, &mouseUpEvent);

   899             UInt16 mbutton = kEventMouseButtonPrimary;

   900             SetEventParameter(mouseUpEvent, kEventParamMouseButton, typeMouseButton, sizeof(mbutton), &mbutton);

   901             WindowRef window;

   902             GetEventParameter(event, kEventParamDirectObject, typeWindowRef, 0, sizeof(window), 0, &window);

   903             Rect dragRect;

   904             GetWindowBounds(window, kWindowGrowRgn, &dragRect);

   905             Point pos = {dragRect.bottom, dragRect.right};

   906             SetEventParameter(mouseUpEvent, kEventParamMouseLocation, typeQDPoint, sizeof(pos), &pos);

   907             SendEventToApplication(mouseUpEvent);

   908             ReleaseEvent(mouseUpEvent);

   909         } else if(ekind == kEventWindowBoundsChanging) {

   910             UInt32 flags = 0;

   911             GetEventParameter(event, kEventParamAttributes, typeUInt32, 0,

   912                                   sizeof(flags), 0, &flags);

   913             Rect nr;

   914             GetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, 0,

   915                                   sizeof(nr), 0, &nr);

   916 

   917             QRect newRect(nr.left, nr.top, nr.right - nr.left, nr.bottom - nr.top);

   918 

   919             QTLWExtra * const tlwExtra = widget->d_func()->maybeTopData();

   920             if (tlwExtra && tlwExtra->isSetGeometry == 1) {

   921                 widget->d_func()->setGeometry_sys_helper(newRect.left(), newRect.top(), newRect.width(), newRect.height(), tlwExtra->isMove);

   922             } else {

   923                 //implicitly removes the maximized bit

   924                 if((widget->data->window_state & Qt::WindowMaximized) &&

   925                    IsWindowInStandardState(wid, 0, 0)) {

   926                     widget->data->window_state &= ~Qt::WindowMaximized;

   927                     QWindowStateChangeEvent e(Qt::WindowStates(widget->data->window_state

   928                                                 | Qt::WindowMaximized));

   929                     QApplication::sendSpontaneousEvent(widget, &e);

   930 

   931                 }

   932 

   933                 handled_event = false;

   934                 const QRect oldRect = widget->data->crect;

   935                 if((flags & kWindowBoundsChangeOriginChanged)) {

   936                     if(nr.left != oldRect.x() || nr.top != oldRect.y()) {

   937                         widget->data->crect.moveTo(nr.left, nr.top);

   938                         QMoveEvent qme(widget->data->crect.topLeft(), oldRect.topLeft());

   939                         QApplication::sendSpontaneousEvent(widget, &qme);

   940                     }

   941                 }

   942                 if((flags & kWindowBoundsChangeSizeChanged)) {

   943                     if (widget->isWindow()) {

   944                         QSize newSize = QLayout::closestAcceptableSize(widget, newRect.size());

   945                         int dh = newSize.height() - newRect.height();

   946                         int dw = newSize.width() - newRect.width();

   947                         if (dw != 0 || dh != 0) {

   948                             handled_event = true;  // We want to change the bounds, so we handle the event

   949 

   950                             // set the rect, so we can also do the resize down below (yes, we need to resize).

   951                             newRect.setBottom(newRect.bottom() + dh);

   952                             newRect.setRight(newRect.right() + dw);

   953 

   954                             nr.left = newRect.x();

   955                             nr.top = newRect.y();

   956                             nr.right = nr.left + newRect.width();

   957                             nr.bottom = nr.top + newRect.height();

   958                             SetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, sizeof(Rect), &nr);

   959                         }

   960                     }

   961 

   962                     if (oldRect.width() != newRect.width() || oldRect.height() != newRect.height()) {

   963                         widget->data->crect.setSize(newRect.size());

   964                         HIRect bounds = CGRectMake(0, 0, newRect.width(), newRect.height());

   965 

   966                         // If the WA_StaticContents attribute is set we can optimize the resize

   967                         // by only repainting the newly exposed area. We do this by disabling

   968                         // painting when setting the size of the view. The OS will invalidate

   969                         // the newly exposed area for us.

   970                         const bool staticContents = widget->testAttribute(Qt::WA_StaticContents);

   971                         const HIViewRef view = qt_mac_nativeview_for(widget);

   972                         if (staticContents)

   973                             HIViewSetDrawingEnabled(view, false);

   974                         HIViewSetFrame(view, &bounds);

   975                         if (staticContents)

   976                             HIViewSetDrawingEnabled(view, true);

   977 

   978                         QResizeEvent qre(newRect.size(), oldRect.size());

   979                         QApplication::sendSpontaneousEvent(widget, &qre);

   980                         qt_event_request_window_change(widget);

   981                     }

   982                 }

   983             }

   984         } else if (ekind == kEventWindowHidden) {

   985             // Make sure that we also hide any visible sheets on our window.

   986             // Cocoa does the right thing for us.

   987             const QObjectList children = widget->children();

   988             const int childCount = children.count();

   989             for (int i = 0; i < childCount; ++i) {

   990                 QObject *obj = children.at(i);

   991                 if (obj->isWidgetType()) {

   992                     QWidget *widget = static_cast<QWidget *>(obj);

   993                     if (qt_mac_is_macsheet(widget) && widget->isVisible())

   994                         widget->hide();

   995                 }

   996             }

   997         } else {

   998             handled_event = false;

   999         }

  1000         break; }

  1001     case kEventClassMouse: {

  1002 #if 0

  1003         return SendEventToApplication(event);

  1004 #endif

  1005 

  1006         bool send_to_app = false;

  1007         {

  1008             WindowPartCode wpc;

  1009             if (GetEventParameter(event, kEventParamWindowPartCode, typeWindowPartCode, 0,

  1010                                   sizeof(wpc), 0, &wpc) == noErr && wpc != inContent)

  1011                 send_to_app = true;

  1012         }

  1013         if(!send_to_app) {

  1014             WindowRef window;

  1015             if(GetEventParameter(event, kEventParamWindowRef, typeWindowRef, 0,

  1016                                  sizeof(window), 0, &window) == noErr) {

  1017                 HIViewRef hiview;

  1018                 if(HIViewGetViewForMouseEvent(HIViewGetRoot(window), event, &hiview) == noErr) {

  1019                     if(QWidget *w = QWidget::find((WId)hiview)) {

  1020 #if 0

  1021                         send_to_app = !w->isActiveWindow();

  1022 #else

  1023                         Q_UNUSED(w);

  1024                         send_to_app = true;

  1025 #endif

  1026                     }

  1027                 }

  1028             }

  1029         }

  1030         if(send_to_app)

  1031             return SendEventToApplication(event);

  1032         handled_event = false;

  1033         break; }

  1034 

  1035 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6

  1036     case kEventClassGesture: {

  1037         // First, find the widget that was under

  1038         // the mouse when the gesture happened:

  1039         HIPoint screenLocation;

  1040         if (GetEventParameter(event, kEventParamMouseLocation, typeHIPoint, 0,

  1041                     sizeof(screenLocation), 0, &screenLocation) != noErr) {

  1042             handled_event = false;

  1043             break;

  1044         }

  1045         QWidget *widget = QApplication::widgetAt(screenLocation.x, screenLocation.y);

  1046         if (!widget) {

  1047             handled_event = false;

  1048             break;

  1049         }

  1050 

  1051         QNativeGestureEvent qNGEvent;

  1052         qNGEvent.position = QPoint(screenLocation.x, screenLocation.y);

  1053 

  1054         switch (ekind) {

  1055             case kEventGestureStarted:

  1056                 qNGEvent.gestureType = QNativeGestureEvent::GestureBegin;

  1057                 break;

  1058             case kEventGestureEnded:

  1059                 qNGEvent.gestureType = QNativeGestureEvent::GestureEnd;

  1060                 break;

  1061             case kEventGestureRotate: {

  1062                 CGFloat amount;

  1063                 if (GetEventParameter(event, kEventParamRotationAmount, typeCGFloat, 0,

  1064                             sizeof(amount), 0, &amount) != noErr) {

  1065                     handled_event = false;

  1066                     break;

  1067                 }

  1068                 qNGEvent.gestureType = QNativeGestureEvent::Rotate;

  1069                 qNGEvent.percentage = float(-amount);

  1070                 break; }

  1071             case kEventGestureSwipe: {

  1072                 HIPoint swipeDirection;

  1073                 if (GetEventParameter(event, kEventParamSwipeDirection, typeHIPoint, 0,

  1074                             sizeof(swipeDirection), 0, &swipeDirection) != noErr) {

  1075                     handled_event = false;

  1076                     break;

  1077                 }

  1078                 qNGEvent.gestureType = QNativeGestureEvent::Swipe;

  1079                 if (swipeDirection.x == 1)

  1080                     qNGEvent.angle = 180.0f;

  1081                 else if (swipeDirection.x == -1)

  1082                     qNGEvent.angle = 0.0f;

  1083                 else if (swipeDirection.y == 1)

  1084                     qNGEvent.angle = 90.0f;

  1085                 else if (swipeDirection.y == -1)

  1086                     qNGEvent.angle = 270.0f;

  1087                 break; }

  1088             case kEventGestureMagnify: {

  1089                 CGFloat amount;

  1090                 if (GetEventParameter(event, kEventParamMagnificationAmount, typeCGFloat, 0,

  1091                             sizeof(amount), 0, &amount) != noErr) {

  1092                     handled_event = false;

  1093                     break;

  1094                 }

  1095                 qNGEvent.gestureType = QNativeGestureEvent::Zoom;

  1096                 qNGEvent.percentage = float(amount);

  1097                 break; }

  1098         }

  1099 

  1100         QApplication::sendSpontaneousEvent(widget, &qNGEvent);

  1101     break; }

  1102 #endif // gestures

  1103 

  1104     default:

  1105         handled_event = false;

  1106     }

  1107     if(!handled_event) //let the event go through

  1108         return eventNotHandledErr;

  1109     return noErr; //we eat the event

  1110 }

  1111 

  1112 // widget events

  1113 static HIObjectClassRef widget_class = 0;

  1114 static EventTypeSpec widget_events[] = {

  1115     { kEventClassHIObject, kEventHIObjectConstruct },

  1116     { kEventClassHIObject, kEventHIObjectDestruct },

  1117 

  1118     { kEventClassControl, kEventControlDraw },

  1119     { kEventClassControl, kEventControlInitialize },

  1120     { kEventClassControl, kEventControlGetPartRegion },

  1121     { kEventClassControl, kEventControlGetClickActivation },

  1122     { kEventClassControl, kEventControlSetFocusPart },

  1123     { kEventClassControl, kEventControlDragEnter },

  1124     { kEventClassControl, kEventControlDragWithin },

  1125     { kEventClassControl, kEventControlDragLeave },

  1126     { kEventClassControl, kEventControlDragReceive },

  1127     { kEventClassControl, kEventControlOwningWindowChanged },

  1128     { kEventClassControl, kEventControlBoundsChanged },

  1129     { kEventClassControl, kEventControlGetSizeConstraints },

  1130     { kEventClassControl, kEventControlVisibilityChanged },

  1131 

  1132     { kEventClassMouse, kEventMouseDown },

  1133     { kEventClassMouse, kEventMouseUp },

  1134     { kEventClassMouse, kEventMouseMoved },