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

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

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

**

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

**

** All rights reserved.

**

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

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

**

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

**     this list of conditions and the following disclaimer.

**

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

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

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

**

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

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

**     without specific prior written permission.

**

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

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

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

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

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

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

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

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

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

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

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

**

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

#include <private/qcore_mac_p.h>

#include <qaction.h>

#include <qwidget.h>

#include <qdesktopwidget.h>

#include <qevent.h>

#include <qpixmapcache.h>

#include <private/qevent_p.h>

#include <private/qt_cocoa_helpers_mac_p.h>

#include <private/qt_mac_p.h>

#include <private/qapplication_p.h>

#include <private/qcocoawindow_mac_p.h>

#include <private/qcocoaview_mac_p.h>

#include <private/qkeymapper_p.h>

#include <private/qwidget_p.h>

QT_BEGIN_NAMESPACE

Q_GLOBAL_STATIC(QMacWindowFader, macwindowFader);

QMacWindowFader::QMacWindowFader()

    : m_duration(0.250)

{

}

QMacWindowFader *QMacWindowFader::currentFader()

{

    return macwindowFader();

}

void QMacWindowFader::registerWindowToFade(QWidget *window)

{

    m_windowsToFade.append(window);

}

void QMacWindowFader::performFade()

{

    const QWidgetList myWidgetsToFade = m_windowsToFade;

    const int widgetCount = myWidgetsToFade.count();

#if QT_MAC_USE_COCOA

    QMacCocoaAutoReleasePool pool;

    [NSAnimationContext beginGrouping];

    [[NSAnimationContext currentContext] setDuration:NSTimeInterval(m_duration)];

#endif

    for (int i = 0; i < widgetCount; ++i) {

        QWidget *widget = m_windowsToFade.at(i);

        OSWindowRef window = qt_mac_window_for(widget);

#if QT_MAC_USE_COCOA

        [[window animator] setAlphaValue:0.0];

        QTimer::singleShot(qRound(m_duration * 1000), widget, SLOT(hide()));

#else

        TransitionWindowOptions options = {0, m_duration, 0, 0};

        TransitionWindowWithOptions(window, kWindowFadeTransitionEffect, kWindowHideTransitionAction,

                                    0, 1, &options);

#endif

    }

#if QT_MAC_USE_COCOA

    [NSAnimationContext endGrouping];

#endif

    m_duration = 0.250;

    m_windowsToFade.clear();

}

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

extern Qt::MouseButton cocoaButton2QtButton(NSInteger buttonNum); // qcocoaview.mm

extern QWidget * mac_mouse_grabber;

void macWindowFade(void * /*OSWindowRef*/ window, float durationSeconds)

{

    OSWindowRef wnd = static_cast<OSWindowRef>(window);

    if (wnd) {

        QWidget *widget;

#if QT_MAC_USE_COCOA

        widget = [wnd QT_MANGLE_NAMESPACE(qt_qwidget)];

#else

    const UInt32 kWidgetCreatorQt = kEventClassQt;

    enum {

        kWidgetPropertyQWidget = 'QWId' //QWidget *

    };

        if (GetWindowProperty(static_cast<WindowRef>(window), kWidgetCreatorQt, kWidgetPropertyQWidget, sizeof(widget), 0, &widget) != noErr)

            widget = 0;

#endif

        if (widget) {

            QMacWindowFader::currentFader()->setFadeDuration(durationSeconds);

            QMacWindowFader::currentFader()->registerWindowToFade(widget);

            QMacWindowFader::currentFader()->performFade();

        }

    }

}

bool macWindowIsTextured( void * /*OSWindowRef*/ window )

{

    OSWindowRef wnd = static_cast<OSWindowRef>(window);

#if QT_MAC_USE_COCOA

	return ( [wnd styleMask] & NSTexturedBackgroundWindowMask ) ? true : false;

#else

	WindowAttributes currentAttributes;

	GetWindowAttributes(wnd, &currentAttributes);

	return (currentAttributes & kWindowMetalAttribute) ? true : false;

#endif

}

void macWindowToolbarShow(const QWidget *widget, bool show )

{

    OSWindowRef wnd = qt_mac_window_for(widget);

#if QT_MAC_USE_COCOA

    if (NSToolbar *toolbar = [wnd toolbar]) {

        QMacCocoaAutoReleasePool pool;

        if (show != [toolbar isVisible]) {

           [toolbar setVisible:show];

        } else {

            // The toolbar may be in sync, but we are not, update our framestrut.

            qt_widget_private(const_cast<QWidget *>(widget))->updateFrameStrut();

        }

    }

#else

    ShowHideWindowToolbar(wnd, show, false);

#endif

}

void macWindowToolbarSet( void * /*OSWindowRef*/ window, void *toolbarRef  )

