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

**

** 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$

**

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

#import <private/qcocoaview_mac_p.h>

#ifdef QT_MAC_USE_COCOA

#include <private/qwidget_p.h>

#include <private/qt_mac_p.h>

#include <private/qapplication_p.h>

#include <private/qabstractscrollarea_p.h>

#include <private/qt_cocoa_helpers_mac_p.h>

#include <private/qdnd_p.h>

#include <private/qmacinputcontext_p.h>

#include <private/qmultitouch_mac_p.h>

#include <private/qevent_p.h>

#include <private/qbackingstore_p.h>

#include <qscrollarea.h>

#include <qhash.h>

#include <qtextformat.h>

#include <qpaintengine.h>

#include <QUrl>

#include <QAccessible>

#include <QFileInfo>

#include <QFile>

#include <qdebug.h>

@interface NSEvent (Qt_Compile_Leopard_DeviceDelta)

  - (CGFloat)deviceDeltaX;

  - (CGFloat)deviceDeltaY;

  - (CGFloat)deviceDeltaZ;

@end

@interface NSEvent (Qt_Compile_Leopard_Gestures)

  - (CGFloat)magnification;

@end

QT_BEGIN_NAMESPACE

Q_GLOBAL_STATIC(DnDParams, qMacDnDParams);

extern void qt_mac_update_cursor_at_global_pos(const QPoint &globalPos); // qcursor_mac.mm

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

extern OSViewRef qt_mac_nativeview_for(const QWidget *w); // qwidget_mac.mm

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

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

extern Qt::MouseButton cocoaButton2QtButton(NSInteger buttonNum);

struct dndenum_mapper

{

    NSDragOperation mac_code;

    Qt::DropAction qt_code;

    bool Qt2Mac;

};

static dndenum_mapper dnd_enums[] = {

    { NSDragOperationLink,  Qt::LinkAction, true },

    { NSDragOperationMove,  Qt::MoveAction, true },

    { NSDragOperationCopy,  Qt::CopyAction, true },

    { NSDragOperationGeneric,  Qt::CopyAction, false },

    { NSDragOperationEvery, Qt::ActionMask, false },

    { NSDragOperationNone, Qt::IgnoreAction, false }

};

static NSDragOperation qt_mac_mapDropAction(Qt::DropAction action)

{

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

        if (dnd_enums[i].Qt2Mac && (action & dnd_enums[i].qt_code)) {

            return dnd_enums[i].mac_code;

        }

    }

    return NSDragOperationNone;

}

static NSDragOperation qt_mac_mapDropActions(Qt::DropActions actions)

{

    NSDragOperation nsActions = NSDragOperationNone;

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

        if (dnd_enums[i].Qt2Mac && (actions & dnd_enums[i].qt_code))

            nsActions |= dnd_enums[i].mac_code;

    }

    return nsActions;

}

static Qt::DropAction qt_mac_mapNSDragOperation(NSDragOperation nsActions)

{

    Qt::DropAction action = Qt::IgnoreAction;

    for (int i=0; dnd_enums[i].mac_code; i++) {

        if (nsActions & dnd_enums[i].mac_code)

            return dnd_enums[i].qt_code;

    }

    return action;

}

static Qt::DropActions qt_mac_mapNSDragOperations(NSDragOperation nsActions)

{

    Qt::DropActions actions = Qt::IgnoreAction;

    for (int i=0; dnd_enums[i].mac_code; i++) {

        if (nsActions & dnd_enums[i].mac_code)

            actions |= dnd_enums[i].qt_code;

    }

    return actions;

}

static QColor colorFrom(NSColor *color)

