/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

/****************************************************************************

**

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

**

** All rights reserved.

**

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

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

**

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

**     this list of conditions and the following disclaimer.

**

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

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

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

**

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

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

**     without specific prior written permission.

**

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

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

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

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

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

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

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

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

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

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

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

**

****************************************************************************/

#include "qplatformdefs.h"

#include "private/qt_mac_p.h"

#include "qeventdispatcher_mac_p.h"

#include "qapplication.h"

#include "qevent.h"

#include "qdialog.h"

#include "qhash.h"

#include "qsocketnotifier.h"

#include "private/qwidget_p.h"

#include "private/qthread_p.h"

#include "private/qapplication_p.h"

#include <private/qcocoaapplication_mac_p.h>

#include "private/qt_cocoa_helpers_mac_p.h"

#ifndef QT_NO_THREAD

#  include "qmutex.h"

#endif

QT_BEGIN_NAMESPACE

QT_USE_NAMESPACE

/*****************************************************************************

  Externals

 *****************************************************************************/

extern void qt_event_request_timer(MacTimerInfo *); //qapplication_mac.cpp

extern MacTimerInfo *qt_event_get_timer(EventRef); //qapplication_mac.cpp

extern void qt_event_request_select(QEventDispatcherMac *); //qapplication_mac.cpp

extern void qt_event_request_updates(); //qapplication_mac.cpp

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

extern bool qt_is_gui_used; //qapplication.cpp

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

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

static inline CFRunLoopRef mainRunLoop()

{

#ifndef QT_MAC_USE_COCOA

    return reinterpret_cast<CFRunLoopRef>(const_cast<void *>(GetCFRunLoopFromEventLoop(GetMainEventLoop())));

#else

    return CFRunLoopGetMain();

#endif

}

/*****************************************************************************

  Timers stuff

 *****************************************************************************/

/* timer call back */

void QEventDispatcherMacPrivate::activateTimer(CFRunLoopTimerRef, void *info)

{

    int timerID =

#ifdef Q_OS_MAC64

    qint64(info);

#else

    int(info);

#endif

    MacTimerInfo *tmr;

    tmr = macTimerHash.value(timerID);

    if (tmr == 0 || tmr->pending == true)

        return; // Can't send another timer event if it's pending.

    if (blockSendPostedEvents) {

        QCoreApplication::postEvent(tmr->obj, new QTimerEvent(tmr->id));

    } else {

        tmr->pending = true;

        QTimerEvent e(tmr->id);

        qt_sendSpontaneousEvent(tmr->obj, &e);

        // Get the value again in case the timer gets unregistered during the sendEvent.

        tmr = macTimerHash.value(timerID);

        if (tmr != 0)

            tmr->pending = false;

    }

}

void QEventDispatcherMac::registerTimer(int timerId, int interval, QObject *obj)

{

#ifndef QT_NO_DEBUG

    if (timerId < 1 || interval < 0 || !obj) {

        qWarning("QEventDispatcherMac::registerTimer: invalid arguments");

        return;

    } else if (obj->thread() != thread() || thread() != QThread::currentThread()) {

        qWarning("QObject::startTimer: timers cannot be started from another thread");

        return;

    }

#endif

    MacTimerInfo *t = new MacTimerInfo();

    t->id = timerId;

    t->interval = interval;

    t->obj = obj;

    t->runLoopTimer = 0;

    t->pending = false;

    CFAbsoluteTime fireDate = CFAbsoluteTimeGetCurrent();

    CFTimeInterval cfinterval = qMax(CFTimeInterval(interval) / 1000, 0.0000001);

    fireDate += cfinterval;

    QEventDispatcherMacPrivate::macTimerHash.insert(timerId, t);

    CFRunLoopTimerContext info = { 0, (void *)timerId, 0, 0, 0 };

    t->runLoopTimer = CFRunLoopTimerCreate(0, fireDate, cfinterval, 0, 0,

                                           QEventDispatcherMacPrivate::activateTimer, &info);

    if (t->runLoopTimer == 0) {

        qFatal("QEventDispatcherMac::registerTimer: Cannot create timer");

    }

    CFRunLoopAddTimer(mainRunLoop(), t->runLoopTimer, kCFRunLoopCommonModes);

}

bool QEventDispatcherMac::unregisterTimer(int identifier)