{

    OSWindowRef wnd = static_cast<OSWindowRef>(window);

#if QT_MAC_USE_COCOA

    [wnd setToolbar:static_cast<NSToolbar *>(toolbarRef)];

#else

    SetWindowToolbar(wnd, static_cast<HIToolbarRef>(toolbarRef));

#endif

}

bool macWindowToolbarIsVisible( void * /*OSWindowRef*/ window )

{

    OSWindowRef wnd = static_cast<OSWindowRef>(window);

#if QT_MAC_USE_COCOA

    if (NSToolbar *toolbar = [wnd toolbar])

        return [toolbar isVisible];

    return false;

#else

    return IsWindowToolbarVisible(wnd);

#endif

}

void macWindowSetHasShadow( void * /*OSWindowRef*/ window, bool hasShadow  )

{

    OSWindowRef wnd = static_cast<OSWindowRef>(window);

#if QT_MAC_USE_COCOA

    [wnd setHasShadow:BOOL(hasShadow)];

#else

    if (hasShadow)

        ChangeWindowAttributes(wnd, 0, kWindowNoShadowAttribute);

    else

        ChangeWindowAttributes(wnd, kWindowNoShadowAttribute, 0);

#endif

}

void macWindowFlush(void * /*OSWindowRef*/ window)

{

    OSWindowRef wnd = static_cast<OSWindowRef>(window);

#if QT_MAC_USE_COCOA

    [wnd flushWindowIfNeeded];

#else

    HIWindowFlush(wnd);

#endif

}

void * /*NSImage */qt_mac_create_nsimage(const QPixmap &pm)

{

    QMacCocoaAutoReleasePool pool;

    if(QCFType<CGImageRef> image = pm.toMacCGImageRef()) {

        NSImage *newImage = 0;

        NSRect imageRect = NSMakeRect(0.0, 0.0, CGImageGetWidth(image), CGImageGetHeight(image));

        newImage = [[NSImage alloc] initWithSize:imageRect.size];

        [newImage lockFocus];

        {

            CGContextRef imageContext = (CGContextRef)[[NSGraphicsContext currentContext] graphicsPort];

            CGContextDrawImage(imageContext, *(CGRect*)&imageRect, image);

        }

        [newImage unlockFocus];

        return newImage;

    }

    return 0;

}

void qt_mac_update_mouseTracking(QWidget *widget)

{

#ifdef QT_MAC_USE_COCOA

    [qt_mac_nativeview_for(widget) updateTrackingAreas];

#else

    Q_UNUSED(widget);

#endif

}

OSStatus qt_mac_drawCGImage(CGContextRef inContext, const CGRect *inBounds, CGImageRef inImage)

{

    // Verbatim copy if HIViewDrawCGImage (as shown on Carbon-Dev)

    OSStatus err = noErr;

    require_action(inContext != NULL, InvalidContext, err = paramErr);

    require_action(inBounds != NULL, InvalidBounds, err = paramErr);

    require_action(inImage != NULL, InvalidImage, err = paramErr);

    CGContextSaveGState( inContext );

    CGContextTranslateCTM (inContext, 0, inBounds->origin.y + CGRectGetMaxY(*inBounds));

    CGContextScaleCTM(inContext, 1, -1);

    CGContextDrawImage(inContext, *inBounds, inImage);

    CGContextRestoreGState(inContext);

InvalidImage:

InvalidBounds:

InvalidContext:

	return err;

}

bool qt_mac_checkForNativeSizeGrip(const QWidget *widget)

{

#ifndef QT_MAC_USE_COCOA

    OSViewRef nativeSizeGrip = 0;

    HIViewFindByID(HIViewGetRoot(HIViewGetWindow(HIViewRef(widget->winId()))), kHIViewWindowGrowBoxID, &nativeSizeGrip);

    return (nativeSizeGrip != 0);

#else

    return [[reinterpret_cast<NSView *>(widget->winId()) window] showsResizeIndicator];

#endif

}

struct qt_mac_enum_mapper

{

    int mac_code;

    int qt_code;

#if defined(DEBUG_MOUSE_MAPS)

#   define QT_MAC_MAP_ENUM(x) x, #x

    const char *desc;

#else

#   define QT_MAC_MAP_ENUM(x) x

#endif

};

//mouse buttons

static qt_mac_enum_mapper qt_mac_mouse_symbols[] = {

{ kEventMouseButtonPrimary, QT_MAC_MAP_ENUM(Qt::LeftButton) },

{ kEventMouseButtonSecondary, QT_MAC_MAP_ENUM(Qt::RightButton) },

{ kEventMouseButtonTertiary, QT_MAC_MAP_ENUM(Qt::MidButton) },

{ 4, QT_MAC_MAP_ENUM(Qt::XButton1) },

{ 5, QT_MAC_MAP_ENUM(Qt::XButton2) },

{ 0, QT_MAC_MAP_ENUM(0) }

};