{

    QColor qtColor;

    NSString *colorSpace = [color colorSpaceName];

    if (colorSpace == NSDeviceCMYKColorSpace) {

        CGFloat cyan, magenta, yellow, black, alpha;

        [color getCyan:&cyan magenta:&magenta yellow:&yellow black:&black alpha:&alpha];

        qtColor.setCmykF(cyan, magenta, yellow, black, alpha);

    } else {

        NSColor *tmpColor;

        tmpColor = [color colorUsingColorSpaceName:NSDeviceRGBColorSpace];

        CGFloat red, green, blue, alpha;

        [tmpColor getRed:&red green:&green blue:&blue alpha:&alpha];

        qtColor.setRgbF(red, green, blue, alpha);

    }

    return qtColor;

}

QT_END_NAMESPACE

QT_FORWARD_DECLARE_CLASS(QMacCocoaAutoReleasePool)

QT_FORWARD_DECLARE_CLASS(QCFString)

QT_FORWARD_DECLARE_CLASS(QDragManager)

QT_FORWARD_DECLARE_CLASS(QMimeData)

QT_FORWARD_DECLARE_CLASS(QPoint)

QT_FORWARD_DECLARE_CLASS(QApplication)

QT_FORWARD_DECLARE_CLASS(QApplicationPrivate)

QT_FORWARD_DECLARE_CLASS(QDragEnterEvent)

QT_FORWARD_DECLARE_CLASS(QDragMoveEvent)

QT_FORWARD_DECLARE_CLASS(QStringList)

QT_FORWARD_DECLARE_CLASS(QString)

QT_FORWARD_DECLARE_CLASS(QRect)

QT_FORWARD_DECLARE_CLASS(QRegion)

QT_FORWARD_DECLARE_CLASS(QAbstractScrollArea)

QT_FORWARD_DECLARE_CLASS(QAbstractScrollAreaPrivate)

QT_FORWARD_DECLARE_CLASS(QPaintEvent)

QT_FORWARD_DECLARE_CLASS(QPainter)

QT_FORWARD_DECLARE_CLASS(QHoverEvent)

QT_FORWARD_DECLARE_CLASS(QCursor)

QT_USE_NAMESPACE

extern "C" {

    extern NSString *NSTextInputReplacementRangeAttributeName;

}

#ifdef ALIEN_DEBUG

static int qCocoaViewCount = 0;

#endif

@implementation QT_MANGLE_NAMESPACE(QCocoaView)

- (id)initWithQWidget:(QWidget *)widget widgetPrivate:(QWidgetPrivate *)widgetprivate

{

    self = [super init];

    if (self) {

        [self finishInitWithQWidget:widget widgetPrivate:widgetprivate];

    }

    [self setFocusRingType:NSFocusRingTypeNone];

    composingText = new QString();

#ifdef ALIEN_DEBUG

    ++qCocoaViewCount;

    qDebug() << "init: qCocoaViewCount is" << qCocoaViewCount;

#endif

    composing = false;

    sendKeyEvents = true;

    [self setHidden:YES];

    return self;

}

- (void) finishInitWithQWidget:(QWidget *)widget widgetPrivate:(QWidgetPrivate *)widgetprivate

{

    qwidget = widget;

    qwidgetprivate = widgetprivate;

    [[NSNotificationCenter defaultCenter] addObserver:self

                                             selector:@selector(frameDidChange:)

                                                 name:@"NSViewFrameDidChangeNotification"

                                               object:self];

}

- (void)resetCursorRects

{

    // [NSView addCursorRect] is slow, so bail out early if we can:

    if (NSIsEmptyRect([self visibleRect]))

        return;

    QWidget *cursorWidget = qwidget;

    if (cursorWidget->testAttribute(Qt::WA_TransparentForMouseEvents))

        cursorWidget = QApplication::widgetAt(qwidget->mapToGlobal(qwidget->rect().center()));

    if (cursorWidget == 0)

        return;

    if (!cursorWidget->testAttribute(Qt::WA_SetCursor)) {

        [super resetCursorRects];

        return;

    }

    QRegion mask = qt_widget_private(cursorWidget)->extra->mask;

    NSCursor *nscursor = static_cast<NSCursor *>(qt_mac_nsCursorForQCursor(cursorWidget->cursor()));

    // The mask could have the WA_MouseNoMask attribute set and that means that we have to ignore the mask.

    if (mask.isEmpty() || cursorWidget->testAttribute(Qt::WA_MouseNoMask)) {

        [self addCursorRect:[qt_mac_nativeview_for(cursorWidget) visibleRect] cursor:nscursor];

    } else {

        const QVector<QRect> &rects = mask.rects();

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

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

            [self addCursorRect:NSMakeRect(rect.x(), rect.y(), rect.width(), rect.height()) cursor:nscursor];

        }

    }

}

