/*

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

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

 * Copyright (C) 2009, 2010 Kakai, Inc. <brian@kakai.com>

 * Copyright (C) 2010 Igalia S.L.

 *

 * 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 "FrameLoader.h"

#include "FrameLoadRequest.h"

#include "FrameTree.h"

#include "Frame.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "GtkVersioning.h"

#include "HTMLNames.h"

#include "HTMLPlugInElement.h"

#include "HostWindow.h"

#include "Image.h"

#include "KeyboardEvent.h"

#include "MouseEvent.h"

#include "Page.h"

#include "PlatformKeyboardEvent.h"

#include "PlatformMouseEvent.h"

#include "PluginDebug.h"

#include "PluginMainThreadScheduler.h"

#include "PluginPackage.h"

#include "RenderLayer.h"

#include "Settings.h"

#include "JSDOMBinding.h"

#include "ScriptController.h"

#include "npruntime_impl.h"

#include "runtime_root.h"

#include <runtime/JSLock.h>

#include <runtime/JSValue.h>

#include <gdkconfig.h>

#include <gtk/gtk.h>

#if defined(XP_UNIX)

#include "gtk2xtbin.h"

#define Bool int // this got undefined somewhere

#define Status int // ditto

#include <X11/extensions/Xrender.h>

#include <cairo/cairo-xlib.h>

#include <gdk/gdkx.h>

#elif defined(GDK_WINDOWING_WIN32)

#include "PluginMessageThrottlerWin.h"

#include <gdk/gdkwin32.h>

#endif

using JSC::ExecState;

using JSC::Interpreter;

using JSC::JSLock;

using JSC::JSObject;

using JSC::UString;

using std::min;

using namespace WTF;

namespace WebCore {

using namespace HTMLNames;

bool PluginView::dispatchNPEvent(NPEvent& event)

{

    // sanity check

    if (!m_plugin->pluginFuncs()->event)

        return false;

    PluginView::setCurrentPluginView(this);

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

    setCallingPlugin(true);

    bool accepted = m_plugin->pluginFuncs()->event(m_instance, &event);

    setCallingPlugin(false);

    PluginView::setCurrentPluginView(0);

    return accepted;

}

#if defined(XP_UNIX)

static Window getRootWindow(Frame* parentFrame)

{

    GtkWidget* parentWidget = parentFrame->view()->hostWindow()->platformPageClient();

    GdkScreen* gscreen = gtk_widget_get_screen(parentWidget);

    return GDK_WINDOW_XWINDOW(gdk_screen_get_root_window(gscreen));

}

#endif

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 = IntRect(frameView->contentsToWindow(frameRect().location()), frameRect().size());

    m_clipRect = windowClipRect();

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

    if (m_windowRect == oldWindowRect && m_clipRect == oldClipRect)

        return;

#if defined(XP_UNIX)

    if (!m_isWindowed) {

        if (m_drawable)

            XFreePixmap(GDK_DISPLAY(), m_drawable);

        m_drawable = XCreatePixmap(GDK_DISPLAY(), getRootWindow(m_parentFrame.get()),

                                   m_windowRect.width(), m_windowRect.height(),

                                   ((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->depth);

        XSync(GDK_DISPLAY(), False); // make sure that the server knows about the Drawable

    }

#endif

    setNPWindowIfNeeded();

}

void PluginView::setFocus(bool focused)

{

    ASSERT(platformPluginWidget() == platformWidget());

    Widget::setFocus(focused);

}

void PluginView::show()

{

    ASSERT(platformPluginWidget() == platformWidget());

    Widget::show();

}

void PluginView::hide()

{

    ASSERT(platformPluginWidget() == platformWidget());

    Widget::hide();

}

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

{

    if (!m_isStarted) {

        paintMissingPluginIcon(context, rect);

        return;

    }

    if (context->paintingDisabled())

        return;

    setNPWindowIfNeeded();

    if (m_isWindowed)

        return;

#if defined(XP_UNIX)

    if (!m_drawable)

        return;

    const bool syncX = m_pluginDisplay && m_pluginDisplay != GDK_DISPLAY();

    IntRect exposedRect(rect);

    exposedRect.intersect(frameRect());

    exposedRect.move(-frameRect().x(), -frameRect().y());

    Window dummyW;

    int dummyI;

    unsigned int dummyUI, actualDepth = 0;

    XGetGeometry(GDK_DISPLAY(), m_drawable, &dummyW, &dummyI, &dummyI,

                 &dummyUI, &dummyUI, &dummyUI, &actualDepth);

    const unsigned int drawableDepth = ((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->depth;

    ASSERT(drawableDepth == actualDepth);

    cairo_surface_t* drawableSurface = cairo_xlib_surface_create(GDK_DISPLAY(),

                                                                 m_drawable,

                                                                 m_visual,

                                                                 m_windowRect.width(),

                                                                 m_windowRect.height());

    if (m_isTransparent && drawableDepth != 32) {

        // Attempt to fake it when we don't have an alpha channel on our

        // pixmap.  If that's not possible, at least clear the window to

        // avoid drawing artifacts.

        GtkWidget* widget = m_parentFrame->view()->hostWindow()->platformPageClient();

        GdkDrawable* gdkBackingStore = 0;

        gint xoff = 0, yoff = 0;

        gdk_window_get_internal_paint_info(gtk_widget_get_window(widget), &gdkBackingStore, &xoff, &yoff);

        GC gc = XDefaultGC(GDK_DISPLAY(), gdk_screen_get_number(gdk_screen_get_default()));

        if (gdkBackingStore) {

            XCopyArea(GDK_DISPLAY(), GDK_DRAWABLE_XID(gdkBackingStore), m_drawable, gc,

                      m_windowRect.x() + exposedRect.x() - xoff,

                      m_windowRect.y() + exposedRect.y() - yoff,

                      exposedRect.width(), exposedRect.height(),

                      exposedRect.x(), exposedRect.y());

        } else {

            // no valid backing store; clear to the background color

            XFillRectangle(GDK_DISPLAY(), m_drawable, gc,

                           exposedRect.x(), exposedRect.y(),

                           exposedRect.width(), exposedRect.height());

        }

    } else if (m_isTransparent) {

        // If we have a 32 bit drawable and the plugin wants transparency,

        // we'll clear the exposed area to transparent first.  Otherwise,

        // we'd end up with junk in there from the last paint, or, worse,

        // uninitialized data.

        cairo_t* crFill = cairo_create(drawableSurface);

        cairo_set_operator(crFill, CAIRO_OPERATOR_SOURCE);

        cairo_pattern_t* fill = cairo_pattern_create_rgba(0., 0., 0., 0.);

        cairo_set_source(crFill, fill);

        cairo_rectangle(crFill, exposedRect.x(), exposedRect.y(),

                        exposedRect.width(), exposedRect.height());

        cairo_clip(crFill);

        cairo_paint(crFill);

        cairo_destroy(crFill);

        cairo_pattern_destroy(fill);

    }

    XEvent xevent;

    memset(&xevent, 0, sizeof(XEvent));

    XGraphicsExposeEvent& exposeEvent = xevent.xgraphicsexpose;

    exposeEvent.type = GraphicsExpose;

    exposeEvent.display = GDK_DISPLAY();

    exposeEvent.drawable = m_drawable;

    exposeEvent.x = exposedRect.x();

    exposeEvent.y = exposedRect.y();

    exposeEvent.width = exposedRect.x() + exposedRect.width(); // flash bug? it thinks width is the right in transparent mode

    exposeEvent.height = exposedRect.y() + exposedRect.height(); // flash bug? it thinks height is the bottom in transparent mode

    dispatchNPEvent(xevent);

    if (syncX)

        XSync(m_pluginDisplay, False); // sync changes by plugin

    cairo_t* cr = context->platformContext();

    cairo_save(cr);

    cairo_set_source_surface(cr, drawableSurface, frameRect().x(), frameRect().y());

    cairo_rectangle(cr,

                    frameRect().x() + exposedRect.x(), frameRect().y() + exposedRect.y(),

                    exposedRect.width(), exposedRect.height());

    cairo_clip(cr);

    if (m_isTransparent)

        cairo_set_operator(cr, CAIRO_OPERATOR_OVER);

    else

        cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);

    cairo_paint(cr);

    cairo_restore(cr);

    cairo_surface_destroy(drawableSurface);

#endif // defined(XP_UNIX)

}

void PluginView::handleKeyboardEvent(KeyboardEvent* event)

{

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

    if (m_isWindowed)

        return;

    if (event->type() != eventNames().keydownEvent && event->type() != eventNames().keyupEvent)

        return;

    NPEvent xEvent;

#if defined(XP_UNIX)

    GdkEventKey* gdkEvent = event->keyEvent()->gdkEventKey();

    xEvent.type = (event->type() == eventNames().keydownEvent) ? 2 : 3; // KeyPress/Release get unset somewhere

    xEvent.xkey.root = getRootWindow(m_parentFrame.get());

    xEvent.xkey.subwindow = 0; // we have no child window

    xEvent.xkey.time = event->timeStamp();

    xEvent.xkey.state = gdkEvent->state; // GdkModifierType mirrors xlib state masks

    xEvent.xkey.keycode = gdkEvent->hardware_keycode;

    xEvent.xkey.same_screen = true;

    // NOTE: As the XEvents sent to the plug-in are synthesized and there is not a native window

    // corresponding to the plug-in rectangle, some of the members of the XEvent structures are not

    // set to their normal Xserver values. e.g. Key events don't have a position.

    // source: https://developer.mozilla.org/en/NPEvent

    xEvent.xkey.x = 0;

    xEvent.xkey.y = 0;

    xEvent.xkey.x_root = 0;

    xEvent.xkey.y_root = 0;

#endif

    if (!dispatchNPEvent(xEvent))

        event->setDefaultHandled();

}

#if defined(XP_UNIX)

static unsigned int inputEventState(MouseEvent* event)

{

    unsigned int state = 0;

    if (event->ctrlKey())

        state |= ControlMask;

    if (event->shiftKey())

        state |= ShiftMask;

    if (event->altKey())

        state |= Mod1Mask;

    if (event->metaKey())

        state |= Mod4Mask;

    return state;

}

void PluginView::initXEvent(XEvent* xEvent)

{

    memset(xEvent, 0, sizeof(XEvent));

    xEvent->xany.serial = 0; // we are unaware of the last request processed by X Server

    xEvent->xany.send_event = false;

    xEvent->xany.display = GDK_DISPLAY();

    // NOTE: event->xany.window doesn't always correspond to the .window property of other XEvent's

    // but does in the case of KeyPress, KeyRelease, ButtonPress, ButtonRelease, and MotionNotify

    // events; thus, this is right:

    GtkWidget* widget = m_parentFrame->view()->hostWindow()->platformPageClient();

    xEvent->xany.window = widget ? GDK_WINDOW_XWINDOW(gtk_widget_get_window(widget)) : 0;

}

static void setXButtonEventSpecificFields(XEvent* xEvent, MouseEvent* event, const IntPoint& postZoomPos, Frame* parentFrame)

{

    XButtonEvent& xbutton = xEvent->xbutton;

    xbutton.type = event->type() == eventNames().mousedownEvent ? ButtonPress : ButtonRelease;

    xbutton.root = getRootWindow(parentFrame);

    xbutton.subwindow = 0;

    xbutton.time = event->timeStamp();

    xbutton.x = postZoomPos.x();

    xbutton.y = postZoomPos.y();

    xbutton.x_root = event->screenX();

    xbutton.y_root = event->screenY();

    xbutton.state = inputEventState(event);

    switch (event->button()) {

    case MiddleButton:

        xbutton.button = Button2;

        break;

    case RightButton:

        xbutton.button = Button3;

        break;

    case LeftButton:

    default:

        xbutton.button = Button1;

        break;

    }

    xbutton.same_screen = true;

}

static void setXMotionEventSpecificFields(XEvent* xEvent, MouseEvent* event, const IntPoint& postZoomPos, Frame* parentFrame)

{

    XMotionEvent& xmotion = xEvent->xmotion;

    xmotion.type = MotionNotify;

    xmotion.root = getRootWindow(parentFrame);

    xmotion.subwindow = 0;

    xmotion.time = event->timeStamp();

    xmotion.x = postZoomPos.x();

    xmotion.y = postZoomPos.y();

    xmotion.x_root = event->screenX();

    xmotion.y_root = event->screenY();

    xmotion.state = inputEventState(event);

    xmotion.is_hint = NotifyNormal;

    xmotion.same_screen = true;

}

static void setXCrossingEventSpecificFields(XEvent* xEvent, MouseEvent* event, const IntPoint& postZoomPos, Frame* parentFrame)

{

    XCrossingEvent& xcrossing = xEvent->xcrossing;

    xcrossing.type = event->type() == eventNames().mouseoverEvent ? EnterNotify : LeaveNotify;

    xcrossing.root = getRootWindow(parentFrame);

    xcrossing.subwindow = 0;

    xcrossing.time = event->timeStamp();

    xcrossing.x = postZoomPos.y();

    xcrossing.y = postZoomPos.x();

    xcrossing.x_root = event->screenX();

    xcrossing.y_root = event->screenY();

    xcrossing.state = inputEventState(event);

    xcrossing.mode = NotifyNormal;

    xcrossing.detail = NotifyDetailNone;

    xcrossing.same_screen = true;

    xcrossing.focus = false;

}

#endif

void PluginView::handleMouseEvent(MouseEvent* event)

{

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

    if (m_isWindowed)

        return;

    NPEvent xEvent;

#if defined(XP_UNIX)

    initXEvent(&xEvent);

    IntPoint postZoomPos = roundedIntPoint(m_element->renderer()->absoluteToLocal(event->absoluteLocation()));

    if (event->type() == eventNames().mousedownEvent || event->type() == eventNames().mouseupEvent)

        setXButtonEventSpecificFields(&xEvent, event, postZoomPos, m_parentFrame.get());

    else if (event->type() == eventNames().mousemoveEvent)

        setXMotionEventSpecificFields(&xEvent, event, postZoomPos, m_parentFrame.get());

    else if (event->type() == eventNames().mouseoutEvent || event->type() == eventNames().mouseoverEvent)

        setXCrossingEventSpecificFields(&xEvent, event, postZoomPos, m_parentFrame.get());

    else

        return;

#endif

    if (!dispatchNPEvent(xEvent))

        event->setDefaultHandled();

}

#if defined(XP_UNIX)

void PluginView::handleFocusInEvent()

{

    XEvent npEvent;

    initXEvent(&npEvent);

    XFocusChangeEvent& event = npEvent.xfocus;

    event.type = 9; // FocusIn gets unset somewhere

    event.mode = NotifyNormal;

    event.detail = NotifyDetailNone;

    dispatchNPEvent(npEvent);

}

void PluginView::handleFocusOutEvent()

{

    XEvent npEvent;

    initXEvent(&npEvent);

    XFocusChangeEvent& event = npEvent.xfocus;

    event.type = 10; // FocusOut gets unset somewhere

    event.mode = NotifyNormal;

    event.detail = NotifyDetailNone;

    dispatchNPEvent(npEvent);

}

#endif

void PluginView::setParent(ScrollView* parent)

{

    Widget::setParent(parent);

    if (parent)

        init();

}

void PluginView::setNPWindowRect(const IntRect&)

{

    if (!m_isWindowed)

        setNPWindowIfNeeded();

}

void PluginView::setNPWindowIfNeeded()

{

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

        return;

    // If the plugin didn't load sucessfully, no point in calling setwindow

    if (m_status != PluginStatusLoadedSuccessfully)

        return;

    // On Unix, only call plugin's setwindow if it's full-page or windowed

    if (m_mode != NP_FULL && m_mode != NP_EMBED)

        return;

    // Check if the platformPluginWidget still exists

    if (m_isWindowed && !platformPluginWidget())

        return;

    if (m_isWindowed) {

        m_npWindow.x = m_windowRect.x();

        m_npWindow.y = m_windowRect.y();

        m_npWindow.width = m_windowRect.width();

        m_npWindow.height = m_windowRect.height();

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

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

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

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

        GtkAllocation allocation = { m_windowRect.x(), m_windowRect.y(), m_windowRect.width(), m_windowRect.height() };

        gtk_widget_size_allocate(platformPluginWidget(), &allocation);

#if defined(XP_UNIX)

        if (!m_needsXEmbed) {

            gtk_xtbin_set_position(GTK_XTBIN(platformPluginWidget()), m_windowRect.x(), m_windowRect.y());

            gtk_xtbin_resize(platformPluginWidget(), m_windowRect.width(), m_windowRect.height());

        }

#endif

    } else {

        m_npWindow.x = 0;

        m_npWindow.y = 0;

        m_npWindow.width = m_windowRect.width();

        m_npWindow.height = m_windowRect.height();

        m_npWindow.clipRect.left = 0;

        m_npWindow.clipRect.top = 0;