{

#ifndef QT_NO_DEBUG

    if (identifier < 1) {

        qWarning("QEventDispatcherMac::unregisterTimer: invalid argument");

        return false;

    } else if (thread() != QThread::currentThread()) {

        qWarning("QObject::killTimer: timers cannot be stopped from another thread");

        return false;

    }

#endif

    if (identifier <= 0)

        return false;                                // not init'd or invalid timer

    MacTimerInfo *timerInfo = QEventDispatcherMacPrivate::macTimerHash.take(identifier);

    if (timerInfo == 0)

        return false;

    if (!QObjectPrivate::get(timerInfo->obj)->inThreadChangeEvent)

        QAbstractEventDispatcherPrivate::releaseTimerId(identifier);

    CFRunLoopTimerInvalidate(timerInfo->runLoopTimer);

    CFRelease(timerInfo->runLoopTimer);

    delete timerInfo;

    return true;

}

bool QEventDispatcherMac::unregisterTimers(QObject *obj)

{

#ifndef QT_NO_DEBUG

    if (!obj) {

        qWarning("QEventDispatcherMac::unregisterTimers: invalid argument");

        return false;

    } else if (obj->thread() != thread() || thread() != QThread::currentThread()) {

        qWarning("QObject::killTimers: timers cannot be stopped from another thread");

        return false;

    }

#endif

    MacTimerHash::iterator it = QEventDispatcherMacPrivate::macTimerHash.begin();

    while (it != QEventDispatcherMacPrivate::macTimerHash.end()) {

        MacTimerInfo *timerInfo = it.value();

        if (timerInfo->obj != obj) {

            ++it;

        } else {

            if (!QObjectPrivate::get(timerInfo->obj)->inThreadChangeEvent)

                QAbstractEventDispatcherPrivate::releaseTimerId(timerInfo->id);

            CFRunLoopTimerInvalidate(timerInfo->runLoopTimer);

            CFRelease(timerInfo->runLoopTimer);

            delete timerInfo;

            it = QEventDispatcherMacPrivate::macTimerHash.erase(it);

        }

    }

    return true;

}

QList<QEventDispatcherMac::TimerInfo>

QEventDispatcherMac::registeredTimers(QObject *object) const

{

    if (!object) {

        qWarning("QEventDispatcherMac:registeredTimers: invalid argument");

        return QList<TimerInfo>();

    }

    QList<TimerInfo> list;

    MacTimerHash::const_iterator it = QEventDispatcherMacPrivate::macTimerHash.constBegin();

    while (it != QEventDispatcherMacPrivate::macTimerHash.constEnd()) {

        MacTimerInfo *t = it.value();

        if (t->obj == object)

            list << TimerInfo(t->id, t->interval);

        ++it;

    }

    return list;

}

/**************************************************************************

    Socket Notifiers

 *************************************************************************/

void qt_mac_socket_callback(CFSocketRef s, CFSocketCallBackType callbackType, CFDataRef,

                            const void *,  void *info) {

    QEventDispatcherMacPrivate *const eventDispatcher

                                    = static_cast<QEventDispatcherMacPrivate *>(info);

    int nativeSocket = CFSocketGetNative(s);

    MacSocketInfo *socketInfo = eventDispatcher->macSockets.value(nativeSocket);

    QEvent notifierEvent(QEvent::SockAct);

    // There is a race condition that happen where we disable the notifier and

    // the kernel still has a notification to pass on. We then get this

    // notification after we've successfully disabled the CFSocket, but our Qt

    // notifier is now gone. The upshot is we have to check the notifier

    // everytime.

    if (callbackType == kCFSocketReadCallBack) {

        if (socketInfo->readNotifier)

            QApplication::sendEvent(socketInfo->readNotifier, &notifierEvent);

    } else if (callbackType == kCFSocketWriteCallBack) {

        if (socketInfo->writeNotifier)

            QApplication::sendEvent(socketInfo->writeNotifier, &notifierEvent);

    }

}

/*

    Adds a loop source for the given socket to the current run loop.

*/

CFRunLoopSourceRef qt_mac_add_socket_to_runloop(const CFSocketRef socket)

{

    CFRunLoopSourceRef loopSource = CFSocketCreateRunLoopSource(kCFAllocatorDefault, socket, 0);

    if (!loopSource)

        return 0;

    CFRunLoopAddSource(mainRunLoop(), loopSource, kCFRunLoopCommonModes);

    return loopSource;

}

/*

    Removes the loop source for the given socket from the current run loop.

*/

void qt_mac_remove_socket_from_runloop(const CFSocketRef socket, CFRunLoopSourceRef runloop)