- (void)removeDropData

{

    if (dropData) {

        delete dropData;

        dropData = 0;

    }

}

- (void)addDropData:(id <NSDraggingInfo>)sender

{

    [self removeDropData];

    CFStringRef dropPasteboard = (CFStringRef) [[sender draggingPasteboard] name];

    dropData = new QCocoaDropData(dropPasteboard);

}

- (void)changeDraggingCursor:(NSDragOperation)newOperation

{

    static SEL action = nil;

    static bool operationSupported = false;

    if (action == nil) {

        action = NSSelectorFromString(@"operationNotAllowedCursor");

        if ([NSCursor respondsToSelector:action]) {

            operationSupported = true;

        }

    }

    if (operationSupported) {

        NSCursor *notAllowedCursor = [NSCursor performSelector:action];

        bool isNotAllowedCursor = ([NSCursor currentCursor] == notAllowedCursor);

        if (newOperation == NSDragOperationNone && !isNotAllowedCursor) {

            [notAllowedCursor push];

        } else if (newOperation != NSDragOperationNone && isNotAllowedCursor) {

            [notAllowedCursor pop];

        }

    }

}

- (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender

{

    // NB: This function is called from QCoocaWindow/QCocoaPanel rather than directly

    // from Cocoa. They modify the drag target, and might fake enter/leave events.

    NSPoint windowPoint = [sender draggingLocation];

    dragEnterSequence = [sender draggingSequenceNumber];

    [self addDropData:sender];

    QMimeData *mimeData = dropData;

    if (QDragManager::self()->source())

        mimeData = QDragManager::self()->dragPrivate()->data;

    NSPoint globalPoint = [[sender draggingDestinationWindow] convertBaseToScreen:windowPoint];

    NSPoint localPoint = [self convertPoint:windowPoint fromView:nil];

    QPoint posDrag(localPoint.x, localPoint.y);

    NSDragOperation nsActions = [sender draggingSourceOperationMask];

    Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations(nsActions);

    QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) = nsActions;

    Qt::KeyboardModifiers modifiers  = Qt::NoModifier;

    if ([sender draggingSource] != nil) {

        // modifier flags might have changed, update it here since we don't send any input events.

        QApplicationPrivate::modifier_buttons = qt_cocoaModifiers2QtModifiers([[NSApp currentEvent] modifierFlags]);

        modifiers = QApplication::keyboardModifiers();

    } else {

        // when the source is from another application the above technique will not work.

        modifiers = qt_cocoaDragOperation2QtModifiers(nsActions);

    }

    // send the drag enter event to the widget.

    QDragEnterEvent qDEEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);

    QApplication::sendEvent(qwidget, &qDEEvent);

    if (!qDEEvent.isAccepted()) {

        // widget is not interested in this drag, so ignore this drop data.

        [self removeDropData];

        [self changeDraggingCursor:NSDragOperationNone];

        return NSDragOperationNone;

    } else {

        // save the mouse position, used by draggingExited handler.

        DnDParams *dndParams = [QT_MANGLE_NAMESPACE(QCocoaView) currentMouseEvent];

        dndParams->activeDragEnterPos = windowPoint;

        // send a drag move event immediately after a drag enter event (as per documentation).

        QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);

        qDMEvent.setDropAction(qDEEvent.dropAction());

        qDMEvent.accept(); // accept by default, since enter event was accepted.

        QApplication::sendEvent(qwidget, &qDMEvent);

        if (!qDMEvent.isAccepted() || qDMEvent.dropAction() == Qt::IgnoreAction) {

            // since we accepted the drag enter event, the widget expects

            // future drage move events.

            // ### check if we need to treat this like the drag enter event.

            nsActions = NSDragOperationNone;

            // Save as ignored in the answer rect.

            qDMEvent.setDropAction(Qt::IgnoreAction);

        } else {

            nsActions = QT_PREPEND_NAMESPACE(qt_mac_mapDropAction)(qDMEvent.dropAction());

        }

        QT_PREPEND_NAMESPACE(qt_mac_copy_answer_rect)(qDMEvent);

        [self changeDraggingCursor:nsActions];

        return nsActions;

    }

 }