Qt::MouseButtons qt_mac_get_buttons(int buttons)

{

#ifdef DEBUG_MOUSE_MAPS

    qDebug("Qt: internal: **Mapping buttons: %d (0x%04x)", buttons, buttons);

#endif

    Qt::MouseButtons ret = Qt::NoButton;

    for(int i = 0; qt_mac_mouse_symbols[i].qt_code; i++) {

        if (buttons & (0x01<<(qt_mac_mouse_symbols[i].mac_code-1))) {

#ifdef DEBUG_MOUSE_MAPS

            qDebug("Qt: internal: got button: %s", qt_mac_mouse_symbols[i].desc);

#endif

            ret |= Qt::MouseButtons(qt_mac_mouse_symbols[i].qt_code);

        }

    }

    return ret;

}

Qt::MouseButton qt_mac_get_button(EventMouseButton button)

{

#ifdef DEBUG_MOUSE_MAPS

    qDebug("Qt: internal: **Mapping button: %d (0x%04x)", button, button);

#endif

    Qt::MouseButtons ret = 0;

    for(int i = 0; qt_mac_mouse_symbols[i].qt_code; i++) {

        if (button == qt_mac_mouse_symbols[i].mac_code) {

#ifdef DEBUG_MOUSE_MAPS

            qDebug("Qt: internal: got button: %s", qt_mac_mouse_symbols[i].desc);

#endif

            return Qt::MouseButton(qt_mac_mouse_symbols[i].qt_code);

        }

    }

    return Qt::NoButton;

}

void macSendToolbarChangeEvent(QWidget *widget)

{

    QToolBarChangeEvent ev(!(GetCurrentKeyModifiers() & cmdKey));

    qt_sendSpontaneousEvent(widget, &ev);

}

Q_GLOBAL_STATIC(QMacTabletHash, tablet_hash)

QMacTabletHash *qt_mac_tablet_hash()

{

    return tablet_hash();

}

#ifdef QT_MAC_USE_COCOA

void qt_dispatchTabletProximityEvent(void * /*NSEvent * */ tabletEvent)

{

    NSEvent *proximityEvent = static_cast<NSEvent *>(tabletEvent);

    // simply construct a Carbon proximity record and handle it all in one spot.

    TabletProximityRec carbonProximityRec = { [proximityEvent vendorID],

                                              [proximityEvent tabletID],

                                              [proximityEvent pointingDeviceID],

                                              [proximityEvent deviceID],

                                              [proximityEvent systemTabletID],

                                              [proximityEvent vendorPointingDeviceType],

                                              [proximityEvent pointingDeviceSerialNumber],

                                              [proximityEvent uniqueID],

                                              [proximityEvent capabilityMask],

                                              [proximityEvent pointingDeviceType],

                                              [proximityEvent isEnteringProximity] };

    qt_dispatchTabletProximityEvent(carbonProximityRec);

}

#endif // QT_MAC_USE_COCOA

void qt_dispatchTabletProximityEvent(const ::TabletProximityRec &proxRec)

{

    QTabletDeviceData proximityDevice;

    proximityDevice.tabletUniqueID = proxRec.uniqueID;

    proximityDevice.capabilityMask = proxRec.capabilityMask;

    switch (proxRec.pointerType) {

        case NSUnknownPointingDevice:

        default:

            proximityDevice.tabletPointerType = QTabletEvent::UnknownPointer;

            break;

        case NSPenPointingDevice:

            proximityDevice.tabletPointerType = QTabletEvent::Pen;

            break;

        case NSCursorPointingDevice:

            proximityDevice.tabletPointerType = QTabletEvent::Cursor;

            break;

        case NSEraserPointingDevice:

            proximityDevice.tabletPointerType = QTabletEvent::Eraser;

            break;

    }

    uint bits = proxRec.vendorPointerType;

    if (bits == 0 && proximityDevice.tabletUniqueID != 0) {

        // Fallback. It seems that the driver doesn't always include all the information.

        // High-End Wacom devices store their "type" in the uper bits of the Unique ID.

        // I'm not sure how to handle it for consumer devices, but I'll test that in a bit.

        bits = proximityDevice.tabletUniqueID >> 32;

    }

    // Defined in the "EN0056-NxtGenImpGuideX"

    // on Wacom's Developer Website (www.wacomeng.com)

    if (((bits & 0x0006) == 0x0002) && ((bits & 0x0F06) != 0x0902)) {

        proximityDevice.tabletDeviceType = QTabletEvent::Stylus;

    } else {

        switch (bits & 0x0F06) {

            case 0x0802:

                proximityDevice.tabletDeviceType = QTabletEvent::Stylus;

                break;

            case 0x0902:

                proximityDevice.tabletDeviceType = QTabletEvent::Airbrush;

                break;

            case 0x0004:

                proximityDevice.tabletDeviceType = QTabletEvent::FourDMouse;

                break;

            case 0x0006:

                proximityDevice.tabletDeviceType = QTabletEvent::Puck;

                break;

            case 0x0804:

                proximityDevice.tabletDeviceType = QTabletEvent::RotationStylus;

                break;

            default:

                proximityDevice.tabletDeviceType = QTabletEvent::NoDevice;

        }

    }

    // The deviceID is "unique" while in the proximity, it's a key that we can use for

    // linking up TabletDeviceData to an event (especially if there are two devices in action).

    bool entering = proxRec.enterProximity;

    if (entering) {

        qt_mac_tablet_hash()->insert(proxRec.deviceID, proximityDevice);

    } else {

        qt_mac_tablet_hash()->remove(proxRec.deviceID);

    }

    QTabletEvent qtabletProximity(entering ? QEvent::TabletEnterProximity

                                  : QEvent::TabletLeaveProximity,

                                  QPoint(), QPoint(), QPointF(), proximityDevice.tabletDeviceType,

                                  proximityDevice.tabletPointerType, 0., 0, 0, 0., 0., 0, 0,

                                  proximityDevice.tabletUniqueID);

    qt_sendSpontaneousEvent(qApp, &qtabletProximity);

}

