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 <Cocoa/Cocoa.h>

    77 

    78 #include "qapplication.h"

    79 #include "qbitarray.h"

    80 #include "qclipboard.h"

    81 #include "qcursor.h"

    82 #include "qdatastream.h"

    83 #include "qdatetime.h"

    84 #include "qdesktopwidget.h"

    85 #include "qdockwidget.h"

    86 #include "qevent.h"

    87 #include "qhash.h"

    88 #include "qlayout.h"

    89 #include "qmenubar.h"

    90 #include "qmessagebox.h"

    91 #include "qmime.h"

    92 #include "qpixmapcache.h"

    93 #include "qpointer.h"

    94 #include "qsessionmanager.h"

    95 #include "qsettings.h"

    96 #include "qsocketnotifier.h"

    97 #include "qstyle.h"

    98 #include "qstylefactory.h"

    99 #include "qtextcodec.h"

   100 #include "qtoolbar.h"

   101 #include "qvariant.h"

   102 #include "qwidget.h"

   103 #include "qcolormap.h"

   104 #include "qdir.h"

   105 #include "qdebug.h"

   106 #include "qtimer.h"

   107 #include "qurl.h"

   108 #include "private/qmacinputcontext_p.h"

   109 #include "private/qpaintengine_mac_p.h"

   110 #include "private/qcursor_p.h"

   111 #include "private/qapplication_p.h"

   112 #include "private/qcolor_p.h"

   113 #include "private/qwidget_p.h"

   114 #include "private/qkeymapper_p.h"

   115 #include "private/qeventdispatcher_mac_p.h"

   116 #include "private/qeventdispatcher_unix_p.h"

   117 #include <private/qcocoamenuloader_mac_p.h>

   118 #include <private/qcocoaapplication_mac_p.h>

   119 #include <private/qcocoaapplicationdelegate_mac_p.h>

   120 #include <private/qt_cocoa_helpers_mac_p.h>

   121 #include <private/qcocoawindow_mac_p.h>

   122 #include <private/qpixmap_mac_p.h>

   123 #include <private/qdesktopwidget_mac_p.h>

   124 #include <private/qeventdispatcher_mac_p.h>

   125 #include <qvarlengtharray.h>

   126 

   127 #ifndef QT_NO_ACCESSIBILITY

   128 #  include "qaccessible.h"

   129 #endif

   130 

   131 #ifndef QT_NO_THREAD

   132 #  include "qmutex.h"

   133 #endif

   134 

   135 #include <unistd.h>

   136 #include <string.h>

   137 #include <sys/time.h>

   138 #include <sys/select.h>

   139 

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

   141   QApplication debug facilities

   142  *****************************************************************************/

   143 //#define DEBUG_EVENTS //like EventDebug but more specific to Qt

   144 //#define DEBUG_DROPPED_EVENTS

   145 //#define DEBUG_MOUSE_MAPS

   146 //#define DEBUG_MODAL_EVENTS

   147 //#define DEBUG_PLATFORM_SETTINGS

   148 

   149 #define QMAC_SPEAK_TO_ME

   150 #ifdef QMAC_SPEAK_TO_ME

   151 #include "qregexp.h"

   152 #endif

   153 

   154 #ifndef kThemeBrushAlternatePrimaryHighlightColor

   155 #define kThemeBrushAlternatePrimaryHighlightColor -5

   156 #endif

   157 

   158 #define kCMDeviceUnregisteredNotification CFSTR("CMDeviceUnregisteredNotification")

   159 #define kCMDefaultDeviceNotification CFSTR("CMDefaultDeviceNotification")

   160 #define kCMDeviceProfilesNotification CFSTR("CMDeviceProfilesNotification")

   161 #define kCMDefaultDeviceProfileNotification CFSTR("CMDefaultDeviceProfileNotification")

   162 

   163 QT_BEGIN_NAMESPACE

   164 

   165 //for qt_mac.h

   166 QPaintDevice *qt_mac_safe_pdev = 0;

   167 QList<QMacWindowChangeEvent*> *QMacWindowChangeEvent::change_events = 0;

   168 

   169 /*****************************************************************************

   170   Internal variables and functions

   171  *****************************************************************************/

   172 static struct {

   173     bool use_qt_time_limit;

   174     QPointer<QWidget> last_widget;

   175     int last_x, last_y;

   176     int last_modifiers, last_button;

   177     EventTime last_time;

   178 } qt_mac_dblclick = { false, 0, -1, -1, 0, 0, -2 };

   179 

   180 static bool app_do_modal = false;       // modal mode

   181 extern QWidgetList *qt_modal_stack;     // stack of modal widgets

   182 extern bool qt_tab_all_widgets;         // from qapplication.cpp

   183 bool qt_mac_app_fullscreen = false;

   184 bool qt_scrollbar_jump_to_pos = false;

   185 static bool qt_mac_collapse_on_dblclick = true;

   186 extern int qt_antialiasing_threshold; // from qapplication.cpp

   187 QPointer<QWidget> qt_button_down;                // widget got last button-down

   188 #ifndef QT_MAC_USE_COCOA

   189 static bool qt_button_down_in_content; // whether the button_down was in the content area.

   190 static bool qt_mac_previous_press_in_popup_mode = false;

   191 static bool qt_mac_no_click_through_mode = false;

   192 static int tablet_button_state = 0;

   193 #endif

   194 QPointer<QWidget> qt_mouseover;

   195 #if defined(QT_DEBUG)

   196 static bool        appNoGrab        = false;        // mouse/keyboard grabbing

   197 #endif

   198 #ifndef QT_MAC_USE_COCOA

   199 static EventHandlerRef app_proc_handler = 0;

   200 static EventHandlerUPP app_proc_handlerUPP = 0;

   201 #endif

   202 static AEEventHandlerUPP app_proc_ae_handlerUPP = NULL;

   203 static EventHandlerRef tablet_proximity_handler = 0;

   204 static EventHandlerUPP tablet_proximity_UPP = 0;

   205 bool QApplicationPrivate::native_modal_dialog_active;

   206 

   207 Q_GUI_EXPORT bool qt_applefontsmoothing_enabled;

   208 

   209 /*****************************************************************************

   210   External functions

   211  *****************************************************************************/

   212 extern void qt_mac_beep(); //qsound_mac.mm

   213 extern Qt::KeyboardModifiers qt_mac_get_modifiers(int keys); //qkeymapper_mac.cpp

   214 extern bool qt_mac_can_clickThrough(const QWidget *); //qwidget_mac.cpp

   215 extern bool qt_mac_is_macdrawer(const QWidget *); //qwidget_mac.cpp

   216 extern OSWindowRef qt_mac_window_for(const QWidget*); //qwidget_mac.cpp

   217 extern QWidget *qt_mac_find_window(OSWindowRef); //qwidget_mac.cpp

   218 extern void qt_mac_set_cursor(const QCursor *, const QPoint &); //qcursor_mac.cpp

   219 extern bool qt_mac_is_macsheet(const QWidget *); //qwidget_mac.cpp

   220 extern QString qt_mac_from_pascal_string(const Str255); //qglobal.cpp

   221 extern void qt_mac_command_set_enabled(MenuRef, UInt32, bool); //qmenu_mac.cpp

   222 extern bool qt_sendSpontaneousEvent(QObject *obj, QEvent *event); // qapplication.cpp

   223 

   224 // Forward Decls

   225 void onApplicationWindowChangedActivation( QWidget*widget, bool activated );

   226 void onApplicationChangedActivation( bool activated );

   227 

   228 static void qt_mac_read_fontsmoothing_settings()

   229 {

   230     qt_applefontsmoothing_enabled = true;

   231     int w = 10, h = 10;

   232     QImage image(w, h, QImage::Format_RGB32);

   233     image.fill(0xffffffff);

   234     QPainter p(&image);

   235     p.drawText(0, h, "X\\");

   236     p.end();

   237 

   238     const int *bits = (const int *) ((const QImage &) image).bits();

   239     int bpl = image.bytesPerLine() / 4;

   240     for (int y=0; y<w; ++y) {

   241         for (int x=0; x<h; ++x) {

   242             int r = qRed(bits[x]);

   243             int g = qGreen(bits[x]);

   244             int b = qBlue(bits[x]);

   245             if (r != g || r != b) {

   246                 qt_applefontsmoothing_enabled = true;

   247                 return;

   248             }

   249         }

   250         bits += bpl;

   251     }

   252     qt_applefontsmoothing_enabled = false;

   253 }

   254 

   255 Q_GUI_EXPORT bool qt_mac_execute_apple_script(const char *script, long script_len, AEDesc *ret) {

   256     OSStatus err;

   257     AEDesc scriptTextDesc;

   258     ComponentInstance theComponent = 0;

   259     OSAID scriptID = kOSANullScript, resultID = kOSANullScript;

   260 

   261     // set up locals to a known state

   262     AECreateDesc(typeNull, 0, 0, &scriptTextDesc);

   263     scriptID = kOSANullScript;

   264     resultID = kOSANullScript;

   265 

   266     // open the scripting component

   267     theComponent = OpenDefaultComponent(kOSAComponentType, typeAppleScript);

   268     if (!theComponent) {

   269         err = paramErr;

   270         goto bail;

   271     }

   272 

   273     // put the script text into an aedesc

   274     err = AECreateDesc(typeUTF8Text, script, script_len, &scriptTextDesc);

   275     if (err != noErr)

   276         goto bail;

   277 

   278     // compile the script

   279     err = OSACompile(theComponent, &scriptTextDesc, kOSAModeNull, &scriptID);

   280     if (err != noErr)

   281         goto bail;

   282 

   283     // run the script

   284     err = OSAExecute(theComponent, scriptID, kOSANullScript, kOSAModeNull, &resultID);

   285 

   286     // collect the results - if any

   287     if (ret) {

   288         AECreateDesc(typeNull, 0, 0, ret);

   289         if (err == errOSAScriptError)

   290             OSAScriptError(theComponent, kOSAErrorMessage, typeChar, ret);

   291         else if (err == noErr && resultID != kOSANullScript)

   292             OSADisplay(theComponent, resultID, typeChar, kOSAModeNull, ret);

   293     }

   294 bail:

   295     AEDisposeDesc(&scriptTextDesc);

   296     if (scriptID != kOSANullScript)

   297         OSADispose(theComponent, scriptID);

   298     if (resultID != kOSANullScript)

   299         OSADispose(theComponent, resultID);

   300     if (theComponent)

   301         CloseComponent(theComponent);

   302     return err == noErr;

   303 }

   304 

   305 Q_GUI_EXPORT bool qt_mac_execute_apple_script(const char *script, AEDesc *ret)

   306 {

   307     return qt_mac_execute_apple_script(script, qstrlen(script), ret);

   308 }

   309 

   310 Q_GUI_EXPORT bool qt_mac_execute_apple_script(const QString &script, AEDesc *ret)

   311 {

   312     const QByteArray l = script.toUtf8(); return qt_mac_execute_apple_script(l.constData(), l.size(), ret);

   313 }

   314 

   315 /* Resolution change magic */

   316 void qt_mac_display_change_callbk(CGDirectDisplayID, CGDisplayChangeSummaryFlags flags, void *)

   317 {

   318 #if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5)

   319     const bool resized = flags & kCGDisplayDesktopShapeChangedFlag;

   320 #else

   321     Q_UNUSED(flags);

   322     const bool resized = true;

   323 #endif

   324     if (resized && qApp) {

   325         if (QDesktopWidget *dw = qApp->desktop()) {

   326             QResizeEvent *re = new QResizeEvent(dw->size(), dw->size());

   327             QApplication::postEvent(dw, re);

   328             QCoreGraphicsPaintEngine::cleanUpMacColorSpaces();

   329         }

   330     }

   331 }

   332 

   333 #ifdef DEBUG_PLATFORM_SETTINGS

   334 static void qt_mac_debug_palette(const QPalette &pal, const QPalette &pal2, const QString &where)

   335 {

   336     const char *const groups[] = {"Active", "Disabled", "Inactive" };

   337     const char *const roles[] = { "WindowText", "Button", "Light", "Midlight", "Dark", "Mid",

   338                             "Text", "BrightText", "ButtonText", "Base", "Window", "Shadow",

   339                             "Highlight", "HighlightedText", "Link", "LinkVisited" };

   340     if (!where.isNull())

   341         qDebug("qt-internal: %s", where.toLatin1().constData());

   342     for(int grp = 0; grp < QPalette::NColorGroups; grp++) {

   343         for(int role = 0; role < QPalette::NColorRoles; role++) {

   344             QBrush b = pal.brush((QPalette::ColorGroup)grp, (QPalette::ColorRole)role);

   345             QPixmap pm = b.texture();

   346             qDebug("  %s::%s %d::%d::%d [%p]%s", groups[grp], roles[role], b.color().red(),

   347                    b.color().green(), b.color().blue(), pm.isNull() ? 0 : &pm,

   348                    pal2.brush((QPalette::ColorGroup)grp, (QPalette::ColorRole)role) != b ? " (*)" : "");

   349         }

   350     }

   351 

   352 }

   353 #else

   354 #define qt_mac_debug_palette(x, y, z)

   355 #endif

   356 

   357 //raise a notification

   358 #ifndef QT_MAC_USE_COCOA

   359 static NMRec qt_mac_notification = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

   360 #endif

   361 void qt_mac_send_notification()

   362 {

   363 #ifndef QT_MAC_USE_COCOA

   364     //send it

   365     qt_mac_notification.nmMark = 1; //non-zero magic number

   366     qt_mac_notification.qType = nmType;

   367     NMInstall(&qt_mac_notification);

   368 #else

   369     QMacCocoaAutoReleasePool pool;

   370     [[NSApplication sharedApplication] requestUserAttention:NSInformationalRequest];

   371 #endif

   372 }

   373 

   374 void qt_mac_cancel_notification()

   375 {

   376 #ifndef QT_MAC_USE_COCOA

   377     NMRemove(&qt_mac_notification);

   378 #else

   379     QMacCocoaAutoReleasePool pool;

   380     [[NSApplication sharedApplication] cancelUserAttentionRequest:NSInformationalRequest];

   381 #endif

   382 }

   383 

   384 #ifndef QT_MAC_USE_COCOA

   385 //find widget (and part) at a given point

   386 static short qt_mac_window_at(int x, int y, QWidget **w=0)

   387 {

   388     Point p;

   389     p.h = x;

   390     p.v = y;

   391     OSWindowRef wp;

   392     WindowPartCode wpc;

   393     OSStatus err = FindWindowOfClass(&p, kAllWindowClasses, &wp, &wpc);

   394     if(err != noErr) {

   395         if(w)

   396             (*w) = 0;

   397         return wpc;

   398     }

   399     if(w) {

   400         if(wp) {

   401             *w = qt_mac_find_window(wp);

   402 #if 0

   403             if(!*w)

   404                 qWarning("QApplication: qt_mac_window_at: Couldn't find %d",(int)wp);

   405 #endif

   406         } else {

   407             *w = 0;

   408         }

   409     }

   410     return wpc;

   411 }

   412 

   413 #endif

   414 

   415 void qt_mac_set_app_icon(const QPixmap &pixmap)

   416 {

   417 #ifndef QT_MAC_USE_COCOA

   418     if(pixmap.isNull()) {

   419         RestoreApplicationDockTileImage();

   420     } else {

   421         CGImageRef img = (CGImageRef)pixmap.macCGHandle();

   422         SetApplicationDockTileImage(img);

   423         CGImageRelease(img);

   424     }

   425 #else

   426     QMacCocoaAutoReleasePool pool;

   427     NSImage *image = NULL;

   428     if (pixmap.isNull()) {

   429         // Get Application icon from bundle

   430         image = [[NSImage imageNamed:@"NSApplicationIcon"] retain]; // released below

   431     } else {

   432         image = static_cast<NSImage *>(qt_mac_create_nsimage(pixmap));

   433     }

   434 

   435     [NSApp setApplicationIconImage:image];

   436     [image release];

   437 #endif

   438 }

   439 

   440 Q_GUI_EXPORT void qt_mac_set_press_and_hold_context(bool b)

   441 {

   442     Q_UNUSED(b);

   443     qWarning("qt_mac_set_press_and_hold_context: This functionality is no longer available");

   444 }

   445 

   446 bool qt_nograb()                                // application no-grab option

   447 {

   448 #if defined(QT_DEBUG)

   449     return appNoGrab;

   450 #else

   451     return false;

   452 #endif

   453 }

   454 

   455 void qt_mac_update_os_settings()

   456 {

   457     if (!qApp)

   458         return;

   459     if (!QApplication::startingUp()) {

   460         static bool needToPolish = true;

   461         if (needToPolish) {

   462             QApplication::style()->polish(qApp);

   463             needToPolish = false;

   464         }

   465     }

   466     //focus mode

   467     /* First worked as of 10.2.3 */

   468     QSettings appleSettings(QLatin1String("apple.com"));

   469     QVariant appleValue = appleSettings.value(QLatin1String("AppleKeyboardUIMode"), 0);

   470     qt_tab_all_widgets = (appleValue.toInt() & 0x2);

   471     //paging mode

   472     /* First worked as of 10.2.3 */

   473     appleValue = appleSettings.value(QLatin1String("AppleScrollerPagingBehavior"), false);

   474     qt_scrollbar_jump_to_pos = appleValue.toBool();

   475     //collapse

   476     /* First worked as of 10.3.3 */

   477     appleValue = appleSettings.value(QLatin1String("AppleMiniaturizeOnDoubleClick"), true);

   478     qt_mac_collapse_on_dblclick = appleValue.toBool();

   479 

   480     // Anti-aliasing threshold

   481     appleValue = appleSettings.value(QLatin1String("AppleAntiAliasingThreshold"));

   482     if (appleValue.isValid())

   483         qt_antialiasing_threshold = appleValue.toInt();

   484 

   485 #ifdef DEBUG_PLATFORM_SETTINGS

   486     qDebug("qt_mac_update_os_settings *********************************************************************");

   487 #endif

   488     { // setup the global palette

   489         QColor qc;

   490         (void) QApplication::style();  // trigger creation of application style and system palettes

   491         QPalette pal = *QApplicationPrivate::sys_pal;

   492 

   493         pal.setBrush( QPalette::Active, QPalette::Highlight, qcolorForTheme(kThemeBrushPrimaryHighlightColor) );

   494         pal.setBrush( QPalette::Inactive, QPalette::Highlight, qcolorForTheme(kThemeBrushSecondaryHighlightColor) );

   495 

   496         pal.setBrush( QPalette::Disabled, QPalette::Highlight, qcolorForTheme(kThemeBrushSecondaryHighlightColor) );

   497         pal.setBrush( QPalette::Active, QPalette::Shadow, qcolorForTheme(kThemeBrushButtonActiveDarkShadow) );

   498 

   499         pal.setBrush( QPalette::Inactive, QPalette::Shadow, qcolorForTheme(kThemeBrushButtonInactiveDarkShadow) );

   500         pal.setBrush( QPalette::Disabled, QPalette::Shadow, qcolorForTheme(kThemeBrushButtonInactiveDarkShadow) );

   501 

   502         qc = qcolorForThemeTextColor(kThemeTextColorDialogActive);

   503         pal.setColor(QPalette::Active, QPalette::Text, qc);

   504         pal.setColor(QPalette::Active, QPalette::WindowText, qc);

   505         pal.setColor(QPalette::Active, QPalette::HighlightedText, qc);

   506 

   507         qc = qcolorForThemeTextColor(kThemeTextColorDialogInactive);

   508         pal.setColor(QPalette::Inactive, QPalette::Text, qc);

   509         pal.setColor(QPalette::Inactive, QPalette::WindowText, qc);

   510         pal.setColor(QPalette::Inactive, QPalette::HighlightedText, qc);

   511         pal.setColor(QPalette::Disabled, QPalette::Text, qc);

   512         pal.setColor(QPalette::Disabled, QPalette::WindowText, qc);

   513         pal.setColor(QPalette::Disabled, QPalette::HighlightedText, qc);

   514         pal.setBrush(QPalette::ToolTipBase, QColor(255, 255, 199));

   515 

   516         if (!QApplicationPrivate::sys_pal || *QApplicationPrivate::sys_pal != pal) {

   517             QApplicationPrivate::setSystemPalette(pal);

   518             QApplication::setPalette(pal);

   519         }

   520 #ifdef DEBUG_PLATFORM_SETTINGS

   521         qt_mac_debug_palette(pal, QApplication::palette(), "Global Palette");

   522 #endif

   523     }

   524 

   525     QFont fnt = qfontForThemeFont(kThemeApplicationFont);

   526 #ifdef DEBUG_PLATFORM_SETTINGS

   527     qDebug("qt-internal: Font for Application [%s::%d::%d::%d]",

   528            fnt.family().toLatin1().constData(), fnt.pointSize(), fnt.bold(), fnt.italic());

   529 #endif

   530     if (!QApplicationPrivate::sys_font || *QApplicationPrivate::sys_font != fnt)

   531         QApplicationPrivate::setSystemFont(fnt);

   532 

   533     { //setup the fonts

   534         struct FontMap {

   535             FontMap(const char *qc, short fk) : qt_class(qc), font_key(fk) { }

   536             const char *const qt_class;

   537             short font_key;

   538         } mac_widget_fonts[] = {

   539             FontMap("QPushButton", kThemePushButtonFont),

   540             FontMap("QListView", kThemeViewsFont),

   541             FontMap("QListBox", kThemeViewsFont),

   542             FontMap("QTitleBar", kThemeWindowTitleFont),

   543             FontMap("QMenuBar", kThemeMenuTitleFont),

   544             FontMap("QMenu", kThemeMenuItemFont),

   545             FontMap("QComboMenuItem", kThemeSystemFont),

   546             FontMap("QHeaderView", kThemeSmallSystemFont),

   547             FontMap("Q3Header", kThemeSmallSystemFont),

   548             FontMap("QTipLabel", kThemeSmallSystemFont),

   549             FontMap("QLabel", kThemeSystemFont),

   550             FontMap("QToolButton", kThemeSmallSystemFont),

   551             FontMap("QMenuItem", kThemeMenuItemCmdKeyFont),  // It doesn't exist, but its unique.

   552             FontMap("QComboLineEdit", kThemeViewsFont),  // It doesn't exist, but its unique.

   553             FontMap("QSmallFont", kThemeSmallSystemFont),  // It doesn't exist, but its unique.

   554             FontMap("QMiniFont", kThemeMiniSystemFont),  // It doesn't exist, but its unique.

   555             FontMap(0, 0) };

   556         for(int i = 0; mac_widget_fonts[i].qt_class; i++) {

   557             QFont fnt = qfontForThemeFont(mac_widget_fonts[i].font_key);

   558             bool set_font = true;

   559             FontHash *hash = qt_app_fonts_hash();

   560             if (!hash->isEmpty()) {

   561                 FontHash::const_iterator it

   562                                         = hash->constFind(mac_widget_fonts[i].qt_class);

   563                 if (it != hash->constEnd())

   564                     set_font = (fnt != *it);

   565             }

   566             if (set_font) {

   567                 QApplication::setFont(fnt, mac_widget_fonts[i].qt_class);

   568 #ifdef DEBUG_PLATFORM_SETTINGS

   569                 qDebug("qt-internal: Font for %s [%s::%d::%d::%d]", mac_widget_fonts[i].qt_class,

   570                        fnt.family().toLatin1().constData(), fnt.pointSize(), fnt.bold(), fnt.italic());

   571 #endif

   572             }

   573         }

   574     }

   575     QApplicationPrivate::initializeWidgetPaletteHash();

   576 #ifdef DEBUG_PLATFORM_SETTINGS

   577     qDebug("qt_mac_update_os_settings END !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");

   578 #endif

   579 }

   580 

   581 void QApplicationPrivate::initializeWidgetPaletteHash()

   582 {

   583     { //setup the palette

   584         struct PaletteMap {

   585             inline PaletteMap(const char *qc, ThemeBrush a, ThemeBrush i) :

   586                 qt_class(qc), active(a), inactive(i) { }

   587             const char *const qt_class;

   588             ThemeBrush active, inactive;

   589         } mac_widget_colors[] = {

   590             PaletteMap("QToolButton", kThemeTextColorBevelButtonActive, kThemeTextColorBevelButtonInactive),

   591             PaletteMap("QAbstractButton", kThemeTextColorPushButtonActive, kThemeTextColorPushButtonInactive),

   592             PaletteMap("QHeaderView", kThemeTextColorPushButtonActive, kThemeTextColorPushButtonInactive),

   593             PaletteMap("Q3Header", kThemeTextColorPushButtonActive, kThemeTextColorPushButtonInactive),

   594             PaletteMap("QComboBox", kThemeTextColorPopupButtonActive, kThemeTextColorPopupButtonInactive),

   595             PaletteMap("QAbstractItemView", kThemeTextColorListView, kThemeTextColorDialogInactive),

   596             PaletteMap("QMessageBoxLabel", kThemeTextColorAlertActive, kThemeTextColorAlertInactive),

   597             PaletteMap("QTabBar", kThemeTextColorTabFrontActive, kThemeTextColorTabFrontInactive),

   598             PaletteMap("QLabel", kThemeTextColorPlacardActive, kThemeTextColorPlacardInactive),

   599             PaletteMap("QGroupBox", kThemeTextColorPlacardActive, kThemeTextColorPlacardInactive),

   600             PaletteMap("QMenu", kThemeTextColorPopupLabelActive, kThemeTextColorPopupLabelInactive),

   601             PaletteMap("QTextEdit", 0, 0),

   602             PaletteMap("QTextControl", 0, 0),

   603             PaletteMap("QLineEdit", 0, 0),

   604             PaletteMap(0, 0, 0) };

   605         QColor qc;

   606         for(int i = 0; mac_widget_colors[i].qt_class; i++) {

   607             QPalette pal;

   608             if (mac_widget_colors[i].active != 0) {

   609                 qc = qcolorForThemeTextColor(mac_widget_colors[i].active);

   610                 pal.setColor(QPalette::Active, QPalette::Text, qc);

   611                 pal.setColor(QPalette::Active, QPalette::WindowText, qc);

   612                 pal.setColor(QPalette::Active, QPalette::HighlightedText, qc);

   613                 qc = qcolorForThemeTextColor(mac_widget_colors[i].inactive);

   614                 pal.setColor(QPalette::Inactive, QPalette::Text, qc);

   615                 pal.setColor(QPalette::Disabled, QPalette::Text, qc);

   616                 pal.setColor(QPalette::Inactive, QPalette::WindowText, qc);

   617                 pal.setColor(QPalette::Disabled, QPalette::WindowText, qc);

   618                 pal.setColor(QPalette::Inactive, QPalette::HighlightedText, qc);

   619                 pal.setColor(QPalette::Disabled, QPalette::HighlightedText, qc);

   620             }

   621             if (!strcmp(mac_widget_colors[i].qt_class, "QMenu")) {

   622                 qc = qcolorForThemeTextColor(kThemeTextColorMenuItemActive);

   623                 pal.setBrush(QPalette::ButtonText, qc);

   624                 qc = qcolorForThemeTextColor(kThemeTextColorMenuItemSelected);

   625                 pal.setBrush(QPalette::HighlightedText, qc);

   626                 qc = qcolorForThemeTextColor(kThemeTextColorMenuItemDisabled);

   627                 pal.setBrush(QPalette::Disabled, QPalette::Text, qc);

   628             } else if (!strcmp(mac_widget_colors[i].qt_class, "QAbstractButton")

   629                       || !strcmp(mac_widget_colors[i].qt_class, "QHeaderView")

   630                       || !strcmp(mac_widget_colors[i].qt_class, "Q3Header")) { //special

   631                 pal.setColor(QPalette::Disabled, QPalette::ButtonText,

   632                              pal.color(QPalette::Disabled, QPalette::Text));

   633                 pal.setColor(QPalette::Inactive, QPalette::ButtonText,

   634                              pal.color(QPalette::Inactive, QPalette::Text));

   635                 pal.setColor(QPalette::Active, QPalette::ButtonText,

   636                              pal.color(QPalette::Active, QPalette::Text));

   637             } else if (!strcmp(mac_widget_colors[i].qt_class, "QAbstractItemView")) {

   638                 pal.setBrush(QPalette::Active, QPalette::Highlight,

   639                              qcolorForTheme(kThemeBrushAlternatePrimaryHighlightColor));

   640                 qc = qcolorForThemeTextColor(kThemeTextColorMenuItemSelected);

   641                 pal.setBrush(QPalette::Active, QPalette::HighlightedText, qc);

   642 #if 1

   643                 pal.setBrush(QPalette::Inactive, QPalette::Text,

   644                               pal.brush(QPalette::Active, QPalette::Text));

   645                 pal.setBrush(QPalette::Inactive, QPalette::HighlightedText,

   646                               pal.brush(QPalette::Active, QPalette::Text));

   647 #endif

   648             } else if (!strcmp(mac_widget_colors[i].qt_class, "QTextEdit")

   649                        || !strcmp(mac_widget_colors[i].qt_class, "QTextControl")) {

   650                 pal.setBrush(QPalette::Inactive, QPalette::Text,

   651                               pal.brush(QPalette::Active, QPalette::Text));

   652                 pal.setBrush(QPalette::Inactive, QPalette::HighlightedText,

   653                               pal.brush(QPalette::Active, QPalette::Text));

   654             } else if (!strcmp(mac_widget_colors[i].qt_class, "QLineEdit")) {

   655                 pal.setBrush(QPalette::Disabled, QPalette::Base,

   656                              pal.brush(QPalette::Active, QPalette::Base));

   657             }

   658 

   659             bool set_palette = true;

   660             PaletteHash *phash = qt_app_palettes_hash();

   661             if (!phash->isEmpty()) {

   662                 PaletteHash::const_iterator it

   663                                     = phash->constFind(mac_widget_colors[i].qt_class);

   664                 if (it != phash->constEnd())

   665                     set_palette = (pal != *it);

   666             }

   667             if (set_palette) {

   668                 QApplication::setPalette(pal, mac_widget_colors[i].qt_class);

   669 #ifdef DEBUG_PLATFORM_SETTINGS

   670                 qt_mac_debug_palette(pal, QApplication::palette(), QLatin1String("Palette for ") + QString::fromLatin1(mac_widget_colors[i].qt_class));

   671 #endif

   672             }

   673         }

   674     }

   675 }

   676 

   677 static void qt_mac_event_release(EventRef &event)

   678 {

   679     ReleaseEvent(event);

   680     event = 0;

   681 }

   682 #ifndef QT_MAC_USE_COCOA

   683 static void qt_mac_event_release(QWidget *w, EventRef &event)

   684 {

   685     if (event) {

   686         QWidget *widget = 0;

   687         if (GetEventParameter(event, kEventParamQWidget, typeQWidget, 0, sizeof(widget), 0, &widget) == noErr

   688            && w == widget) {

   689             if (IsEventInQueue(GetMainEventQueue(), event))

   690                 RemoveEventFromQueue(GetMainEventQueue(), event);

   691             qt_mac_event_release(event);

   692         }

   693     }

   694 }

   695 

   696 static bool qt_mac_event_remove(EventRef &event)

   697 {

   698     if (event) {

   699         if (IsEventInQueue(GetMainEventQueue(), event))

   700             RemoveEventFromQueue(GetMainEventQueue(), event);

   701         qt_mac_event_release(event);

   702         return true;

   703     }

   704     return false;

   705 }

   706 #endif

   707 

   708 /* sheets */

   709 #ifndef QT_MAC_USE_COCOA

   710 static EventRef request_showsheet_pending = 0;

   711 #endif

   712 void qt_event_request_showsheet(QWidget *w)

   713 {

   714     Q_ASSERT(qt_mac_is_macsheet(w));

   715 #ifdef QT_MAC_USE_COCOA

   716     [NSApp beginSheet:qt_mac_window_for(w) modalForWindow:qt_mac_window_for(w->parentWidget())

   717         modalDelegate:nil didEndSelector:nil contextInfo:0];

   718 #else

   719     qt_mac_event_remove(request_showsheet_pending);

   720     CreateEvent(0, kEventClassQt, kEventQtRequestShowSheet, GetCurrentEventTime(),

   721                 kEventAttributeUserEvent, &request_showsheet_pending);

   722     SetEventParameter(request_showsheet_pending, kEventParamQWidget, typeQWidget, sizeof(w), &w);

   723     PostEventToQueue(GetMainEventQueue(), request_showsheet_pending, kEventPriorityStandard);

   724 #endif

   725 }

   726 

   727 static void qt_post_window_change_event(QWidget *widget)

   728 {

   729     qt_widget_private(widget)->needWindowChange = true;

   730     QEvent *glWindowChangeEvent = new QEvent(QEvent::MacGLWindowChange);

   731     QApplication::postEvent(widget, glWindowChangeEvent);

   732 }

   733 

   734 /*

   735     Posts updates to all child and grandchild OpenGL widgets for the given widget.

   736 */

   737 static void qt_mac_update_child_gl_widgets(QWidget *widget)

   738 {

   739     if (widget->isWindow())

   740         return;

   741 

   742     // Update all OpenGL child widgets for the given widget.

   743     QList<QWidgetPrivate::GlWidgetInfo> &glWidgets = qt_widget_private(widget)->glWidgets;

   744     QList<QWidgetPrivate::GlWidgetInfo>::iterator end = glWidgets.end();

   745     QList<QWidgetPrivate::GlWidgetInfo>::iterator it = glWidgets.begin();

   746 

   747     for (;it != end; ++it) {

   748         qt_post_window_change_event(it->widget);

   749     }

   750 }

   751 

   752 /*

   753     Sends updates to all child and grandchild gl widgets that have updates pending.

   754 */

   755 void qt_mac_send_posted_gl_updates(QWidget *widget)

   756 {

   757     QList<QWidgetPrivate::GlWidgetInfo> &glWidgets = qt_widget_private(widget)->glWidgets;

   758     QList<QWidgetPrivate::GlWidgetInfo>::iterator end = glWidgets.end();

   759     QList<QWidgetPrivate::GlWidgetInfo>::iterator it = glWidgets.begin();

   760 

   761     for (;it != end; ++it) {

   762         QWidget *glWidget = it->widget;

   763         if (qt_widget_private(glWidget)->needWindowChange) {

   764             QEvent glChangeEvent(QEvent::MacGLWindowChange);

   765             QApplication::sendEvent(glWidget, &glChangeEvent);

   766         }

   767     }

   768 }

   769 

   770 /*

   771     Posts updates to all OpenGL widgets within the window that the given widget intersects.

   772 */

   773 static void qt_mac_update_intersected_gl_widgets(QWidget *widget)

   774 {

   775 #ifndef QT_MAC_USE_COCOA

   776     QList<QWidgetPrivate::GlWidgetInfo> &glWidgets = qt_widget_private(widget->window())->glWidgets;

   777     if (glWidgets.isEmpty())

   778         return;

   779 

   780     // Exit if the window has not been created yet (mapToGlobal/size will force create it)

   781     if (widget->testAttribute(Qt::WA_WState_Created) == false || HIViewGetWindow(qt_mac_nativeview_for(widget)) == 0)

   782         return;

   783 

   784     const QRect globalWidgetRect = QRect(widget->mapToGlobal(QPoint(0, 0)), widget->size());

   785 

   786     QList<QWidgetPrivate::GlWidgetInfo>::iterator end = glWidgets.end();

   787     QList<QWidgetPrivate::GlWidgetInfo>::iterator it = glWidgets.begin();

   788 

   789     for (;it != end; ++it){

   790         QWidget *glWidget = it->widget;

   791         const QRect globalGlWidgetRect = QRect(glWidget->mapToGlobal(QPoint(0, 0)), glWidget->size());

   792         if (globalWidgetRect.intersects(globalGlWidgetRect)) {

   793             qt_post_window_change_event(glWidget);

   794             it->lastUpdateWidget = widget;

   795         } else if (it->lastUpdateWidget == widget) {

   796             // Update the gl wigets that the widget intersected the last time around,

   797             // and that we are not intersecting now. This prevents paint errors when the

   798             // intersecting widget leaves a gl widget.

   799             qt_post_window_change_event(glWidget);

   800             it->lastUpdateWidget = 0;

   801         }

   802     }

   803 #else

   804     Q_UNUSED(widget);

   805 #endif

   806 }

   807 

   808 /*

   809     Posts a kEventQtRequestWindowChange event to the main Carbon event queue.

   810 */

   811 static EventRef request_window_change_pending = 0;

   812 Q_GUI_EXPORT void qt_event_request_window_change()

   813 {

   814     if(request_window_change_pending)

   815         return;

   816 

   817     CreateEvent(0, kEventClassQt, kEventQtRequestWindowChange, GetCurrentEventTime(),

   818                 kEventAttributeUserEvent, &request_window_change_pending);

   819     PostEventToQueue(GetMainEventQueue(), request_window_change_pending, kEventPriorityHigh);

   820 }

   821 

   822 /* window changing. This is a hack around Apple's missing functionality, pending the toolbox

   823    team fix. --Sam */

   824 Q_GUI_EXPORT void qt_event_request_window_change(QWidget *widget)

   825 {

   826     if (!widget)

   827         return;

   828 

   829     // Post a kEventQtRequestWindowChange event. This event is semi-public,

   830     // don't remove this line!

   831     qt_event_request_window_change();

   832 

   833     // Post update request on gl widgets unconditionally.

   834     if (qt_widget_private(widget)->isGLWidget == true) {

   835         qt_post_window_change_event(widget);

   836         return;

   837     }

   838 

   839     qt_mac_update_child_gl_widgets(widget);

   840     qt_mac_update_intersected_gl_widgets(widget);

   841 }

   842 

   843 /* activation */

   844 static struct {

   845     QPointer<QWidget> widget;

   846     EventRef event;

   847     EventLoopTimerRef timer;

   848     EventLoopTimerUPP timerUPP;

   849 } request_activate_pending = { 0, 0, 0, 0 };

   850 bool qt_event_remove_activate()

   851 {

   852     if (request_activate_pending.timer) {

   853         RemoveEventLoopTimer(request_activate_pending.timer);

   854         request_activate_pending.timer = 0;

   855     }

   856     if (request_activate_pending.event)

   857         qt_mac_event_release(request_activate_pending.event);

   858     return true;

   859 }

   860 

   861 void qt_event_activate_timer_callbk(EventLoopTimerRef r, void *)

   862 {

   863     EventLoopTimerRef otc = request_activate_pending.timer;

   864     qt_event_remove_activate();

   865     if (r == otc && !request_activate_pending.widget.isNull()) {

   866         const QWidget *tlw = request_activate_pending.widget->window();

   867         Qt::WindowType wt = tlw->windowType();

   868         if (tlw->isVisible()

   869                && ((wt != Qt::Desktop && wt != Qt::Popup && wt != Qt::Tool) || tlw->isModal())) {

   870             CreateEvent(0, kEventClassQt, kEventQtRequestActivate, GetCurrentEventTime(),

   871                         kEventAttributeUserEvent, &request_activate_pending.event);

   872             PostEventToQueue(GetMainEventQueue(), request_activate_pending.event, kEventPriorityHigh);

   873         }

   874     }

   875 }

   876 

   877 void qt_event_request_activate(QWidget *w)

   878 {

   879     if (w == request_activate_pending.widget)

   880         return;

   881 

   882     /* We put these into a timer because due to order of events being sent we need to be sure this

   883        comes from inside of the event loop */

   884     qt_event_remove_activate();

   885     if (!request_activate_pending.timerUPP)

   886         request_activate_pending.timerUPP = NewEventLoopTimerUPP(qt_event_activate_timer_callbk);

   887     request_activate_pending.widget = w;

   888     InstallEventLoopTimer(GetMainEventLoop(), 0, 0, request_activate_pending.timerUPP, 0, &request_activate_pending.timer);

   889 }

   890 

   891 

   892 /* menubars */

   893 #ifndef QT_MAC_USE_COCOA

   894 static EventRef request_menubarupdate_pending = 0;

   895 #endif

   896 void qt_event_request_menubarupdate()

   897 {

   898 #ifndef QT_MAC_USE_COCOA

   899     if (request_menubarupdate_pending) {

   900         if (IsEventInQueue(GetMainEventQueue(), request_menubarupdate_pending))

   901             return;

   902 #ifdef DEBUG_DROPPED_EVENTS

   903         qDebug("%s:%d Whoa, we dropped an event on the floor!", __FILE__, __LINE__);

   904 #endif

   905     }

   906 

   907     CreateEvent(0, kEventClassQt, kEventQtRequestMenubarUpdate, GetCurrentEventTime(),

   908                 kEventAttributeUserEvent, &request_menubarupdate_pending);

   909     PostEventToQueue(GetMainEventQueue(), request_menubarupdate_pending, kEventPriorityHigh);

   910 #else

   911     // Just call this. The request has the benefit that we don't call this multiple times, but

   912     // we can optimize this.

   913     QMenuBar::macUpdateMenuBar();

   914 #endif

   915 }

   916 

   917 #ifndef QT_MAC_USE_COCOA

   918 //context menu

   919 static EventRef request_context_pending = 0;

   920 static void qt_event_request_context(QWidget *w=0, EventRef *where=0)

   921 {

   922     if (!where)

   923         where = &request_context_pending;

   924     if (*where)

   925         return;

   926     CreateEvent(0, kEventClassQt, kEventQtRequestContext, GetCurrentEventTime(),

   927                 kEventAttributeUserEvent, where);

   928     if (w)

   929         SetEventParameter(*where, kEventParamQWidget, typeQWidget, sizeof(w), &w);

   930     PostEventToQueue(GetMainEventQueue(), *where, kEventPriorityStandard);

   931 }

   932 #endif

   933 

   934 void QApplicationPrivate::createEventDispatcher()

   935 {

   936     Q_Q(QApplication);

   937     if (q->type() != QApplication::Tty)

   938         eventDispatcher = new QEventDispatcherMac(q);

   939     else

   940         eventDispatcher = new QEventDispatcherUNIX(q);

   941 }

   942 

   943 /* clipboard */

   944 void qt_event_send_clipboard_changed()

   945 {

   946 #ifndef QT_MAC_USE_COCOA

   947     AppleEvent ae;

   948     if (AECreateAppleEvent(kEventClassQt, typeAEClipboardChanged, 0, kAutoGenerateReturnID, kAnyTransactionID, &ae) != noErr)

   949         qDebug("Can't happen!!");

   950     AppleEvent reply;

   951     AESend(&ae, &reply, kAENoReply, kAENormalPriority, kAEDefaultTimeout, 0, 0);

   952 #endif

   953 }

   954 

   955 /* app menu */

   956 static QMenu *qt_mac_dock_menu = 0;

   957 Q_GUI_EXPORT void qt_mac_set_dock_menu(QMenu *menu)

   958 {

   959     qt_mac_dock_menu = menu;

   960 #ifdef QT_MAC_USE_COCOA

   961     [NSApp setDockMenu:menu->macMenu()];

   962 #else

   963     SetApplicationDockTileMenu(menu->macMenu());

   964 #endif

   965 }

   966 

   967 /* events that hold pointers to widgets, must be cleaned up like this */

   968 void qt_mac_event_release(QWidget *w)

   969 {

   970     if (w) {

   971 #ifndef QT_MAC_USE_COCOA

   972         qt_mac_event_release(w, request_showsheet_pending);

   973         qt_mac_event_release(w, request_context_pending);

   974 #endif

   975         if (w == qt_mac_dock_menu) {

   976             qt_mac_dock_menu = 0;

   977 #ifndef QT_MAC_USE_COCOA

   978             SetApplicationDockTileMenu(0);

   979 #else

   980             [NSApp setDockMenu:0];

   981 #endif

   982         }

   983     }

   984 }

   985 

   986 struct QMacAppleEventTypeSpec {

   987     AEEventClass mac_class;

   988     AEEventID mac_id;

   989 } app_apple_events[] = {

   990     { kCoreEventClass, kAEQuitApplication },

   991     { kCoreEventClass, kAEOpenDocuments },

   992     { kInternetEventClass, kAEGetURL },

   993 };

   994 

   995 #ifndef QT_MAC_USE_COCOA

   996 

   997 #if (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5)

   998 enum

   999 {

  1000     kEventMouseScroll                          = 11,

  1001     kEventParamMouseWheelSmoothVerticalDelta   = 'saxy',

  1002     kEventParamMouseWheelSmoothHorizontalDelta = 'saxx',

  1003 };

  1004 #endif

  1005 

  1006 /* watched events */

  1007 static EventTypeSpec app_events[] = {

  1008     { kEventClassQt, kEventQtRequestWindowChange },

  1009     { kEventClassQt, kEventQtRequestShowSheet },

  1010     { kEventClassQt, kEventQtRequestContext },

  1011     { kEventClassQt, kEventQtRequestActivate },

  1012     { kEventClassQt, kEventQtRequestMenubarUpdate },

  1013 

  1014     { kEventClassWindow, kEventWindowActivated },

  1015     { kEventClassWindow, kEventWindowDeactivated },

  1016 

  1017     { kEventClassMouse, kEventMouseScroll },

  1018     { kEventClassMouse, kEventMouseWheelMoved },

  1019     { kEventClassMouse, kEventMouseDown },

  1020     { kEventClassMouse, kEventMouseUp },

  1021     { kEventClassMouse, kEventMouseDragged },

  1022     { kEventClassMouse, kEventMouseMoved },

  1023 

  1024     { kEventClassTablet, kEventTabletProximity },

  1025 

  1026     { kEventClassApplication, kEventAppActivated },

  1027     { kEventClassApplication, kEventAppDeactivated },

  1028     { kEventClassApplication, kEventAppAvailableWindowBoundsChanged },

  1029 

  1030     //    { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },

  1031     { kEventClassKeyboard, kEventRawKeyModifiersChanged },

  1032     { kEventClassKeyboard, kEventRawKeyRepeat },

  1033     { kEventClassKeyboard, kEventRawKeyUp },

  1034     { kEventClassKeyboard, kEventRawKeyDown },

  1035 

  1036     { kEventClassCommand, kEventCommandProcess },

  1037 

  1038     { kEventClassAppleEvent, kEventAppleEvent },

  1039 

  1040     { kAppearanceEventClass, kAEAppearanceChanged }

  1041 };

  1042 

  1043 void qt_init_app_proc_handler()

  1044 {

  1045     InstallEventHandler(GetApplicationEventTarget(), app_proc_handlerUPP,

  1046                         GetEventTypeCount(app_events), app_events, (void *)qApp,

  1047                         &app_proc_handler);

  1048 }

  1049 #endif // QT_MAC_USE_COCOA

  1050 

  1051 static void qt_init_tablet_proximity_handler()

  1052 {

  1053     EventTypeSpec	tabletProximityEvent = { kEventClassTablet, kEventTabletProximity };

  1054     InstallEventHandler(GetEventMonitorTarget(), tablet_proximity_UPP,

  1055                         1, &tabletProximityEvent, qApp, &tablet_proximity_handler);

  1056 }

  1057 

  1058 static void qt_release_tablet_proximity_handler()

  1059 {

  1060     RemoveEventHandler(tablet_proximity_handler);

  1061 }

  1062 

  1063 QString QApplicationPrivate::appName() const

  1064 {

  1065     static QString applName;

  1066     if (applName.isEmpty()) {

  1067         applName = QCoreApplicationPrivate::macMenuBarName();

  1068         ProcessSerialNumber psn;

  1069         if (applName.isEmpty() && qt_is_gui_used && GetCurrentProcess(&psn) == noErr) {

  1070             QCFString cfstr;

  1071             CopyProcessName(&psn, &cfstr);

  1072             applName = cfstr;

  1073         }

  1074     }

  1075     return applName;

  1076 }

  1077 

  1078 void qt_release_app_proc_handler()

  1079 {

  1080 #ifndef QT_MAC_USE_COCOA

  1081     if (app_proc_handler) {

  1082         RemoveEventHandler(app_proc_handler);

  1083         app_proc_handler = 0;

  1084     }

  1085 #endif

  1086 }

  1087 

  1088 void qt_color_profile_changed(CFNotificationCenterRef, void *, CFStringRef, const void *,

  1089                               CFDictionaryRef)

  1090 {

  1091     QCoreGraphicsPaintEngine::cleanUpMacColorSpaces();

  1092 }

  1093 /* platform specific implementations */

  1094 void qt_init(QApplicationPrivate *priv, int)

  1095 {

  1096     if (qt_is_gui_used) {

  1097         CGDisplayRegisterReconfigurationCallback(qt_mac_display_change_callbk, 0);

  1098         CFNotificationCenterRef center = CFNotificationCenterGetDistributedCenter();

  1099         CFNotificationCenterAddObserver(center, qApp, qt_color_profile_changed,

  1100                                         kCMDeviceUnregisteredNotification, 0,

  1101                                         CFNotificationSuspensionBehaviorDeliverImmediately);

  1102         CFNotificationCenterAddObserver(center, qApp, qt_color_profile_changed,

  1103                                         kCMDefaultDeviceNotification, 0,

  1104                                         CFNotificationSuspensionBehaviorDeliverImmediately);

  1105         CFNotificationCenterAddObserver(center, qApp, qt_color_profile_changed,

  1106                                         kCMDeviceProfilesNotification, 0,

  1107                                         CFNotificationSuspensionBehaviorDeliverImmediately);

  1108         CFNotificationCenterAddObserver(center, qApp, qt_color_profile_changed,

  1109                                         kCMDefaultDeviceProfileNotification, 0,

  1110                                         CFNotificationSuspensionBehaviorDeliverImmediately);

  1111         ProcessSerialNumber psn;

  1112         if (GetCurrentProcess(&psn) == noErr) {

  1113             // Jambi needs to transform itself since most people aren't "used"

  1114             // to putting things in bundles, but other people may actually not

  1115             // want to tranform the process (running as a helper or something)

  1116             // so don't do that for them. This means checking both LSUIElement

  1117             // and LSBackgroundOnly. If you set them both... well, you

  1118             // shouldn't do that.

  1119 

  1120             bool forceTransform = true;

  1121             CFTypeRef value = CFBundleGetValueForInfoDictionaryKey(CFBundleGetMainBundle(),

  1122                                                                    CFSTR("LSUIElement"));

  1123             if (value) {

  1124                 CFTypeID valueType = CFGetTypeID(value);

  1125                 // Officially it's supposed to be a string, a boolean makes sense, so we'll check.

  1126                 // A number less so, but OK.

  1127                 if (valueType == CFStringGetTypeID())

  1128                     forceTransform = !(QCFString::toQString(static_cast<CFStringRef>(value)).toInt());

  1129                 else if (valueType == CFBooleanGetTypeID())

  1130                     forceTransform = !CFBooleanGetValue(static_cast<CFBooleanRef>(value));

  1131                 else if (valueType == CFNumberGetTypeID()) {

  1132                     int valueAsInt;

  1133                     CFNumberGetValue(static_cast<CFNumberRef>(value), kCFNumberIntType, &valueAsInt);

  1134                     forceTransform = !valueAsInt;

  1135                 }