- (NSDragOperation)draggingUpdated:(id < NSDraggingInfo >)sender

{

    // NB: This function is called from QCoocaWindow/QCocoaPanel rather than directly

    // from Cocoa. They modify the drag target, and might fake enter/leave events.

    NSPoint windowPoint = [sender draggingLocation];

    // in cases like QFocusFrame, the view under the mouse might

    // not have received the drag enter. Generate a synthetic

    // drag enter event for that view.

    if (dragEnterSequence != [sender draggingSequenceNumber])

        [self draggingEntered:sender];

    // drag enter event was rejected, so ignore the move event.

    if (dropData == 0) {

        [self changeDraggingCursor:NSDragOperationNone];

        return NSDragOperationNone;

    }

    // return last value, if we are still in the answerRect.

    NSPoint globalPoint = [[sender draggingDestinationWindow] convertBaseToScreen:windowPoint];

    NSPoint localPoint = [self convertPoint:windowPoint fromView:nil];

    NSDragOperation nsActions = [sender draggingSourceOperationMask];

    QPoint posDrag(localPoint.x, localPoint.y);

    if (qt_mac_mouse_inside_answer_rect(posDrag)

        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) == nsActions) {

        NSDragOperation operation = QT_PREPEND_NAMESPACE(qt_mac_mapDropActions)(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastAction));

        [self changeDraggingCursor:operation];

        return operation;

    }

    // send drag move event to the widget

    QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastOperation) = nsActions;

    Qt::DropActions qtAllowed = QT_PREPEND_NAMESPACE(qt_mac_mapNSDragOperations)(nsActions);

    Qt::KeyboardModifiers modifiers  = Qt::NoModifier;

    if ([sender draggingSource] != nil) {

        // modifier flags might have changed, update it here since we don't send any input events.

        QApplicationPrivate::modifier_buttons = qt_cocoaModifiers2QtModifiers([[NSApp currentEvent] modifierFlags]);

        modifiers = QApplication::keyboardModifiers();

    } else {

        // when the source is from another application the above technique will not work.

        modifiers = qt_cocoaDragOperation2QtModifiers(nsActions);

    }

    QMimeData *mimeData = dropData;

    if (QDragManager::self()->source())

        mimeData = QDragManager::self()->dragPrivate()->data;

    QDragMoveEvent qDMEvent(posDrag, qtAllowed, mimeData, QApplication::mouseButtons(), modifiers);

    if (QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).lastAction != Qt::IgnoreAction

        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).buttons == qDMEvent.mouseButtons()

        && QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).modifiers == qDMEvent.keyboardModifiers())

        qDMEvent.setDropAction(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec).lastAction);

    qDMEvent.accept();

    QApplication::sendEvent(qwidget, &qDMEvent);

    NSDragOperation operation = qt_mac_mapDropAction(qDMEvent.dropAction());

    if (!qDMEvent.isAccepted() || qDMEvent.dropAction() == Qt::IgnoreAction) {

        // ignore this event (we will still receive further notifications)

        operation = NSDragOperationNone;

        // Save as ignored in the answer rect.

        qDMEvent.setDropAction(Qt::IgnoreAction);

    }

    qt_mac_copy_answer_rect(qDMEvent);

    [self changeDraggingCursor:operation];

    return operation;

}