#ifdef QT_MAC_USE_COCOA

// Use this method to keep all the information in the TextSegment. As long as it is ordered

// we are in OK shape, and we can influence that ourselves.

struct KeyPair

{

    QChar cocoaKey;

    Qt::Key qtKey;

};

bool operator==(const KeyPair &entry, QChar qchar)

{

    return entry.cocoaKey == qchar;

}

bool operator<(const KeyPair &entry, QChar qchar)

{

    return entry.cocoaKey < qchar;

}

bool operator<(QChar qchar, const KeyPair &entry)

{

    return qchar < entry.cocoaKey;

}

static Qt::Key cocoaKey2QtKey(QChar keyCode)

{

    static const int NumEntries = 57;

    static const KeyPair entries[NumEntries] = {

        { NSEnterCharacter, Qt::Key_Enter },

        { NSTabCharacter, Qt::Key_Tab },

        { NSCarriageReturnCharacter, Qt::Key_Return },

        { NSBackTabCharacter, Qt::Key_Backtab },

        { kEscapeCharCode, Qt::Key_Escape },

        { NSDeleteCharacter, Qt::Key_Backspace },

        { NSUpArrowFunctionKey, Qt::Key_Up },

        { NSDownArrowFunctionKey, Qt::Key_Down },

        { NSLeftArrowFunctionKey, Qt::Key_Left },

        { NSRightArrowFunctionKey, Qt::Key_Right },

        { NSF1FunctionKey, Qt::Key_F1 },

        { NSF2FunctionKey, Qt::Key_F2 },

        { NSF3FunctionKey, Qt::Key_F3 },

        { NSF4FunctionKey, Qt::Key_F4 },

        { NSF5FunctionKey, Qt::Key_F5 },

        { NSF6FunctionKey, Qt::Key_F6 },

        { NSF7FunctionKey, Qt::Key_F7 },

        { NSF8FunctionKey, Qt::Key_F8 },

        { NSF9FunctionKey, Qt::Key_F8 },

        { NSF10FunctionKey, Qt::Key_F10 },

        { NSF11FunctionKey, Qt::Key_F11 },

        { NSF12FunctionKey, Qt::Key_F12 },

        { NSF13FunctionKey, Qt::Key_F13 },

        { NSF14FunctionKey, Qt::Key_F14 },

        { NSF15FunctionKey, Qt::Key_F15 },

        { NSF16FunctionKey, Qt::Key_F16 },

        { NSF17FunctionKey, Qt::Key_F17 },

        { NSF18FunctionKey, Qt::Key_F18 },

        { NSF19FunctionKey, Qt::Key_F19 },

        { NSF20FunctionKey, Qt::Key_F20 },

        { NSF21FunctionKey, Qt::Key_F21 },

        { NSF22FunctionKey, Qt::Key_F22 },

        { NSF23FunctionKey, Qt::Key_F23 },

        { NSF24FunctionKey, Qt::Key_F24 },

        { NSF25FunctionKey, Qt::Key_F25 },

        { NSF26FunctionKey, Qt::Key_F26 },

        { NSF27FunctionKey, Qt::Key_F27 },

        { NSF28FunctionKey, Qt::Key_F28 },

        { NSF29FunctionKey, Qt::Key_F29 },

        { NSF30FunctionKey, Qt::Key_F30 },

        { NSF31FunctionKey, Qt::Key_F31 },

        { NSF32FunctionKey, Qt::Key_F32 },

        { NSF33FunctionKey, Qt::Key_F33 },