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

**

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

**

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

#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 (DeviceDelta)

  - (CGFloat)deviceDeltaX;

  - (CGFloat)deviceDeltaY;

  - (CGFloat)deviceDeltaZ;

@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 const QStringList& qEnabledDraggedTypes(); // qmime_mac.cpp

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

Qt::MouseButton cocoaButton2QtButton(NSInteger buttonNum)

{

    if (buttonNum == 0)

        return Qt::LeftButton;

    if (buttonNum == 1)

        return Qt::RightButton;

    if (buttonNum == 2)

        return Qt::MidButton;

    if (buttonNum == 3)

        return Qt::XButton1;

    if (buttonNum == 4)

        return Qt::XButton2;

    return Qt::NoButton;

}

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;

}

@implementation QT_MANGLE_NAMESPACE(QCocoaView)

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

{

    self = [super init];

    if (self) {

        [self finishInitWithQWidget:widget widgetPrivate:widgetprivate];

    }

    composingText = new QString();

    composing = false;

    sendKeyEvents = true;

    currentCustomTypes = 0;

    [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)registerDragTypes

{

    QMacCocoaAutoReleasePool pool;

    // Calling registerForDraggedTypes is slow, so only do it once for each widget

    // or when the custom types change.

    const QStringList& customTypes = qEnabledDraggedTypes();

    if (currentCustomTypes == 0 || *currentCustomTypes != customTypes) {

        if (currentCustomTypes == 0)

            currentCustomTypes = new QStringList();

        *currentCustomTypes = customTypes;

        const NSString* mimeTypeGeneric = @"com.trolltech.qt.MimeTypeName";

	NSMutableArray *supportedTypes = [NSMutableArray arrayWithObjects:NSColorPboardType,

                                   NSFilenamesPboardType, NSStringPboardType,

                                   NSFilenamesPboardType, NSPostScriptPboardType, NSTIFFPboardType,

                                   NSRTFPboardType, NSTabularTextPboardType, NSFontPboardType,

                                   NSRulerPboardType, NSFileContentsPboardType, NSColorPboardType,

                                   NSRTFDPboardType, NSHTMLPboardType, NSPICTPboardType,

                                   NSURLPboardType, NSPDFPboardType, NSVCardPboardType,

                                   NSFilesPromisePboardType, NSInkTextPboardType,

                                   NSMultipleTextSelectionPboardType, mimeTypeGeneric, nil];

        // Add custom types supported by the application.

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

           [supportedTypes addObject:reinterpret_cast<const NSString *>(QCFString::toCFStringRef(customTypes[i]))];

        }

        [self registerForDraggedTypes:supportedTypes];

    }

}

- (void)resetCursorRects

{

    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()));

    if (mask.isEmpty()) {

        [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);

}

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

{

    if (qwidget->testAttribute(Qt::WA_DropSiteRegistered) == false)

        return NSDragOperationNone;

    NSPoint windowPoint = [sender draggingLocation];

    if (qwidget->testAttribute(Qt::WA_TransparentForMouseEvents)) {

        // pass the drag enter event to the view underneath.

        NSView *candidateView = [[[self window] contentView] hitTest:windowPoint];

        if (candidateView && candidateView != self)

            return [candidateView draggingEntered:sender];

    }

    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];

        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 = QT_PREPEND_NAMESPACE(qt_mac_mapDropAction)(qDEEvent.dropAction());

        } else {

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

        }

        QT_PREPEND_NAMESPACE(qt_mac_copy_answer_rect)(qDMEvent);

        return nsActions;

    }

 }

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

{

    NSPoint windowPoint = [sender draggingLocation];

    if (qwidget->testAttribute(Qt::WA_TransparentForMouseEvents)) {

        // pass the drag move event to the view underneath.

        NSView *candidateView = [[[self window] contentView] hitTest:windowPoint];

        if (candidateView && candidateView != self)

            return [candidateView draggingUpdated:sender];

    }

    // 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)

        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)

        return QT_PREPEND_NAMESPACE(qt_mac_mapDropActions)(QT_PREPEND_NAMESPACE(qt_mac_dnd_answer_rec.lastAction));

    // 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);

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

    qDMEvent.accept();

    QApplication::sendEvent(qwidget, &qDMEvent);

    qt_mac_copy_answer_rect(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;

    }

    return operation;

}

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

{

    dragEnterSequence = -1;

    if (qwidget->testAttribute(Qt::WA_TransparentForMouseEvents)) {

        // try sending the leave event to the last view which accepted drag enter.

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

        NSView *candidateView = [[[self window] contentView] hitTest:dndParams->activeDragEnterPos];

        if (candidateView && candidateView != self)

            return [candidateView draggingExited:sender];

    }

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

    if (dropData) {

        QDragLeaveEvent de;

        QApplication::sendEvent(qwidget, &de);

        [self removeDropData];

    }

}

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

{

    NSPoint windowPoint = [sender draggingLocation];

    dragEnterSequence = -1;

    if (qwidget->testAttribute(Qt::WA_TransparentForMouseEvents)) {

        // pass the drop event to the view underneath.

        NSView *candidateView = [[[self window] contentView] hitTest:windowPoint];

        if (candidateView && candidateView != self)

            return [candidateView performDragOperation:sender];

    }

    [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];

    delete currentCustomTypes;

    [self unregisterDraggedTypes];

    [super dealloc];

}

- (BOOL)isOpaque;

{

    return qwidgetprivate->isOpaque;

}

- (BOOL)isFlipped;

{

    return YES;

}

- (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];

    }

}

- (void)drawRect:(NSRect)aRect

{

    if (QApplicationPrivate::graphicsSystem() != 0) {

        if (QWidgetBackingStore *bs = qwidgetprivate->maybeBackingStore())

            bs->markDirty(qwidget->rect(), qwidget);

        qwidgetprivate->syncBackingStore(qwidget->rect());

        return;

    }

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

    qwidgetprivate->hd = cg;

    CGContextSaveGState(cg);

    if (qwidget->isVisible() && qwidget->updatesEnabled()) { //process the actual paint event.

        if (qwidget->testAttribute(Qt::WA_WState_InPaintEvent))

            qWarning("QWidget::repaint: Recursive repaint detected");

        const QRect qrect = QRect(aRect.origin.x, aRect.origin.y, aRect.size.width, aRect.size.height);

        QRegion qrgn(qrect);

        if (!qwidget->isWindow() && !qobject_cast<QAbstractScrollArea *>(qwidget->parent())) {

            const QRegion &parentMask = qwidget->window()->mask();

            if (!parentMask.isEmpty()) {

                const QPoint mappedPoint = qwidget->mapTo(qwidget->window(), qrect.topLeft());

                qrgn.translate(mappedPoint);