- (void)draggingExited:(id < NSDraggingInfo >)sender

{

    // NB: This function is called from QCoocaWindow/QCocoaPanel rather than directly

    // from Cocoa. They modify the drag target, and might fake enter/leave events.

    Q_UNUSED(sender);

    dragEnterSequence = -1;

    // drag enter event was rejected, so ignore the move event.

    if (dropData) {

        QDragLeaveEvent de;

        QApplication::sendEvent(qwidget, &de);

        [self removeDropData];

    }

    [self changeDraggingCursor:NSDragOperationEvery];

}

- (BOOL)performDragOperation:(id <NSDraggingInfo>)sender

{

    // NB: This function is called from QCoocaWindow/QCocoaPanel rather than directly

    // from Cocoa. They modify the drag target, and might fake enter/leave events.

    NSPoint windowPoint = [sender draggingLocation];

    dragEnterSequence = -1;

    [self addDropData:sender];

    NSPoint globalPoint = [[sender draggingDestinationWindow] convertBaseToScreen:windowPoint];

    NSPoint localPoint = [self convertPoint:windowPoint fromView:nil];

    QPoint posDrop(localPoint.x, localPoint.y);

    NSDragOperation nsActions = [sender draggingSourceOperationMask];

    Qt::DropActions qtAllowed = qt_mac_mapNSDragOperations(nsActions);

    QMimeData *mimeData = dropData;

    if (QDragManager::self()->source())

        mimeData = QDragManager::self()->dragPrivate()->data;

    // send the drop event to the widget.

    QDropEvent de(posDrop, qtAllowed, mimeData,

                  QApplication::mouseButtons(), QApplication::keyboardModifiers());

    if (QDragManager::self()->object)

        QDragManager::self()->dragPrivate()->target = qwidget;

    QApplication::sendEvent(qwidget, &de);

    if (QDragManager::self()->object)

        QDragManager::self()->dragPrivate()->executed_action = de.dropAction();

    if (!de.isAccepted())

        return NO;

    else

        return YES;

}

- (void)dealloc

{

    delete composingText;

    [[NSNotificationCenter defaultCenter] removeObserver:self];

#ifdef ALIEN_DEBUG

    --qCocoaViewCount;

    qDebug() << "qCocoaViewCount is" << qCocoaViewCount;

#endif

    [super dealloc];

}

- (BOOL)isOpaque;

{

    if (!qwidgetprivate)

        return [super isOpaque];

    return qwidgetprivate->isOpaque;

}

- (BOOL)isFlipped;

{

    return YES;

}

// We preserve the content of the view if WA_StaticContents is defined.

//

// More info in the Cocoa documentation:

// http://developer.apple.com/mac/library/documentation/cocoa/conceptual/CocoaViewsGuide/Optimizing/Optimizing.html

- (BOOL) preservesContentDuringLiveResize

{

    return qwidget->testAttribute(Qt::WA_StaticContents);

}

- (void) setFrameSize:(NSSize)newSize

{

    [super setFrameSize:newSize];

    // A change in size has required the view to be invalidated.

    if ([self inLiveResize]) {

        NSRect rects[4];

        NSInteger count;

        [self getRectsExposedDuringLiveResize:rects count:&count];

        while (count-- > 0)

        {

            [self setNeedsDisplayInRect:rects[count]];

        }

    } else {

        [self setNeedsDisplay:YES];

    }

    // Make sure the opengl context is updated on resize.

    if (qwidgetprivate && qwidgetprivate->isGLWidget) {

        qwidgetprivate->needWindowChange = true;

        QEvent event(QEvent::MacGLWindowChange);

        qApp->sendEvent(qwidget, &event);

    }

}

// We catch the 'setNeedsDisplay:' message in order to avoid a useless full repaint.