/*

 * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.

 * Copyright (C) 2008 Collabora Ltd. All rights reserved.

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

 * Copyright (C) 2009 Girish Ramakrishnan <girish@forwardbias.in>

 *

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

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. 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.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``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 APPLE COMPUTER, INC. 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 "config.h"

#include "PluginView.h"

#include "Bridge.h"

#include "Document.h"

#include "DocumentLoader.h"

#include "Element.h"

#include "EventNames.h"

#include "FocusController.h"

#include "FrameLoader.h"

#include "FrameLoadRequest.h"

#include "FrameTree.h"

#include "Frame.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HostWindow.h"

#include "HTMLNames.h"

#include "HTMLPlugInElement.h"

#include "Image.h"

#include "JSDOMBinding.h"

#include "KeyboardEvent.h"

#include "MouseEvent.h"

#include "NotImplemented.h"

#include "Page.h"

#include "PlatformMouseEvent.h"

#include "PlatformKeyboardEvent.h"

#include "PluginDebug.h"

#include "PluginPackage.h"

#include "PluginMainThreadScheduler.h"

#include "RenderLayer.h"

#include "ScriptController.h"

#include "Settings.h"

#include "npruntime_impl.h"

#include "runtime_root.h"

#include <runtime/JSLock.h>

#include <runtime/JSValue.h>

#include <wtf/RetainPtr.h>

using JSC::ExecState;

using JSC::Interpreter;

using JSC::JSLock;

using JSC::JSObject;

using JSC::JSValue;

using JSC::UString;

#if PLATFORM(QT)

#include <QWidget>

#include <QKeyEvent>

#include <QPainter>

#include "QWebPageClient.h"

QT_BEGIN_NAMESPACE

extern Q_GUI_EXPORT OSWindowRef qt_mac_window_for(const QWidget* w);

QT_END_NAMESPACE

#endif

#if PLATFORM(WX)

#include <wx/defs.h>

#include <wx/wx.h>

#endif

using std::min;

using namespace WTF;

namespace WebCore {

using namespace HTMLNames;

#ifndef NP_NO_CARBON

static int modifiersForEvent(UIEventWithKeyState *event);

#endif

static inline WindowRef nativeWindowFor(PlatformWidget widget)

{

#if PLATFORM(QT)

    if (widget)

#if QT_MAC_USE_COCOA

        return static_cast<WindowRef>([qt_mac_window_for(widget) windowRef]);

#else

        return static_cast<WindowRef>(qt_mac_window_for(widget));

#endif

#elif PLATFORM(WX)

    if (widget)

        return (WindowRef)widget->MacGetTopLevelWindowRef();

#endif

    return 0;

}

static inline CGContextRef cgHandleFor(PlatformWidget widget)

{

#if PLATFORM(QT)

    if (widget)

        return (CGContextRef)widget->macCGHandle();

#endif

#if PLATFORM(WX)

    if (widget)

        return (CGContextRef)widget->MacGetCGContextRef();

#endif

    return 0;

}

static inline IntPoint topLevelOffsetFor(PlatformWidget widget)

{

#if PLATFORM(QT)

    if (widget) {

        PlatformWidget topLevel = widget->window();

        return widget->mapTo(topLevel, QPoint(0, 0)) + topLevel->geometry().topLeft() - topLevel->pos();

    }

#endif

#if PLATFORM(WX)

    if (widget) {

        PlatformWidget toplevel = wxGetTopLevelParent(widget);

        return toplevel->ScreenToClient(widget->GetScreenPosition());

    }

#endif

    return IntPoint();

}

// --------------- Lifetime management -----------------

bool PluginView::platformStart()

{

    ASSERT(m_isStarted);

    ASSERT(m_status == PluginStatusLoadedSuccessfully);

    if (m_drawingModel == NPDrawingModel(-1)) {

        // We default to QuickDraw, even though we don't support it,

        // since that's what Safari does, and some plugins expect this

        // behavior and never set the drawing model explicitly.

#ifndef NP_NO_QUICKDRAW

        m_drawingModel = NPDrawingModelQuickDraw;

#else

        // QuickDraw not available, so we have to default to CoreGraphics

        m_drawingModel = NPDrawingModelCoreGraphics;

#endif

    }

    if (m_eventModel == NPEventModel(-1)) {

        // If the plug-in did not specify an event model

        // we default to Carbon, when it is available.

#ifndef NP_NO_CARBON

        m_eventModel = NPEventModelCarbon;

#else

        m_eventModel = NPEventModelCocoa;

#endif

    }

    // Gracefully handle unsupported drawing or event models. We can do this

    // now since the drawing and event model can only be set during NPP_New.

#ifndef NP_NO_CARBON

    NPBool eventModelSupported;

    if (getValueStatic(NPNVariable(NPNVsupportsCarbonBool + m_eventModel), &eventModelSupported) != NPERR_NO_ERROR

            || !eventModelSupported) {

#endif

        m_status = PluginStatusCanNotLoadPlugin;

        LOG(Plugins, "Plug-in '%s' uses unsupported event model %s",

                m_plugin->name().utf8().data(), prettyNameForEventModel(m_eventModel));

        return false;

#ifndef NP_NO_CARBON

    }

#endif

#ifndef NP_NO_QUICKDRAW

    NPBool drawingModelSupported;

    if (getValueStatic(NPNVariable(NPNVsupportsQuickDrawBool + m_drawingModel), &drawingModelSupported) != NPERR_NO_ERROR

            || !drawingModelSupported) {

#endif

        m_status = PluginStatusCanNotLoadPlugin;

        LOG(Plugins, "Plug-in '%s' uses unsupported drawing model %s",

                m_plugin->name().utf8().data(), prettyNameForDrawingModel(m_drawingModel));

        return false;

#ifndef NP_NO_QUICKDRAW

    }

#endif

#if PLATFORM(QT)

    // Set the platformPluginWidget only in the case of QWebView so that the context menu appears in the right place.

    // In all other cases, we use off-screen rendering

    if (QWebPageClient* client = m_parentFrame->view()->hostWindow()->platformPageClient()) {

        if (QWidget* widget = qobject_cast<QWidget*>(client->pluginParent()))

            setPlatformPluginWidget(widget);

    }

#endif

#if PLATFORM(WX)

    if (wxWindow* widget = m_parentFrame->view()->hostWindow()->platformPageClient())

        setPlatformPluginWidget(widget);

#endif

    // Create a fake window relative to which all events will be sent when using offscreen rendering

    if (!platformPluginWidget()) {

#ifndef NP_NO_CARBON

        // Make the default size really big. It is unclear why this is required but with a smaller size, mouse move

        // events don't get processed. Resizing the fake window to flash's size doesn't help.

        ::Rect windowBounds = { 0, 0, 1000, 1000 };

        CreateNewWindow(kDocumentWindowClass, kWindowStandardDocumentAttributes, &windowBounds, &m_fakeWindow);

        // Flash requires the window to be hilited to process mouse move events.

        HiliteWindow(m_fakeWindow, true);

#endif

    }

    // TODO: Implement null timer throttling depending on plugin activation

    m_nullEventTimer.set(new Timer<PluginView>(this, &PluginView::nullEventTimerFired));

    m_nullEventTimer->startRepeating(0.02);

    m_lastMousePos.h = m_lastMousePos.v = 0;

    return true;

}

void PluginView::platformDestroy()

{

    if (platformPluginWidget())

        setPlatformPluginWidget(0);

    else {

        CGContextRelease(m_contextRef);

#ifndef NP_NO_CARBON

        if (m_fakeWindow)

            DisposeWindow(m_fakeWindow);

#endif

    }

}

// Used before the plugin view has been initialized properly, and as a

// fallback for variables that do not require a view to resolve.

bool PluginView::platformGetValueStatic(NPNVariable variable, void* value, NPError* result)

{

    switch (variable) {

    case NPNVToolkit:

        *static_cast<uint32_t*>(value) = 0;

        *result = NPERR_NO_ERROR;

        return true;

    case NPNVjavascriptEnabledBool:

        *static_cast<NPBool*>(value) = true;

        *result = NPERR_NO_ERROR;

        return true;

#ifndef NP_NO_CARBON

    case NPNVsupportsCarbonBool:

        *static_cast<NPBool*>(value) = true;

        *result = NPERR_NO_ERROR;

        return true;

#endif

    case NPNVsupportsCocoaBool:

        *static_cast<NPBool*>(value) = false;

        *result = NPERR_NO_ERROR;

        return true;

    // CoreGraphics is the only drawing model we support

    case NPNVsupportsCoreGraphicsBool:

        *static_cast<NPBool*>(value) = true;

        *result = NPERR_NO_ERROR;

        return true;

#ifndef NP_NO_QUICKDRAW

    // QuickDraw is deprecated in 10.5 and not supported on 64-bit

    case NPNVsupportsQuickDrawBool:

#endif

    case NPNVsupportsOpenGLBool:

    case NPNVsupportsCoreAnimationBool:

        *static_cast<NPBool*>(value) = false;

        *result = NPERR_NO_ERROR;

        return true;

    default:

        return false;

    }

}

// Used only for variables that need a view to resolve

bool PluginView::platformGetValue(NPNVariable variable, void* value, NPError* error)

{

    return false;

}

void PluginView::setParent(ScrollView* parent)

{

    LOG(Plugins, "PluginView::setParent(%p)", parent);

    Widget::setParent(parent);

    if (parent)

        init();

}

// -------------- Geometry and painting ----------------

void PluginView::show()

{

    LOG(Plugins, "PluginView::show()");

    setSelfVisible(true);

    Widget::show();

}

void PluginView::hide()

{

    LOG(Plugins, "PluginView::hide()");

    setSelfVisible(false);

    Widget::hide();

}

void PluginView::setFocus(bool focused)

{

    LOG(Plugins, "PluginView::setFocus(%d)", focused);

    if (!focused) {

        Widget::setFocus(focused);

        return;

    }

    if (platformPluginWidget())

#if PLATFORM(QT)

       platformPluginWidget()->setFocus(Qt::OtherFocusReason);

#else

        platformPluginWidget()->SetFocus();

#endif

   else

       Widget::setFocus(focused);

    // TODO: Also handle and pass on blur events (focus lost)

#ifndef NP_NO_CARBON

    EventRecord record;

    record.what = getFocusEvent;

    record.message = 0;

    record.when = TickCount();

    record.where = globalMousePosForPlugin();

    record.modifiers = GetCurrentKeyModifiers();

    if (!dispatchNPEvent(record))

        LOG(Events, "PluginView::setFocus(%d): Focus event not accepted", focused);

#endif

}

void PluginView::setParentVisible(bool visible)

{

    if (isParentVisible() == visible)

        return;

    Widget::setParentVisible(visible);

}

void PluginView::setNPWindowRect(const IntRect&)

{

    setNPWindowIfNeeded();

}

void PluginView::setNPWindowIfNeeded()

{

    if (!m_isStarted || !parent() || !m_plugin->pluginFuncs()->setwindow)

        return;

    CGContextRef newContextRef = 0;

    WindowRef newWindowRef = 0;

    if (platformPluginWidget()) {

        newContextRef = cgHandleFor(platformPluginWidget());

        newWindowRef = nativeWindowFor(platformPluginWidget());

        m_npWindow.type = NPWindowTypeWindow;

    } else {

        newContextRef = m_contextRef;

        newWindowRef = m_fakeWindow;

        m_npWindow.type = NPWindowTypeDrawable;

    }

    if (!newContextRef || !newWindowRef)

        return;

    m_npWindow.window = (void*)&m_npCgContext;

#ifndef NP_NO_CARBON

    m_npCgContext.window = newWindowRef;

#endif

    m_npCgContext.context = newContextRef;

    m_npWindow.x = m_windowRect.x();

    m_npWindow.y = m_windowRect.y();

    m_npWindow.width = m_windowRect.width();

    m_npWindow.height = m_windowRect.height();

    // TODO: (also clip against scrollbars, etc.)

    m_npWindow.clipRect.left = max(0, m_windowRect.x());

    m_npWindow.clipRect.top = max(0, m_windowRect.y());

    m_npWindow.clipRect.right = m_windowRect.x() + m_windowRect.width();

    m_npWindow.clipRect.bottom = m_windowRect.y() + m_windowRect.height();

    LOG(Plugins, "PluginView::setNPWindowIfNeeded(): window=%p, context=%p,"

            " window.x:%d window.y:%d window.width:%d window.height:%d window.clipRect size:%dx%d",

            newWindowRef, newContextRef, m_npWindow.x, m_npWindow.y, m_npWindow.width, m_npWindow.height,

            m_npWindow.clipRect.right - m_npWindow.clipRect.left, m_npWindow.clipRect.bottom - m_npWindow.clipRect.top);

    PluginView::setCurrentPluginView(this);

    JSC::JSLock::DropAllLocks dropAllLocks(JSC::SilenceAssertionsOnly);

    setCallingPlugin(true);

    m_plugin->pluginFuncs()->setwindow(m_instance, &m_npWindow);

    setCallingPlugin(false);

    PluginView::setCurrentPluginView(0);

}

void PluginView::updatePluginWidget()

{

    if (!parent())

       return;

    ASSERT(parent()->isFrameView());

    FrameView* frameView = static_cast<FrameView*>(parent());

    IntRect oldWindowRect = m_windowRect;

    IntRect oldClipRect = m_clipRect;

    m_windowRect = frameView->contentsToWindow(frameRect());

    IntPoint offset = topLevelOffsetFor(platformPluginWidget());

    m_windowRect.move(offset.x(), offset.y());

    if (!platformPluginWidget()) {

        if (m_windowRect.size() != oldWindowRect.size()) {

            CGContextRelease(m_contextRef);

#if PLATFORM(QT)

            m_pixmap = QPixmap(m_windowRect.size());

            m_pixmap.fill(Qt::transparent);

            m_contextRef = m_pixmap.isNull() ? 0 : qt_mac_cg_context(&m_pixmap);

#endif

        }

    }

    m_clipRect = windowClipRect();

    m_clipRect.move(-m_windowRect.x(), -m_windowRect.y());

    if (platformPluginWidget() && (m_windowRect != oldWindowRect || m_clipRect != oldClipRect))

        setNPWindowIfNeeded();

}

void PluginView::paint(GraphicsContext* context, const IntRect& rect)

{

    if (!m_isStarted || m_status != PluginStatusLoadedSuccessfully) {

        paintMissingPluginIcon(context, rect);

        return;

    }

    if (context->paintingDisabled())

        return;

    setNPWindowIfNeeded();

    CGContextRef cgContext = m_npCgContext.context;

    if (!cgContext)

        return;

    CGContextSaveGState(cgContext);

    if (platformPluginWidget()) {

        IntPoint offset = frameRect().location();

        CGContextTranslateCTM(cgContext, offset.x(), offset.y());

    }

    IntRect targetRect(frameRect());

    targetRect.intersects(rect);

    // clip the context so that plugin only updates the interested area.

    CGRect r;

    r.origin.x = targetRect.x() - frameRect().x();

    r.origin.y = targetRect.y() - frameRect().y();

    r.size.width = targetRect.width();

    r.size.height = targetRect.height();

    CGContextClipToRect(cgContext, r);

    if (!platformPluginWidget() && m_isTransparent) { // clean the pixmap in transparent mode

#if PLATFORM(QT)

        QPainter painter(&m_pixmap);

        painter.setCompositionMode(QPainter::CompositionMode_Clear);

        painter.fillRect(QRectF(r.origin.x, r.origin.y, r.size.width, r.size.height), Qt::transparent);

#endif

    }

#ifndef NP_NO_CARBON

    EventRecord event;

    event.what = updateEvt;

    event.message = (long unsigned int)m_npCgContext.window;

    event.when = TickCount();

    event.where.h = 0;

    event.where.v = 0;

    event.modifiers = GetCurrentKeyModifiers();

    if (!dispatchNPEvent(event))

        LOG(Events, "PluginView::paint(): Paint event not accepted");

#endif

    CGContextRestoreGState(cgContext);

    if (!platformPluginWidget()) {

#if PLATFORM(QT)

        QPainter* painter = context->platformContext();

        painter->drawPixmap(targetRect.x(), targetRect.y(), m_pixmap,