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

     2 **

     3 ** Copyright (C) 2010 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 #include "qmainwindow.h"

   114 

   115 QT_BEGIN_NAMESPACE

   116 

   117 #define XCOORD_MAX 16383

   118 #define WRECT_MAX 8191

   119 

   120 #ifndef QT_MAC_USE_COCOA

   121 

   122 extern "C" {

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

   124                                                  OptionBits) __attribute__ ((weak));

   125 }

   126 #define kHIViewScrollRectAdjustInvalid 1

   127 #define kHIViewScrollRectDontInvalidateRevealedArea 2

   128 #endif

   129 

   130 

   131 /*****************************************************************************

   132   QWidget debug facilities

   133  *****************************************************************************/

   134 //#define DEBUG_WINDOW_RGNS

   135 //#define DEBUG_WINDOW_CREATE

   136 //#define DEBUG_WINDOW_STATE

   137 //#define DEBUG_WIDGET_PAINT

   138 

   139 /*****************************************************************************

   140   QWidget globals

   141  *****************************************************************************/

   142 #ifndef QT_MAC_USE_COCOA

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

   144 Q_GLOBAL_STATIC(WindowGroupHash, qt_mac_window_groups)

   145 const UInt32 kWidgetCreatorQt = kEventClassQt;

   146 enum {

   147     kWidgetPropertyQWidget = 'QWId' //QWidget *

   148 };

   149 #endif

   150 

   151 static bool qt_mac_raise_process = true;

   152 static OSWindowRef qt_root_win = 0;

   153 QWidget *mac_mouse_grabber = 0;

   154 QWidget *mac_keyboard_grabber = 0;

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

   156 

   157 #ifndef QT_MAC_USE_COCOA

   158 #ifdef QT_NAMESPACE

   159 

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

   161 #define SS(x) #x

   162 #define S0(x) SS(x)

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

   164 

   165 static CFStringRef kObjectQWidget = CFSTR(S);

   166 

   167 #undef SS

   168 #undef S0

   169 #undef S

   170 

   171 #else

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

   173 #endif // QT_NAMESPACE

   174 #endif // QT_MAC_USE_COCOA

   175 

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

   177   Externals

   178  *****************************************************************************/

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

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

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

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

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

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

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

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

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

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

   189 extern bool qt_nograb();

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

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

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

   193 

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

   195   QWidget utility functions

   196  *****************************************************************************/

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

   198 static QSize qt_mac_desktopSize()

   199 {

   200     int w = 0, h = 0;

   201     CGDisplayCount cg_count;

   202     CGGetActiveDisplayList(0, 0, &cg_count);

   203     QVector<CGDirectDisplayID> displays(cg_count);

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

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

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

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

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

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

   210     }

   211     return QSize(w, h);

   212 }

   213 

   214 #ifdef QT_MAC_USE_COCOA

   215 static NSDrawer *qt_mac_drawer_for(const QWidget *widget)

   216 {

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

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

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

   220     // NSDrawer directly.

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

   222     NSArray *windows = [NSApp windows];

   223     for (NSWindow *window in windows) {

   224         NSArray *drawers = [window drawers];

   225         for (NSDrawer *drawer in drawers) {

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

   227             for (NSView *view in views) {

   228                 if (view == widgetView)

   229                     return drawer;

   230             }

   231         }

   232     }

   233     return 0;

   234 }

   235 #endif

   236 

   237 static void qt_mac_destructView(OSViewRef view)

   238 {

   239 #ifdef QT_MAC_USE_COCOA

   240     [view removeFromSuperview];

   241     [view release];

   242 #else

   243     HIViewRemoveFromSuperview(view);

   244     CFRelease(view);

   245 #endif

   246 }

   247 

   248 static void qt_mac_destructWindow(OSWindowRef window)

   249 {

   250 #ifdef QT_MAC_USE_COCOA

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

   252         [NSApp endSheet:window];

   253         [window orderOut:window];

   254     }

   255 

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

   257     [window release];

   258 #else

   259     // Remove property to clean up memory:

   260     RemoveWindowProperty(window, kWidgetCreatorQt, kWidgetPropertyQWidget);

   261     CFRelease(window);

   262 #endif

   263 }

   264 

   265 static void qt_mac_destructDrawer(NSDrawer *drawer)

   266 {

   267 #ifdef QT_MAC_USE_COCOA

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

   269     [drawer release];

   270 #else

   271     Q_UNUSED(drawer);

   272 #endif

   273 }

   274 

   275 bool qt_mac_can_clickThrough(const QWidget *w)

   276 {

   277     static int qt_mac_carbon_clickthrough = -1;

   278     if (qt_mac_carbon_clickthrough < 0)

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

   280     bool ret = !qt_mac_carbon_clickthrough;

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

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

   283             ret = false;

   284             break;

   285         }

   286     }

   287     return ret;

   288 }

   289 

   290 bool qt_mac_is_macsheet(const QWidget *w)

   291 {

   292     if (!w)

   293         return false;

   294 

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

   296     if (modality == Qt::ApplicationModal)

   297         return false;

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

   299 }

   300 

   301 bool qt_mac_is_macdrawer(const QWidget *w)

   302 {

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

   304 }

   305 

   306 bool qt_mac_insideKeyWindow(const QWidget *w)

   307 {

   308 #ifdef QT_MAC_USE_COCOA

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

   310 #else

   311     Q_UNUSED(w);

   312 #endif

   313     return false;

   314 }

   315 

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

   317 {

   318     if(!qt_mac_is_macdrawer(w))

   319         return false;

   320 

   321 #if QT_MAC_USE_COCOA

   322     NSDrawer *drawer = qt_mac_drawer_for(w);

   323     if (!drawer)

   324         return false;

   325 	NSRectEdge	edge;

   326     if (where & Qt::LeftDockWidgetArea)

   327         edge = NSMinXEdge;

   328     else if (where & Qt::RightDockWidgetArea)

   329         edge = NSMaxXEdge;

   330     else if (where & Qt::TopDockWidgetArea)

   331 		edge = NSMaxYEdge;

   332     else if (where & Qt::BottomDockWidgetArea)

   333         edge = NSMinYEdge;

   334     else

   335         return false;

   336 

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

   338         return false;

   339 

   340     if (w->isVisible()) {

   341 	    [drawer close];

   342 	    [drawer openOnEdge:edge];

   343 	}

   344 	[drawer setPreferredEdge:edge];

   345 #else

   346     OSWindowRef window = qt_mac_window_for(w);

   347     OptionBits edge;

   348     if(where & Qt::LeftDockWidgetArea)

   349         edge = kWindowEdgeLeft;

   350     else if(where & Qt::RightDockWidgetArea)

   351         edge = kWindowEdgeRight;

   352     else if(where & Qt::TopDockWidgetArea)

   353         edge = kWindowEdgeTop;

   354     else if(where & Qt::BottomDockWidgetArea)

   355         edge = kWindowEdgeBottom;

   356     else

   357         return false;

   358 

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

   360         return false;

   361 

   362     //do it

   363     SetDrawerPreferredEdge(window, edge);

   364     if(w->isVisible()) {

   365         CloseDrawer(window, false);

   366         OpenDrawer(window, edge, true);

   367     }

   368 #endif

   369     return true;

   370 }

   371 

   372 #ifndef QT_MAC_USE_COCOA

   373 Q_GUI_EXPORT

   374 #endif

   375 QPoint qt_mac_posInWindow(const QWidget *w)

   376 {

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

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

   379         ret += w->pos();

   380         w =  w->parentWidget();

   381     }

   382     return ret;

   383 }

   384 

   385 //find a QWidget from a OSWindowRef

   386 QWidget *qt_mac_find_window(OSWindowRef window)

   387 {

   388 #ifdef QT_MAC_USE_COCOA

   389     return [window QT_MANGLE_NAMESPACE(qt_qwidget)];

   390 #else

   391     if(!window)

   392         return 0;

   393 

   394     QWidget *ret;

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

   396         return ret;

   397     return 0;

   398 #endif

   399 }

   400 

   401 inline static void qt_mac_set_fullscreen_mode(bool b)

   402 {

   403     extern bool qt_mac_app_fullscreen; //qapplication_mac.mm

   404     if(qt_mac_app_fullscreen == b)

   405         return;

   406     qt_mac_app_fullscreen = b;

   407     if (b) {

   408         SetSystemUIMode(kUIModeAllHidden, kUIOptionAutoShowMenuBar);

   409     } else {

   410         SetSystemUIMode(kUIModeNormal, 0);

   411     }

   412 }

   413 

   414 Q_GUI_EXPORT OSViewRef qt_mac_nativeview_for(const QWidget *w)

   415 {

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

   417 }

   418 

   419 Q_GUI_EXPORT OSViewRef qt_mac_get_contentview_for(OSWindowRef w)

   420 {

   421 #ifdef QT_MAC_USE_COCOA

   422     return [w contentView];

   423 #else

   424     HIViewRef contentView = 0;

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

   426     if (err == errUnknownControl) {

   427         contentView = HIViewGetRoot(w);

   428     } else if (err != noErr) {

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

   430                  __FILE__, __LINE__, err);

   431     }

   432     return contentView;

   433 #endif

   434 }

   435 

   436 bool qt_mac_sendMacEventToWidget(QWidget *widget, EventRef ref)

   437 {

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

   439 }

   440 

   441 Q_GUI_EXPORT OSWindowRef qt_mac_window_for(OSViewRef view)

   442 {

   443 #ifdef QT_MAC_USE_COCOA

   444     if (view)

   445         return [view window];

   446     return 0;

   447 #else

   448     return HIViewGetWindow(view);

   449 #endif

   450 }

   451 

   452 static bool qt_isGenuineQWidget(OSViewRef ref)

   453 {

   454 #ifdef QT_MAC_USE_COCOA

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

   456 #else

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

   458 #endif

   459 }

   460 

   461 bool qt_isGenuineQWidget(const QWidget *window)

   462 {

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

   464 }

   465 

   466 Q_GUI_EXPORT OSWindowRef qt_mac_window_for(const QWidget *w)

   467 {

   468     OSViewRef hiview = qt_mac_nativeview_for(w);

   469     if (hiview){

   470         OSWindowRef window = qt_mac_window_for(hiview);

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

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

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

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

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

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

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

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

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

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

   481                 return qt_mac_window_for(qt_mac_nativeview_for(myWindow));

   482 

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

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

   485             hiview = qt_mac_nativeview_for(w);

   486             window = qt_mac_window_for(hiview);

   487         }

   488         return window;

   489     }

   490     return 0;

   491 }

   492 #ifndef QT_MAC_USE_COCOA

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

   494     group gets removed from the hash table */

   495 static void qt_mac_release_stays_on_top_group(WindowGroupRef group)

   496 {

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

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

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

   500             return;

   501         }

   502     }

   503 }

   504 

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

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

   507 static void qt_mac_release_window_group(WindowGroupRef group)

   508 {

   509     ReleaseWindowGroup(group);

   510     if (GetWindowGroupRetainCount(group) == 0)

   511         qt_mac_release_stays_on_top_group(group);

   512 }

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

   514 

   515 SInt32 qt_mac_get_group_level(WindowClass wclass)

   516 {

   517     SInt32 group_level;

   518     CGWindowLevel tmpLevel;

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

   520     group_level = tmpLevel;

   521     return group_level;

   522 }

   523 #endif

   524 

   525 #ifndef QT_MAC_USE_COCOA

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

   527 {

   528     WindowGroupRef group = 0;

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

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

   531         RetainWindowGroup(group);

   532     } else {

   533         CreateWindowGroup(kWindowActivationScopeNone, &group);

   534         SetWindowGroupLevel(group, level);

   535         SetWindowGroupParent(group, GetWindowGroupOfClass(kAllWindowClasses));

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

   537     }

   538     SetWindowGroup(window, group);

   539 }

   540 

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

   542 {

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

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

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

   546     // within the same window group).

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

   548 }

   549 

   550 inline static void qt_mac_set_window_group_to_tooltip(OSWindowRef window)

   551 {

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

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

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

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

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

   557 }

   558 

   559 inline static void qt_mac_set_window_group_to_popup(OSWindowRef window)

   560 {

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

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

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

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

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

   566 }

   567 #endif

   568 

   569 #ifdef QT_MAC_USE_COCOA

   570 void qt_mac_set_needs_display(QWidget *widget, QRegion region)

   571 {

   572     NSView *theNSView = qt_mac_nativeview_for(widget);

   573     if (region.isEmpty()) {

   574         [theNSView setNeedsDisplay:YES];

   575         return;

   576     }

   577 

   578     QVector<QRect> rects = region.rects();

   579     for (int i = 0; i<rects.count(); ++i) {

   580         const QRect &rect = rects.at(i);

   581         NSRect nsrect = NSMakeRect(rect.x(), rect.y(), rect.width(), rect.height());

   582         [theNSView setNeedsDisplayInRect:nsrect];

   583     }

   584 

   585 }

   586 #endif

   587 

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

   589 {

   590     if (!widget)

   591         return false;

   592 

   593 #ifndef QT_NO_GRAPHICSVIEW

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

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

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

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

   598         return true;

   599     }

   600 #endif

   601 

   602     return false;

   603 }

   604 

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

   606 {

   607     if (!widget)

   608         return false;

   609 

   610 #ifndef QT_NO_GRAPHICSVIEW

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

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

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

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

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

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

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

   618         return true;

   619     }

   620 #endif

   621 

   622     return false;

   623 }

   624 

   625 void QWidgetPrivate::macUpdateIsOpaque()

   626 {

   627     Q_Q(QWidget);

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

   629         return;

   630 #ifndef QT_MAC_USE_COCOA

   631     HIViewFeatures bits;

   632     HIViewRef hiview = qt_mac_nativeview_for(q);

   633     HIViewGetFeatures(hiview, &bits);

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

   635         return;

   636     if (isOpaque) {

   637         HIViewChangeFeatures(hiview, kHIViewIsOpaque, 0);

   638     } else {

   639         HIViewChangeFeatures(hiview, 0, kHIViewIsOpaque);

   640     }

   641     if (q->isVisible())

   642         HIViewReshapeStructure(qt_mac_nativeview_for(q));

   643 #else

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

   645         bool opaque = isOpaque;

   646         if (extra && extra->imageMask)

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

   648         [qt_mac_window_for(q) setOpaque:opaque];

   649     }

   650 #endif

   651 }

   652 #ifdef QT_MAC_USE_COCOA

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

   654                                         NSUInteger wattr, const QRect &crect)

   655 {

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

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

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

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

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

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

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

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

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

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

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

   667                       | Qt::WindowMinimizeButtonHint | Qt::WindowTitleHint))

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

   669             wattr |= QtMacCustomizeWindow;

   670     }

   671 

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

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

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

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

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

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

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

   679     QMacCocoaAutoReleasePool pool;

   680     OSWindowRef window;

   681     switch (wclass) {

   682     case kMovableModalWindowClass:

   683     case kModalWindowClass:

   684     case kSheetWindowClass:

   685     case kFloatingWindowClass:

   686     case kOverlayWindowClass:

   687     case kHelpWindowClass: {

   688         NSPanel *panel;

   689         BOOL needFloating = NO;

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

   691         // Add in the extra flags if necessary.

   692         switch (wclass) {

   693         case kSheetWindowClass:

   694             wattr |= NSDocModalWindowMask;

   695             break;

   696         case kFloatingWindowClass:

   697         case kHelpWindowClass:

   698             needFloating = YES;

   699             wattr |= NSUtilityWindowMask;

   700             break;

   701         default:

   702             break;

   703         }

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

   705         [panel setFloatingPanel:needFloating];

   706         [panel setWorksWhenModal:worksWhenModal];

   707         window = panel;

   708         break;

   709     }

   710     case kDrawerWindowClass: {

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

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

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

   714         if (parentWidget)

   715             [drawer setParentWindow:qt_mac_window_for(parentWidget)];

   716         [drawer setLeadingOffset:0.0];

   717         [drawer setTrailingOffset:25.0];

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

   719         break;

   720     }

   721     default:

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

   723         break;

   724     }

   725     qt_syncCocoaTitleBarButtons(window, widget);

   726     return window;

   727 }

   728 #else

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

   730                                         const QRect &crect)

   731 {

   732     OSWindowRef window;

   733     Rect geo;

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

   735     OSStatus err;

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

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

   738     Rect null_rect;

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

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

   741     if(err == noErr) {

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

   743         if(err != noErr)

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

   745     }

   746     return window;

   747 }

   748 

   749 #if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6

   750 /* We build the release package against the 10.4 SDK.

   751    So, to enable gestures for applications running on

   752    10.6+, we define the missing constants here: */

   753 enum {

   754     kEventClassGesture              = 'gest',

   755     kEventGestureStarted            = 1,

   756     kEventGestureEnded              = 2,

   757     kEventGestureMagnify            = 4,

   758     kEventGestureSwipe              = 5,

   759     kEventGestureRotate             = 6,

   760     kEventParamRotationAmount       = 'rota',

   761     kEventParamSwipeDirection       = 'swip',

   762     kEventParamMagnificationAmount  = 'magn'

   763 };

   764 #endif

   765 

   766 // window events

   767 static EventTypeSpec window_events[] = {

   768     { kEventClassWindow, kEventWindowClose },

   769     { kEventClassWindow, kEventWindowExpanded },

   770     { kEventClassWindow, kEventWindowHidden },

   771     { kEventClassWindow, kEventWindowZoom },

   772     { kEventClassWindow, kEventWindowZoomed },

   773     { kEventClassWindow, kEventWindowCollapsed },

   774     { kEventClassWindow, kEventWindowToolbarSwitchMode },

   775     { kEventClassWindow, kEventWindowProxyBeginDrag },

   776     { kEventClassWindow, kEventWindowProxyEndDrag },

   777     { kEventClassWindow, kEventWindowResizeCompleted },

   778     { kEventClassWindow, kEventWindowBoundsChanging },

   779     { kEventClassWindow, kEventWindowGetRegion },

   780     { kEventClassWindow, kEventWindowGetClickModality },

   781     { kEventClassWindow, kEventWindowTransitionCompleted },

   782     { kEventClassGesture, kEventGestureStarted },

   783     { kEventClassGesture, kEventGestureEnded },

   784     { kEventClassGesture, kEventGestureMagnify },

   785     { kEventClassGesture, kEventGestureSwipe },

   786     { kEventClassGesture, kEventGestureRotate },

   787     { kEventClassMouse, kEventMouseDown }

   788 };

   789 static EventHandlerUPP mac_win_eventUPP = 0;

   790 static void cleanup_win_eventUPP()

   791 {

   792     DisposeEventHandlerUPP(mac_win_eventUPP);

   793     mac_win_eventUPP = 0;

   794 }

   795 static const EventHandlerUPP make_win_eventUPP()

   796 {

   797     if(mac_win_eventUPP)

   798         return mac_win_eventUPP;

   799     qAddPostRoutine(cleanup_win_eventUPP);

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

   801 }

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

   803 {

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

   805     bool handled_event = true;

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

   807     switch(eclass) {

   808     case kEventClassWindow: {

   809         WindowRef wid = 0;

   810         GetEventParameter(event, kEventParamDirectObject, typeWindowRef, 0,

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

   812         QWidget *widget = qt_mac_find_window(wid);

   813         if(!widget) {

   814             handled_event = false;

   815         } else if(ekind == kEventWindowGetClickModality) {

   816             // Carbon will send us kEventWindowGetClickModality before every

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

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

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

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

   821             // and perhaps use it to close itself.

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

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

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

   825         } else if(ekind == kEventWindowClose) {

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

   827             QMenuBar::macUpdateMenuBar();

   828         } else if (ekind == kEventWindowTransitionCompleted) {

   829             WindowTransitionAction transitionAction;

   830             GetEventParameter(event, kEventParamWindowTransitionAction, typeWindowTransitionAction,

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

   832             if (transitionAction == kWindowHideTransitionAction)

   833                 widget->hide();

   834         } else if(ekind == kEventWindowExpanded) {

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

   836             Qt::WindowStates newState = currState;

   837             if (currState & Qt::WindowMinimized)

   838                 newState &= ~Qt::WindowMinimized;

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

   840                 newState |= Qt::WindowActive;

   841             if (newState != currState) {

   842                 // newState will differ from currState if the window

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

   844                 // to calling QWidget::setWindowState)

   845                 widget->data->window_state = newState;

   846                 QWindowStateChangeEvent e(currState);

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

   848             }

   849 

   850             QShowEvent qse;

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

   852         } else if(ekind == kEventWindowZoom) {

   853             widget->d_func()->topData()->normalGeometry = widget->geometry();

   854             handled_event = false;

   855         } else if(ekind == kEventWindowZoomed) {

   856             WindowPartCode windowPart;

   857             GetEventParameter(event, kEventParamWindowPartCode,

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

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

   860 

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

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

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

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

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

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

   867                                                            & ~Qt::WindowMaximized));

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

   869             }

   870             qt_button_down = 0;

   871         } else if(ekind == kEventWindowCollapsed) {

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

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

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

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

   876             }

   877 

   878             // Deactivate this window:

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

   880                 QWidget *w = 0;

   881                 if (widget->parentWidget())

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

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

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

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

   886                         if ((w = qt_mac_find_window(wp)))

   887                             break;

   888                     }

   889                 }

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

   891                     qApp->setActiveWindow(0);

   892             }

   893 

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

   895             QEvent e(QEvent::Hide);

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

   897             qt_button_down = 0;

   898         } else if(ekind == kEventWindowToolbarSwitchMode) {

   899             macSendToolbarChangeEvent(widget);

   900             HIToolbarRef toolbar;

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

   902                 if (toolbar) {

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

   904                     // needs to know about it.

   905                     CallNextEventHandler(er, event);

   906                     qt_event_request_window_change(widget);

   907                     widget->data->fstrut_dirty = true;

   908                 }

   909             }

   910         } else if(ekind == kEventWindowGetRegion) {

   911             WindowRef window;

   912             GetEventParameter(event, kEventParamDirectObject, typeWindowRef, 0,

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

   914             WindowRegionCode wcode;

   915             GetEventParameter(event, kEventParamWindowRegionCode, typeWindowRegionCode, 0,

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

   917             if (wcode != kWindowOpaqueRgn){

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

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

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

   921                 CallNextEventHandler(er, event);

   922             }

   923 			RgnHandle rgn;

   924             GetEventParameter(event, kEventParamRgnHandle, typeQDRgnHandle, 0,

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

   926 

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

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

   929         } else if(ekind == kEventWindowProxyBeginDrag) {

   930             QIconDragEvent e;

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

   932         } else if(ekind == kEventWindowResizeCompleted) {

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

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

   935             EventRef mouseUpEvent;

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

   937             UInt16 mbutton = kEventMouseButtonPrimary;

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

   939             WindowRef window;

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

   941             Rect dragRect;

   942             GetWindowBounds(window, kWindowGrowRgn, &dragRect);

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

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

   945             SendEventToApplication(mouseUpEvent);

   946             ReleaseEvent(mouseUpEvent);

   947         } else if(ekind == kEventWindowBoundsChanging) {

   948             UInt32 flags = 0;

   949             GetEventParameter(event, kEventParamAttributes, typeUInt32, 0,

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

   951             Rect nr;

   952             GetEventParameter(event, kEventParamCurrentBounds, typeQDRectangle, 0,

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

   954 

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

   956 

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

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

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

   960             } else {

   961                 //implicitly removes the maximized bit

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

   963                    IsWindowInStandardState(wid, 0, 0)) {

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

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

   966                                                 | Qt::WindowMaximized));

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

   968 

   969                 }

   970 

   971                 handled_event = false;

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

   973                 if((flags & kWindowBoundsChangeOriginChanged)) {

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

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

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

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

   978                     }

   979                 }

   980                 if((flags & kWindowBoundsChangeSizeChanged)) {

   981                     if (widget->isWindow()) {

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

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

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

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

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

   987 

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

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

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

   991 

   992                             nr.left = newRect.x();

   993                             nr.top = newRect.y();

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

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

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

   997                         }

   998                     }

   999 

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

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

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

  1003 

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

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

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

  1007                         // the newly exposed area for us.

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

  1009                         const HIViewRef view = qt_mac_nativeview_for(widget);

  1010                         if (staticContents)

  1011                             HIViewSetDrawingEnabled(view, false);

  1012                         HIViewSetFrame(view, &bounds);

  1013                         if (staticContents)

  1014                             HIViewSetDrawingEnabled(view, true);

  1015 

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

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

  1018                         qt_event_request_window_change(widget);

  1019                     }

  1020                 }

  1021             }

  1022         } else if (ekind == kEventWindowHidden) {

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

  1024             // Cocoa does the right thing for us.

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

  1026             const int childCount = children.count();

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

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

  1029                 if (obj->isWidgetType()) {

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

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

  1032                         widget->hide();

  1033                 }

  1034             }

  1035         } else {

  1036             handled_event = false;

  1037         }

  1038         break; }

  1039     case kEventClassMouse: {

  1040 #if 0

  1041         return SendEventToApplication(event);

  1042 #endif

  1043 

  1044         bool send_to_app = false;

  1045         {

  1046             WindowPartCode wpc;

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

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

  1049                 send_to_app = true;

  1050         }

  1051         if(!send_to_app) {

  1052             WindowRef window;

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

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

  1055                 HIViewRef hiview;

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

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

  1058 #if 0

  1059                         send_to_app = !w->isActiveWindow();

  1060 #else

  1061                         Q_UNUSED(w);

  1062                         send_to_app = true;

  1063 #endif

  1064                     }

  1065                 }

  1066             }

  1067         }

  1068         if(send_to_app)

  1069             return SendEventToApplication(event);

  1070         handled_event = false;

  1071         break; }

  1072 

  1073     case kEventClassGesture: {

  1074         // First, find the widget that was under

  1075         // the mouse when the gesture happened:

  1076         HIPoint screenLocation;

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

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

  1079             handled_event = false;

  1080             break;

  1081         }

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

  1083         if (!widget) {

  1084             handled_event = false;

  1085             break;

  1086         }

  1087 

  1088         QNativeGestureEvent qNGEvent;

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

  1090 

  1091         switch (ekind) {

  1092             case kEventGestureStarted:

  1093                 qNGEvent.gestureType = QNativeGestureEvent::GestureBegin;

  1094                 break;

  1095             case kEventGestureEnded:

  1096                 qNGEvent.gestureType = QNativeGestureEvent::GestureEnd;

  1097                 break;

  1098             case kEventGestureRotate: {

  1099                 CGFloat amount;

  1100                 if (GetEventParameter(event, kEventParamRotationAmount, 'cgfl', 0,

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

  1102                     handled_event = false;

  1103                     break;

  1104                 }

  1105                 qNGEvent.gestureType = QNativeGestureEvent::Rotate;

  1106                 qNGEvent.percentage = float(-amount);

  1107                 break; }

  1108             case kEventGestureSwipe: {

  1109                 HIPoint swipeDirection;

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

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

  1112                     handled_event = false;

  1113                     break;

  1114                 }

  1115                 qNGEvent.gestureType = QNativeGestureEvent::Swipe;

  1116                 if (swipeDirection.x == 1)

  1117                     qNGEvent.angle = 180.0f;

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

  1119                     qNGEvent.angle = 0.0f;

  1120                 else if (swipeDirection.y == 1)

  1121                     qNGEvent.angle = 90.0f;

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

  1123                     qNGEvent.angle = 270.0f;

  1124                 break; }

  1125             case kEventGestureMagnify: {

  1126                 CGFloat amount;

  1127                 if (GetEventParameter(event, kEventParamMagnificationAmount, 'cgfl', 0,

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

  1129                     handled_event = false;

  1130                     break;

  1131                 }

  1132                 qNGEvent.gestureType = QNativeGestureEvent::Zoom;

  1133                 qNGEvent.percentage = float(amount);

  1134                 break; }

  1135         }