/* * 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 "BridgeJSC.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 "RenderObject.h" #include "ScriptController.h" #include "Settings.h" #include "WheelEvent.h" #include "npruntime_impl.h" #include "runtime_root.h" #include <runtime/JSLock.h> #include <runtime/JSCJSValue.h> #include <wtf/RetainPtr.h> using JSC::ExecState; using JSC::Interpreter; using JSC::JSLock; using JSC::JSObject; using JSC::JSValue; #if PLATFORM(QT) #include <QPainter> #endif using namespace WTF; namespace WebCore { using namespace HTMLNames; // --------- Cocoa specific utility functions ---------- static void initializeNPCocoaEvent(NPCocoaEvent* event) { memset(event, 0, sizeof(NPCocoaEvent)); } static int32_t getModifiers(UIEventWithKeyState *event) { int32_t modifiers = 0; if (event->keyCode() == 57) modifiers |= NSAlphaShiftKeyMask; if (event->shiftKey()) modifiers |= NSShiftKeyMask; if (event->ctrlKey()) modifiers |= NSControlKeyMask; if (event->metaKey()) modifiers |= NSCommandKeyMask; if (event->altKey()) modifiers |= NSAlternateKeyMask; return modifiers; } static CGContextRef createBitmapContext(const IntSize& size) { CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB(); uint flags = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host; CGContextRef context = CGBitmapContextCreate(0, size.width(), size.height(), 8, 4 * size.width(), colorspace, flags); CGContextTranslateCTM(context, 0, size.height()); CGContextScaleCTM(context, 1, -1); CGColorSpaceRelease(colorspace); return context; } // --------------- Lifetime management ----------------- bool PluginView::platformStart() { ASSERT(m_isStarted); ASSERT(m_status == PluginStatusLoadedSuccessfully); // 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. NPBool eventModelSupported; if (getValueStatic(NPNVariable(NPNVsupportsCocoaBool), &eventModelSupported) != NPERR_NO_ERROR || !eventModelSupported) { m_status = PluginStatusCanNotLoadPlugin; LOG(Plugins, "Plug-in '%s' uses unsupported event model %s", m_plugin->name().utf8().data(), prettyNameForEventModel(NPEventModelCocoa)); return false; } updatePluginWidget(); if (!m_plugin->quirks().contains(PluginQuirkDeferFirstSetWindowCall)) setNPWindowIfNeeded(); return true; } void PluginView::platformDestroy() { CGContextRelease(m_contextRef); } // 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; case NPNVsupportsCocoaBool: *static_cast<NPBool*>(value) = true; *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; case NPNVsupportsAdvancedKeyHandling: *static_cast<NPBool*>(value) = true; *result = NPERR_NO_ERROR; return true; 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) { // In WebKit2, this is set if the plugin queries it's availiablity and // no key down events have already been sent. if (variable == NPNVsupportsUpdatedCocoaTextInputBool) { if (m_keyDownSent && !m_updatedCocoaTextInputRequested) { *static_cast<NPBool*>(value) = false; *error = NPERR_NO_ERROR; } else { *static_cast<NPBool*>(value) = true; *error = NPERR_NO_ERROR; m_updatedCocoaTextInputRequested = true; } return true; } 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); Widget::setFocus(focused); NPCocoaEvent cocoaEvent; initializeNPCocoaEvent(&cocoaEvent); cocoaEvent.type = NPCocoaEventFocusChanged; NPBool focus = focused; cocoaEvent.data.focus.hasFocus = focus; if(!dispatchNPCocoaEvent(cocoaEvent)) { LOG(Events, "PluginView::setFocus(): Focus event %d not accepted", cocoaEvent.type); } } 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 || !m_contextRef) return; // The context is set through the draw event. ASSERT(!m_npCgContext.context && !m_npCgContext.window); m_npWindow.window = (void*)&m_npCgContext; m_npWindow.type = NPWindowTypeDrawable; 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_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(): context=%p," " window.x:%d window.y:%d window.width:%d window.height:%d window.clipRect size:%dx%d", m_contextRef, 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(JSDOMWindowBase::commonVM()); 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 = toFrameView(parent()); IntRect oldWindowRect = m_windowRect; m_windowRect = frameView->contentsToWindow(frameRect()); if (m_windowRect.size() != oldWindowRect.size()) { CGContextRelease(m_contextRef); m_contextRef = createBitmapContext(m_windowRect.size()); CGContextClearRect(m_contextRef, CGRectMake(0, 0, m_windowRect.width(), m_windowRect.height())); } if (m_windowRect != oldWindowRect) setNPWindowIfNeeded(); } void PluginView::paint(GraphicsContext* context, const IntRect& rect) { if (!m_isStarted || m_status != PluginStatusLoadedSuccessfully) { paintMissingPluginIcon(context, rect); return; } if (context->paintingDisabled() || !m_contextRef) return; CGContextSaveGState(m_contextRef); 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(m_contextRef, r); if (m_isTransparent) { // Clean the pixmap in transparent mode. CGContextClearRect(m_contextRef, CGRectMake(r.origin.x, r.origin.y, r.size.width, r.size.height)); } NPCocoaEvent cocoaEvent; initializeNPCocoaEvent(&cocoaEvent); cocoaEvent.type = NPCocoaEventDrawRect; cocoaEvent.data.draw.x = 0; cocoaEvent.data.draw.y = 0; cocoaEvent.data.draw.width = CGBitmapContextGetWidth(m_contextRef); cocoaEvent.data.draw.height = CGBitmapContextGetHeight(m_contextRef); cocoaEvent.data.draw.context = m_contextRef; if(!dispatchNPCocoaEvent(cocoaEvent)) LOG(Events, "PluginView::paint(): Paint event type %d not accepted", cocoaEvent.type); #if PLATFORM(QT) // Paint the intermediate bitmap into our graphics context. ASSERT(CGBitmapContextGetBitmapInfo(m_contextRef) & (kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host)); ASSERT(CGBitmapContextGetBitsPerPixel(m_contextRef) == 32); const uint8_t* data = reinterpret_cast<const uint8_t*>(CGBitmapContextGetData(m_contextRef)); size_t width = CGBitmapContextGetWidth(m_contextRef); size_t height = CGBitmapContextGetHeight(m_contextRef); const QImage imageFromBitmap(data, width, height, QImage::Format_ARGB32_Premultiplied); QPainter* painter = context->platformContext(); painter->drawImage(targetRect.x(), targetRect.y(), imageFromBitmap, targetRect.x() - frameRect().x(), targetRect.y() - frameRect().y(), targetRect.width(), targetRect.height()); #endif CGContextRestoreGState(m_contextRef); } bool PluginView::popUpContextMenu(NPMenu *menu) { NSEvent* currentEvent = [NSApp currentEvent]; // NPN_PopUpContextMenu must be called from within the plug-in's NPP_HandleEvent. if (!currentEvent) return NPERR_GENERIC_ERROR; NSWindow* window = [currentEvent window]; NSView* view = [window contentView]; [NSMenu popUpContextMenu:(NSMenu*)menu withEvent:currentEvent forView:view]; return true; } void PluginView::invalidateRect(const IntRect& rect) { invalidateWindowlessPluginRect(rect); } void PluginView::invalidateRect(NPRect* rect) { IntRect r(rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top); invalidateRect(r); } void PluginView::invalidateRegion(NPRegion region) { // TODO: optimize invalidate(); } void PluginView::forceRedraw() { notImplemented(); } // ----------------- Event handling -------------------- void PluginView::handleWheelEvent(WheelEvent *event) { if (!m_isStarted) return; NPCocoaEvent cocoaEvent; initializeNPCocoaEvent(&cocoaEvent); NSEvent *currentEvent = [NSApp currentEvent]; cocoaEvent.type = NPCocoaEventScrollWheel; cocoaEvent.data.mouse.pluginX = event->layerX() - m_npWindow.x + m_windowRect.x() - m_element->offsetLeft(); cocoaEvent.data.mouse.pluginY = event->layerY() - m_npWindow.y + m_windowRect.y() - m_element->offsetTop(); cocoaEvent.data.mouse.deltaX = [currentEvent deltaX]; cocoaEvent.data.mouse.deltaY = [currentEvent deltaY]; cocoaEvent.data.mouse.deltaZ = [currentEvent deltaZ]; cocoaEvent.data.mouse.modifierFlags = getModifiers(event); if(!dispatchNPCocoaEvent(cocoaEvent)) { LOG(Events, "PluginView::handleMouseEvent(): Wheel event type %d at %d,%d not accepted", cocoaEvent.type, cocoaEvent.data.mouse.pluginX, cocoaEvent.data.mouse.pluginY); } event->setDefaultHandled(); } void PluginView::handleMouseEvent(MouseEvent* event) { if (!m_isStarted) return; NPCocoaEventType eventType; int32_t buttonNumber = 0; int32_t clickCount = 0; NSEvent *currentEvent = [NSApp currentEvent]; NSEventType type = [currentEvent type]; switch (type) { case NSLeftMouseDown: case NSRightMouseDown: case NSOtherMouseDown: buttonNumber = [currentEvent buttonNumber]; clickCount = [currentEvent clickCount]; eventType = NPCocoaEventMouseDown; // The plugin needs focus to receive keyboard events if (Page* page = m_parentFrame->page()) page->focusController()->setFocusedFrame(m_parentFrame); m_parentFrame->document()->setFocusedElement(m_element); break; case NSLeftMouseUp: case NSRightMouseUp: case NSOtherMouseUp: buttonNumber = [currentEvent buttonNumber]; clickCount = [currentEvent clickCount]; eventType = NPCocoaEventMouseUp; break; case NSMouseMoved: eventType = NPCocoaEventMouseMoved; break; case NSLeftMouseDragged: case NSRightMouseDragged: case NSOtherMouseDragged: buttonNumber = [currentEvent buttonNumber]; eventType = NPCocoaEventMouseDragged; break; case NSMouseEntered: eventType = NPCocoaEventMouseEntered; break; case NSMouseExited: eventType = NPCocoaEventMouseExited; default: return; } NPCocoaEvent cocoaEvent; initializeNPCocoaEvent(&cocoaEvent); cocoaEvent.type = eventType; if (!(NPCocoaEventMouseEntered == eventType || NPCocoaEventMouseExited == eventType)) { cocoaEvent.data.mouse.buttonNumber = buttonNumber; cocoaEvent.data.mouse.clickCount = clickCount; } cocoaEvent.data.mouse.pluginX = event->layerX() - m_npWindow.x + m_windowRect.x() - m_element->offsetLeft(); cocoaEvent.data.mouse.pluginY = event->layerY() - m_npWindow.y + m_windowRect.y() - m_element->offsetTop(); cocoaEvent.data.mouse.deltaX = [currentEvent deltaX]; cocoaEvent.data.mouse.deltaY = [currentEvent deltaY]; cocoaEvent.data.mouse.deltaZ = [currentEvent deltaZ]; cocoaEvent.data.mouse.modifierFlags = getModifiers(event); int16_t response = dispatchNPCocoaEvent(cocoaEvent); if(response == kNPEventNotHandled) { LOG(Events, "PluginView::handleMouseEvent(): Mouse event type %d at %d,%d not accepted", cocoaEvent.type, cocoaEvent.data.mouse.pluginX, cocoaEvent.data.mouse.pluginY); } // Safari policy is to return true for all mouse events, because some plugins // return false even if they have handled the event. event->setDefaultHandled(); } void PluginView::handleKeyboardEvent(KeyboardEvent* event) { if (!m_isStarted) return; LOG(Plugins, "PluginView::handleKeyboardEvent() ----------------- "); LOG(Plugins, "PV::hKE(): KE.keyCode: 0x%02X, KE.charCode: %d", event->keyCode(), event->charCode()); NSEvent *currentEvent = [NSApp currentEvent]; NPCocoaEventType eventType; NSEventType type = [currentEvent type]; switch (type) { case NSKeyDown: eventType = NPCocoaEventKeyDown; m_keyDownSent = true; break; case NSKeyUp: if (m_disregardKeyUpCounter > 0) { m_disregardKeyUpCounter--; event->setDefaultHandled(); return; } eventType = NPCocoaEventKeyUp; break; case NSFlagsChanged: eventType = NPCocoaEventFlagsChanged; break; default: return; } NPCocoaEvent cocoaEvent; initializeNPCocoaEvent(&cocoaEvent); cocoaEvent.type = eventType; if (eventType != NPCocoaEventFlagsChanged) { NSString *characters = [currentEvent characters]; NSString *charactersIgnoringModifiers = [currentEvent charactersIgnoringModifiers]; cocoaEvent.data.key.characters = reinterpret_cast<NPNSString*>(characters); cocoaEvent.data.key.charactersIgnoringModifiers = reinterpret_cast<NPNSString*>(charactersIgnoringModifiers); cocoaEvent.data.key.isARepeat = [currentEvent isARepeat]; cocoaEvent.data.key.keyCode = [currentEvent keyCode]; cocoaEvent.data.key.modifierFlags = getModifiers(event); } int16_t response = dispatchNPCocoaEvent(cocoaEvent); if(response == kNPEventNotHandled) { LOG(Events, "PluginView::handleKeyboardEvent(): Keyboard event type %d not accepted", cocoaEvent.type); } else if (response == kNPEventStartIME) { // increment counter and resend as a text input m_disregardKeyUpCounter++; NPCocoaEvent textEvent; initializeNPCocoaEvent(&textEvent); textEvent.type = NPCocoaEventTextInput; textEvent.data.text.text = reinterpret_cast<NPNSString*>([currentEvent characters]); response = dispatchNPCocoaEvent(textEvent); if(response == kNPEventNotHandled) LOG(Events, "PluginView::handleKeyboardEvent(): Keyboard event type %d not accepted", cocoaEvent.type); } // All keyboard events need to be handled to prevent them falling // through to the page, unless they are Meta key events, in which // case they are, unless they are Cmd+a. From WebKit2, possibly // not the most elegant piece of key handling code..... if (event->metaKey()) { if (cocoaEvent.data.key.keyCode == 0) event->setDefaultHandled(); } else { // else ignore, it's a Meta Key event for the browser. event->setDefaultHandled(); } } int16_t PluginView::dispatchNPCocoaEvent(NPCocoaEvent& cocoaEvent) { PluginView::setCurrentPluginView(this); JSC::JSLock::DropAllLocks dropAllLocks(JSDOMWindowBase::commonVM()); setCallingPlugin(true); int16_t response = m_plugin->pluginFuncs()->event(m_instance, &cocoaEvent); setCallingPlugin(false); PluginView::setCurrentPluginView(0); return response; } // ------------------- Miscellaneous ------------------ NPError PluginView::handlePostReadFile(Vector<char>& buffer, uint32_t len, const char* buf) { String filename(buf, len); if (filename.startsWith("file:///")) filename = filename.substring(8); if (!fileExists(filename)) return NPERR_FILE_NOT_FOUND; FILE* fileHandle = fopen((filename.utf8()).data(), "r"); if (fileHandle == 0) return NPERR_FILE_NOT_FOUND; int bytesRead = fread(buffer.data(), 1, 0, fileHandle); fclose(fileHandle); if (bytesRead <= 0) return NPERR_FILE_NOT_FOUND; return NPERR_NO_ERROR; } } // namespace WebCore