{

    Q_ASSERT(runloop);

    CFRunLoopRemoveSource(mainRunLoop(), runloop, kCFRunLoopCommonModes);

    CFSocketDisableCallBacks(socket, kCFSocketReadCallBack);

    CFSocketDisableCallBacks(socket, kCFSocketWriteCallBack);

    CFRunLoopSourceInvalidate(runloop);

}

/*

    Register a QSocketNotifier with the mac event system by creating a CFSocket with

    with a read/write callback.

    Qt has separate socket notifiers for reading and writing, but on the mac there is

    a limitation of one CFSocket object for each native socket.

*/

void QEventDispatcherMac::registerSocketNotifier(QSocketNotifier *notifier)

{

    Q_ASSERT(notifier);

    int nativeSocket = notifier->socket();

    int type = notifier->type();

#ifndef QT_NO_DEBUG

    if (nativeSocket < 0 || nativeSocket > FD_SETSIZE) {

        qWarning("QSocketNotifier: Internal error");

        return;

    } else if (notifier->thread() != thread()

               || thread() != QThread::currentThread()) {

        qWarning("QSocketNotifier: socket notifiers cannot be enabled from another thread");

        return;

    }

#endif

    Q_D(QEventDispatcherMac);

    if (type == QSocketNotifier::Exception) {

        qWarning("QSocketNotifier::Exception is not supported on Mac OS X");

        return;

    }

    // Check if we have a CFSocket for the native socket, create one if not.

    MacSocketInfo *socketInfo = d->macSockets.value(nativeSocket);

    if (!socketInfo) {

        socketInfo = new MacSocketInfo();

        // Create CFSocket, specify that we want both read and write callbacks (the callbacks

        // are enabled/disabled later on).

        const int callbackTypes = kCFSocketReadCallBack | kCFSocketWriteCallBack;

        CFSocketContext context = {0, d, 0, 0, 0};

        socketInfo->socket = CFSocketCreateWithNative(kCFAllocatorDefault, nativeSocket, callbackTypes, qt_mac_socket_callback, &context);

        if (CFSocketIsValid(socketInfo->socket) == false) {

            qWarning("QEventDispatcherMac::registerSocketNotifier: Failed to create CFSocket");

            return;

        }

        CFOptionFlags flags = CFSocketGetSocketFlags(socketInfo->socket);

        flags |= kCFSocketAutomaticallyReenableWriteCallBack; //QSocketNotifier stays enabled after a write

        flags &= ~kCFSocketCloseOnInvalidate; //QSocketNotifier doesn't close the socket upon destruction/invalidation

        CFSocketSetSocketFlags(socketInfo->socket, flags);

        // Add CFSocket to runloop.

        if(!(socketInfo->runloop = qt_mac_add_socket_to_runloop(socketInfo->socket))) {

            qWarning("QEventDispatcherMac::registerSocketNotifier: Failed to add CFSocket to runloop");

            CFSocketInvalidate(socketInfo->socket);

            CFRelease(socketInfo->socket);

            return;

        }

        // Disable both callback types by default. This must be done after

        // we add the CFSocket to the runloop, or else these calls will have

        // no effect.

        CFSocketDisableCallBacks(socketInfo->socket, kCFSocketReadCallBack);

        CFSocketDisableCallBacks(socketInfo->socket, kCFSocketWriteCallBack);

        d->macSockets.insert(nativeSocket, socketInfo);

    }

    // Increment read/write counters and select enable callbacks if necessary.

    if (type == QSocketNotifier::Read) {

        Q_ASSERT(socketInfo->readNotifier == 0);

        socketInfo->readNotifier = notifier;

        CFSocketEnableCallBacks(socketInfo->socket, kCFSocketReadCallBack);

    } else if (type == QSocketNotifier::Write) {

        Q_ASSERT(socketInfo->writeNotifier == 0);

        socketInfo->writeNotifier = notifier;

        CFSocketEnableCallBacks(socketInfo->socket, kCFSocketWriteCallBack);

    }

}

/*

    Unregister QSocketNotifer. The CFSocket correspoding to this notifier is

    removed from the runloop of this is the last notifier that users

    that CFSocket.

*/

void QEventDispatcherMac::unregisterSocketNotifier(QSocketNotifier *notifier)

{

    Q_ASSERT(notifier);

    int nativeSocket = notifier->socket();

    int type = notifier->type();

#ifndef QT_NO_DEBUG

    if (nativeSocket < 0 || nativeSocket > FD_SETSIZE) {

        qWarning("QSocketNotifier: Internal error");

        return;

    } else if (notifier->thread() != thread() || thread() != QThread::currentThread()) {

        qWarning("QSocketNotifier: socket notifiers cannot be disabled from another thread");

        return;

    }

#endif

    Q_D(QEventDispatcherMac);

    if (type == QSocketNotifier::Exception) {

        qWarning("QSocketNotifier::Exception is not supported on Mac OS X");

        return;

    }

    MacSocketInfo *socketInfo = d->macSockets.value(nativeSocket);

    if (!socketInfo) {

        qWarning("QEventDispatcherMac::unregisterSocketNotifier: Tried to unregister a not registered notifier");

        return;

    }

    // Decrement read/write counters and disable callbacks if necessary.

    if (type == QSocketNotifier::Read) {

        Q_ASSERT(notifier == socketInfo->readNotifier);

        socketInfo->readNotifier = 0;

        CFSocketDisableCallBacks(socketInfo->socket, kCFSocketReadCallBack);

    } else if (type == QSocketNotifier::Write) {

        Q_ASSERT(notifier == socketInfo->writeNotifier);

        socketInfo->writeNotifier = 0;

        CFSocketDisableCallBacks(socketInfo->socket, kCFSocketWriteCallBack);

    }

    // Remove CFSocket from runloop if this was the last QSocketNotifier.

    if (socketInfo->readNotifier == 0 && socketInfo->writeNotifier == 0) {

        if (CFSocketIsValid(socketInfo->socket))

            qt_mac_remove_socket_from_runloop(socketInfo->socket, socketInfo->runloop);

        CFRunLoopSourceInvalidate(socketInfo->runloop);

        CFRelease(socketInfo->runloop);

        CFSocketInvalidate(socketInfo->socket);

        CFRelease(socketInfo->socket);

        delete socketInfo;

        d->macSockets.remove(nativeSocket);

    }

}

bool QEventDispatcherMac::hasPendingEvents()

{

    extern uint qGlobalPostedEventsCount();

    return qGlobalPostedEventsCount() || (qt_is_gui_used && GetNumEventsInQueue(GetMainEventQueue()));

}

static bool qt_mac_send_event(QEventLoop::ProcessEventsFlags, OSEventRef event, OSWindowRef pt)

{

#ifndef QT_MAC_USE_COCOA

    if(pt && SendEventToWindow(event, pt) != eventNotHandledErr)

        return true;

    return !SendEventToEventTarget(event, GetEventDispatcherTarget());

#else // QT_MAC_USE_COCOA

    if (pt)

        [pt sendEvent:event];

    else

        [NSApp sendEvent:event];

    return true;

#endif

}

#ifdef QT_MAC_USE_COCOA

static bool IsMouseOrKeyEvent( NSEvent* event )

{

    bool    result    = false;

    switch( [event type] )

    {

        case NSLeftMouseDown:              

        case NSLeftMouseUp:      

        case NSRightMouseDown:   

        case NSRightMouseUp:     

        case NSMouseMoved:                // ??

        case NSLeftMouseDragged: 

        case NSRightMouseDragged:

        case NSMouseEntered:     

        case NSMouseExited:      

        case NSKeyDown:          

        case NSKeyUp:            

        case NSFlagsChanged:            // key modifiers changed?

        case NSCursorUpdate:            // ??

        case NSScrollWheel:      

        case NSTabletPoint:      

        case NSTabletProximity:  

        case NSOtherMouseDown:   

        case NSOtherMouseUp:     

        case NSOtherMouseDragged:

#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6

        case NSEventTypeGesture: // touch events

        case NSEventTypeMagnify:

        case NSEventTypeSwipe:

        case NSEventTypeRotate:

        case NSEventTypeBeginGesture:

        case NSEventTypeEndGesture:

#endif

            result    = true;

        break;

        default:

        break;

    }

    return result;

}

#endif

static inline void qt_mac_waitForMoreEvents()

{

#ifndef QT_MAC_USE_COCOA

    while (CFRunLoopRunInMode(kCFRunLoopDefaultMode, 1.0e20, true) == kCFRunLoopRunTimedOut) ;

#else

    // If no event exist in the cocoa event que, wait

    // (and free up cpu time) until at least one event occur.

    // This implementation is a bit on the edge, but seems to

    // work fine:

    NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask

        untilDate:[NSDate distantFuture]

        inMode:NSDefaultRunLoopMode

        dequeue:YES];