2011-05-02 Robert Hogan <robert@webkit.org>
[WebKit-https.git] / Source / WebCore / plugins / qt / PluginViewQt.cpp
1 /*
2  * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.
3  * Copyright (C) 2008 Collabora Ltd. All rights reserved.
4  * Copyright (C) 2009 Girish Ramakrishnan <girish@forwardbias.in>
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
26  */
27
28 #include "config.h"
29 #include "PluginView.h"
30
31 #if USE(JSC)
32 #include "BridgeJSC.h"
33 #endif
34 #include "Chrome.h"
35 #include "ChromeClient.h"
36 #include "Document.h"
37 #include "DocumentLoader.h"
38 #include "Element.h"
39 #include "FloatPoint.h"
40 #include "FocusController.h"
41 #include "Frame.h"
42 #include "FrameLoadRequest.h"
43 #include "FrameLoader.h"
44 #include "FrameTree.h"
45 #include "FrameView.h"
46 #include "GraphicsContext.h"
47 #include "HTMLNames.h"
48 #include "HTMLPlugInElement.h"
49 #include "HostWindow.h"
50 #include "IFrameShimSupport.h"
51 #include "Image.h"
52 #if USE(JSC)
53 #include "JSDOMBinding.h"
54 #endif
55 #include "KeyboardEvent.h"
56 #include "MouseEvent.h"
57 #include "NotImplemented.h"
58 #include "Page.h"
59 #include "PlatformMouseEvent.h"
60 #include "PlatformKeyboardEvent.h"
61 #include "PluginContainerQt.h"
62 #include "PluginDebug.h"
63 #include "PluginPackage.h"
64 #include "PluginMainThreadScheduler.h"
65 #include "QWebPageClient.h"
66 #include "RenderLayer.h"
67 #include "Settings.h"
68 #include "npruntime_impl.h"
69 #include "qwebpage_p.h"
70 #if USE(JSC)
71 #include "runtime_root.h"
72 #endif
73
74 #include <QApplication>
75 #include <QDesktopWidget>
76 #include <QGraphicsWidget>
77 #include <QKeyEvent>
78 #include <QPainter>
79 #include <QStyleOptionGraphicsItem>
80 #include <QWidget>
81 #include <QX11Info>
82 #include <X11/X.h>
83 #ifndef QT_NO_XRENDER
84 #define Bool int
85 #define Status int
86 #include <X11/extensions/Xrender.h>
87 #endif
88 #include <runtime/JSLock.h>
89 #include <runtime/JSValue.h>
90
91 using JSC::ExecState;
92 #if USE(JSC)
93 using JSC::Interpreter;
94 #endif
95 using JSC::JSLock;
96 using JSC::JSObject;
97 using JSC::UString;
98
99 using std::min;
100
101 using namespace WTF;
102
103 namespace WebCore {
104
105 using namespace HTMLNames;
106
107 #if USE(ACCELERATED_COMPOSITING)
108 // Qt's GraphicsLayer (GraphicsLayerQt) requires layers to be QGraphicsWidgets
109 class PluginGraphicsLayerQt : public QGraphicsWidget {
110 public:
111     PluginGraphicsLayerQt(PluginView* view) : m_view(view) { }
112     ~PluginGraphicsLayerQt() { }
113
114     void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0)
115     {
116         Q_UNUSED(widget);
117         m_view->paintUsingXPixmap(painter, option->exposedRect.toRect());
118     }
119
120 private:
121     PluginView* m_view;
122 };
123 #endif
124
125 void PluginView::updatePluginWidget()
126 {
127     if (!parent())
128         return;
129
130     ASSERT(parent()->isFrameView());
131     FrameView* frameView = static_cast<FrameView*>(parent());
132
133     IntRect oldWindowRect = m_windowRect;
134     IntRect oldClipRect = m_clipRect;
135
136     m_windowRect = IntRect(frameView->contentsToWindow(frameRect().location()), frameRect().size());
137     m_clipRect = windowClipRect();
138     m_clipRect.move(-m_windowRect.x(), -m_windowRect.y());
139
140     if (m_windowRect == oldWindowRect && m_clipRect == oldClipRect)
141         return;
142
143     // The plugin had a zero width or height before but was resized, we need to show it again.
144     if (oldWindowRect.isEmpty())
145         show();
146
147     if (!m_isWindowed && m_windowRect.size() != oldWindowRect.size()) {
148 #if defined(MOZ_PLATFORM_MAEMO) && (MOZ_PLATFORM_MAEMO >= 5)
149         // On Maemo5, Flash always renders to 16-bit buffer
150         if (m_renderToImage)
151             m_image = QImage(m_windowRect.width(), m_windowRect.height(), QImage::Format_RGB16);
152         else
153 #endif
154         {
155             if (m_drawable)
156                 XFreePixmap(QX11Info::display(), m_drawable);
157
158             m_drawable = XCreatePixmap(QX11Info::display(), QX11Info::appRootWindow(), m_windowRect.width(), m_windowRect.height(), 
159                                        ((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->depth);
160             QApplication::syncX(); // make sure that the server knows about the Drawable
161         }
162     }
163
164     // do not call setNPWindowIfNeeded immediately, will be called on paint()
165     m_hasPendingGeometryChange = true;
166
167     // (i) in order to move/resize the plugin window at the same time as the
168     // rest of frame during e.g. scrolling, we set the window geometry
169     // in the paint() function, but as paint() isn't called when the
170     // plugin window is outside the frame which can be caused by a
171     // scroll, we need to move/resize immediately.
172     // (ii) if we are running layout tests from DRT, paint() won't ever get called
173     // so we need to call setNPWindowIfNeeded() if window geometry has changed
174     if (!m_windowRect.intersects(frameView->frameRect())
175         || (QWebPagePrivate::drtRun && platformPluginWidget() && (m_windowRect != oldWindowRect || m_clipRect != oldClipRect)))
176         setNPWindowIfNeeded();
177
178     if (!m_platformLayer) {
179         // Make sure we get repainted afterwards. This is necessary for downward
180         // scrolling to move the plugin widget properly.
181         // Note that we don't invalidate the frameRect() here. This is because QWebFrame::renderRelativeCoords()
182         // imitates ScrollView and adds the scroll offset back on to the rect we damage here (making the co-ordinates absolute
183         // to the frame again) before passing it to FrameView.
184         invalidate();
185     }
186 }
187
188 void PluginView::setFocus(bool focused)
189 {
190     if (platformPluginWidget()) {
191         if (focused)
192             platformPluginWidget()->setFocus(Qt::OtherFocusReason);
193     } else {
194         Widget::setFocus(focused);
195     }
196 }
197
198 void PluginView::show()
199 {
200     Q_ASSERT(platformPluginWidget() == platformWidget());
201     Widget::show();
202 }
203
204 void PluginView::hide()
205 {
206     Q_ASSERT(platformPluginWidget() == platformWidget());
207     Widget::hide();
208 }
209
210 #if defined(MOZ_PLATFORM_MAEMO) && (MOZ_PLATFORM_MAEMO >= 5)
211 void PluginView::paintUsingImageSurfaceExtension(QPainter* painter, const IntRect& exposedRect)
212 {
213     NPImageExpose imageExpose;
214     QPoint offset;
215     QWebPageClient* client = m_parentFrame->view()->hostWindow()->platformPageClient();
216     const bool surfaceHasUntransformedContents = client && qobject_cast<QWidget*>(client->pluginParent());
217
218     QPaintDevice* surface =  QPainter::redirected(painter->device(), &offset);
219
220     // If the surface is a QImage, we can render directly into it
221     if (surfaceHasUntransformedContents && surface && surface->devType() == QInternal::Image) {
222         QImage* image = static_cast<QImage*>(surface);
223         offset = -offset; // negating the offset gives us the offset of the view within the surface
224         imageExpose.data = reinterpret_cast<char*>(image->bits());
225         imageExpose.dataSize.width = image->width();
226         imageExpose.dataSize.height = image->height();
227         imageExpose.stride = image->bytesPerLine();
228         imageExpose.depth = image->depth(); // this is guaranteed to be 16 on Maemo5
229         imageExpose.translateX = offset.x() + m_windowRect.x();
230         imageExpose.translateY = offset.y() + m_windowRect.y();
231         imageExpose.scaleX = 1;
232         imageExpose.scaleY = 1;
233     } else {
234         if (m_isTransparent) {
235             // On Maemo5, Flash expects the buffer to contain the contents that are below it.
236             // We don't support transparency for non-raster graphicssystem, so clean the image 
237             // before giving to Flash.
238             QPainter imagePainter(&m_image);
239             imagePainter.fillRect(exposedRect, Qt::white);
240         }
241
242         imageExpose.data = reinterpret_cast<char*>(m_image.bits());
243         imageExpose.dataSize.width = m_image.width();
244         imageExpose.dataSize.height = m_image.height();
245         imageExpose.stride = m_image.bytesPerLine();
246         imageExpose.depth = m_image.depth();
247         imageExpose.translateX = 0;
248         imageExpose.translateY = 0;
249         imageExpose.scaleX = 1;
250         imageExpose.scaleY = 1;
251     }
252     imageExpose.x = exposedRect.x();
253     imageExpose.y = exposedRect.y();
254     imageExpose.width = exposedRect.width();
255     imageExpose.height = exposedRect.height();
256
257     XEvent xevent;
258     memset(&xevent, 0, sizeof(XEvent));
259     XGraphicsExposeEvent& exposeEvent = xevent.xgraphicsexpose;
260     exposeEvent.type = GraphicsExpose;
261     exposeEvent.display = 0;
262     exposeEvent.drawable = reinterpret_cast<XID>(&imageExpose);
263     exposeEvent.x = exposedRect.x();
264     exposeEvent.y = exposedRect.y();
265     exposeEvent.width = exposedRect.width();
266     exposeEvent.height = exposedRect.height();
267
268     dispatchNPEvent(xevent);
269
270     if (!surfaceHasUntransformedContents || !surface || surface->devType() != QInternal::Image)
271         painter->drawImage(QPoint(frameRect().x() + exposedRect.x(), frameRect().y() + exposedRect.y()), m_image, exposedRect);
272 }
273 #endif
274
275 void PluginView::paintUsingXPixmap(QPainter* painter, const QRect &exposedRect)
276 {
277     QPixmap qtDrawable = QPixmap::fromX11Pixmap(m_drawable, QPixmap::ExplicitlyShared);
278     const int drawableDepth = ((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->depth;
279     ASSERT(drawableDepth == qtDrawable.depth());
280     const bool syncX = m_pluginDisplay && m_pluginDisplay != QX11Info::display();
281
282     // When printing, Qt uses a QPicture to capture the output in preview mode. The
283     // QPicture holds a reference to the X Pixmap. As a result, the print preview would
284     // update itself when the X Pixmap changes. To prevent this, we create a copy.
285     if (m_element->document()->printing())
286         qtDrawable = qtDrawable.copy();
287
288     if (m_isTransparent && drawableDepth != 32) {
289         // Attempt content propagation for drawable with no alpha by copying over from the backing store
290         QPoint offset;
291         QPaintDevice* backingStoreDevice =  QPainter::redirected(painter->device(), &offset);
292         offset = -offset; // negating the offset gives us the offset of the view within the backing store pixmap
293
294         const bool hasValidBackingStore = backingStoreDevice && backingStoreDevice->devType() == QInternal::Pixmap;
295         QPixmap* backingStorePixmap = static_cast<QPixmap*>(backingStoreDevice);
296
297         // We cannot grab contents from the backing store when painting on QGraphicsView items
298         // (because backing store contents are already transformed). What we really mean to do 
299         // here is to check if we are painting on QWebView, but let's be a little permissive :)
300         QWebPageClient* client = m_parentFrame->view()->hostWindow()->platformPageClient();
301         const bool backingStoreHasUntransformedContents = client && qobject_cast<QWidget*>(client->pluginParent());
302
303         if (hasValidBackingStore && backingStorePixmap->depth() == drawableDepth 
304             && backingStoreHasUntransformedContents) {
305             GC gc = XDefaultGC(QX11Info::display(), QX11Info::appScreen());
306             XCopyArea(QX11Info::display(), backingStorePixmap->handle(), m_drawable, gc,
307                 offset.x() + m_windowRect.x() + exposedRect.x(), offset.y() + m_windowRect.y() + exposedRect.y(),
308                 exposedRect.width(), exposedRect.height(), exposedRect.x(), exposedRect.y());
309         } else { // no backing store, clean the pixmap because the plugin thinks its transparent
310             QPainter painter(&qtDrawable);
311             painter.fillRect(exposedRect, Qt::white);
312         }
313
314         if (syncX)
315             QApplication::syncX();
316     }
317
318     XEvent xevent;
319     memset(&xevent, 0, sizeof(XEvent));
320     XGraphicsExposeEvent& exposeEvent = xevent.xgraphicsexpose;
321     exposeEvent.type = GraphicsExpose;
322     exposeEvent.display = QX11Info::display();
323     exposeEvent.drawable = qtDrawable.handle();
324     exposeEvent.x = exposedRect.x();
325     exposeEvent.y = exposedRect.y();
326     exposeEvent.width = exposedRect.x() + exposedRect.width(); // flash bug? it thinks width is the right in transparent mode
327     exposeEvent.height = exposedRect.y() + exposedRect.height(); // flash bug? it thinks height is the bottom in transparent mode
328
329     dispatchNPEvent(xevent);
330
331     if (syncX)
332         XSync(m_pluginDisplay, false); // sync changes by plugin
333
334     painter->drawPixmap(QPoint(exposedRect.x(), exposedRect.y()), qtDrawable, exposedRect);
335 }
336
337 void PluginView::paint(GraphicsContext* context, const IntRect& rect)
338 {
339     if (!m_isStarted) {
340         paintMissingPluginIcon(context, rect);
341         return;
342     }
343
344     if (context->paintingDisabled())
345         return;
346
347     setNPWindowIfNeeded();
348
349     if (m_isWindowed)
350         return;
351
352 #if USE(ACCELERATED_COMPOSITING)
353     if (m_platformLayer)
354         return;
355 #endif
356
357     if (!m_drawable
358 #if defined(MOZ_PLATFORM_MAEMO) && (MOZ_PLATFORM_MAEMO >= 5)
359         && m_image.isNull()
360 #endif
361        )
362         return;
363
364     QPainter* painter = context->platformContext();
365     IntRect exposedRect(rect);
366     exposedRect.intersect(frameRect());
367     exposedRect.move(-frameRect().x(), -frameRect().y());
368
369 #if defined(MOZ_PLATFORM_MAEMO) && (MOZ_PLATFORM_MAEMO >= 5)
370     if (!m_image.isNull()) {
371         paintUsingImageSurfaceExtension(painter, exposedRect);
372         return;
373     }
374 #endif
375
376     painter->translate(frameRect().x(), frameRect().y());
377     paintUsingXPixmap(painter, exposedRect);
378     painter->translate(-frameRect().x(), -frameRect().y());
379 }
380
381 // TODO: Unify across ports.
382 bool PluginView::dispatchNPEvent(NPEvent& event)
383 {
384     if (!m_plugin->pluginFuncs()->event)
385         return false;
386
387     bool shouldPop = false;
388
389     if (m_plugin->pluginFuncs()->version < NPVERS_HAS_POPUPS_ENABLED_STATE
390         && (event.type == ButtonRelease || event.type == 3 /*KeyRelease*/)) {
391         pushPopupsEnabledState(true);
392         shouldPop = true;
393     }
394
395     PluginView::setCurrentPluginView(this);
396 #if USE(JSC)
397     JSC::JSLock::DropAllLocks dropAllLocks(JSC::SilenceAssertionsOnly);
398 #endif
399     setCallingPlugin(true);
400     bool accepted = m_plugin->pluginFuncs()->event(m_instance, &event);
401     setCallingPlugin(false);
402     PluginView::setCurrentPluginView(0);
403
404     if (shouldPop)
405         popPopupsEnabledState();
406
407     return accepted;
408 }
409
410 void setSharedXEventFields(XEvent* xEvent, QWidget* ownerWidget)
411 {
412     xEvent->xany.serial = 0; // we are unaware of the last request processed by X Server
413     xEvent->xany.send_event = false;
414     xEvent->xany.display = QX11Info::display();
415     // NOTE: event->xany.window doesn't always respond to the .window property of other XEvent's
416     // but does in the case of KeyPress, KeyRelease, ButtonPress, ButtonRelease, and MotionNotify
417     // events; thus, this is right:
418     xEvent->xany.window = ownerWidget ? ownerWidget->window()->handle() : 0;
419 }
420
421 void PluginView::initXEvent(XEvent* xEvent)
422 {
423     memset(xEvent, 0, sizeof(XEvent));
424
425     QWebPageClient* client = m_parentFrame->view()->hostWindow()->platformPageClient();
426     QWidget* ownerWidget = client ? client->ownerWidget() : 0;
427     setSharedXEventFields(xEvent, ownerWidget);
428 }
429
430 void setXKeyEventSpecificFields(XEvent* xEvent, KeyboardEvent* event)
431 {
432     const PlatformKeyboardEvent* keyEvent = event->keyEvent();
433
434     xEvent->type = (event->type() == eventNames().keydownEvent) ? 2 : 3; // ints as Qt unsets KeyPress and KeyRelease
435     xEvent->xkey.root = QX11Info::appRootWindow();
436     xEvent->xkey.subwindow = 0; // we have no child window
437     xEvent->xkey.time = event->timeStamp();
438     xEvent->xkey.state = keyEvent->nativeModifiers();
439     xEvent->xkey.keycode = keyEvent->nativeScanCode();
440
441     // We may not have a nativeScanCode() if the key event is from DRT's eventsender. In that
442     // case fetch the XEvent's keycode from the event's text. The only
443     // place this keycode will be used is in webkit_test_plugin_handle_event().
444     // FIXME: Create Qt API so that we can set the appropriate keycode in DRT EventSender instead.
445     if (QWebPagePrivate::drtRun && !xEvent->xkey.keycode) {
446         QKeyEvent* qKeyEvent = keyEvent->qtEvent();
447         ASSERT(qKeyEvent);
448         QString keyText = qKeyEvent->text().left(1);
449         xEvent->xkey.keycode = XKeysymToKeycode(QX11Info::display(), XStringToKeysym(keyText.toUtf8().constData()));
450     }
451
452     xEvent->xkey.same_screen = true;
453
454     // NOTE: As the XEvents sent to the plug-in are synthesized and there is not a native window
455     // corresponding to the plug-in rectangle, some of the members of the XEvent structures are not
456     // set to their normal Xserver values. e.g. Key events don't have a position.
457     // source: https://developer.mozilla.org/en/NPEvent
458     xEvent->xkey.x = 0;
459     xEvent->xkey.y = 0;
460     xEvent->xkey.x_root = 0;
461     xEvent->xkey.y_root = 0;
462 }
463
464 void PluginView::handleKeyboardEvent(KeyboardEvent* event)
465 {
466     if (m_isWindowed)
467         return;
468
469     if (event->type() != eventNames().keydownEvent && event->type() != eventNames().keyupEvent)
470         return;
471
472     XEvent npEvent;
473     initXEvent(&npEvent);
474     setXKeyEventSpecificFields(&npEvent, event);
475
476     if (!dispatchNPEvent(npEvent))
477         event->setDefaultHandled();
478 }
479
480 static unsigned int inputEventState(MouseEvent* event)
481 {
482     unsigned int state = 0;
483     if (event->ctrlKey())
484         state |= ControlMask;
485     if (event->shiftKey())
486         state |= ShiftMask;
487     if (event->altKey())
488         state |= Mod1Mask;
489     if (event->metaKey())
490         state |= Mod4Mask;
491     return state;
492 }
493
494 static void setXButtonEventSpecificFields(XEvent* xEvent, MouseEvent* event, const IntPoint& postZoomPos)
495 {
496     XButtonEvent& xbutton = xEvent->xbutton;
497     xbutton.type = event->type() == eventNames().mousedownEvent ? ButtonPress : ButtonRelease;
498     xbutton.root = QX11Info::appRootWindow();
499     xbutton.subwindow = 0;
500     xbutton.time = event->timeStamp();
501     xbutton.x = postZoomPos.x();
502     xbutton.y = postZoomPos.y();
503     xbutton.x_root = event->screenX();
504     xbutton.y_root = event->screenY();
505     xbutton.state = inputEventState(event);
506     switch (event->button()) {
507     case MiddleButton:
508         xbutton.button = Button2;
509         break;
510     case RightButton:
511         xbutton.button = Button3;
512         break;
513     case LeftButton:
514     default:
515         xbutton.button = Button1;
516         break;
517     }
518     xbutton.same_screen = true;
519 }
520
521 static void setXMotionEventSpecificFields(XEvent* xEvent, MouseEvent* event, const IntPoint& postZoomPos)
522 {
523     XMotionEvent& xmotion = xEvent->xmotion;
524     xmotion.type = MotionNotify;
525     xmotion.root = QX11Info::appRootWindow();
526     xmotion.subwindow = 0;
527     xmotion.time = event->timeStamp();
528     xmotion.x = postZoomPos.x();
529     xmotion.y = postZoomPos.y();
530     xmotion.x_root = event->screenX();
531     xmotion.y_root = event->screenY();
532     xmotion.state = inputEventState(event);
533     xmotion.is_hint = NotifyNormal;
534     xmotion.same_screen = true;
535 }
536
537 static void setXCrossingEventSpecificFields(XEvent* xEvent, MouseEvent* event, const IntPoint& postZoomPos)
538 {
539     XCrossingEvent& xcrossing = xEvent->xcrossing;
540     xcrossing.type = event->type() == eventNames().mouseoverEvent ? EnterNotify : LeaveNotify;
541     xcrossing.root = QX11Info::appRootWindow();
542     xcrossing.subwindow = 0;
543     xcrossing.time = event->timeStamp();
544     xcrossing.x = postZoomPos.y();
545     xcrossing.y = postZoomPos.x();
546     xcrossing.x_root = event->screenX();
547     xcrossing.y_root = event->screenY();
548     xcrossing.state = inputEventState(event);
549     xcrossing.mode = NotifyNormal;
550     xcrossing.detail = NotifyDetailNone;
551     xcrossing.same_screen = true;
552     xcrossing.focus = false;
553 }
554
555 void PluginView::handleMouseEvent(MouseEvent* event)
556 {
557     if (m_isWindowed)
558         return;
559
560     if (event->button() == RightButton && m_plugin->quirks().contains(PluginQuirkIgnoreRightClickInWindowlessMode))
561         return;
562
563     if (event->type() == eventNames().mousedownEvent) {
564         // Give focus to the plugin on click
565         if (Page* page = m_parentFrame->page())
566             page->focusController()->setActive(true);
567
568         focusPluginElement();
569     }
570
571     XEvent npEvent;
572     initXEvent(&npEvent);
573
574     IntPoint postZoomPos = roundedIntPoint(m_element->renderer()->absoluteToLocal(event->absoluteLocation()));
575
576     if (event->type() == eventNames().mousedownEvent || event->type() == eventNames().mouseupEvent)
577         setXButtonEventSpecificFields(&npEvent, event, postZoomPos);
578     else if (event->type() == eventNames().mousemoveEvent)
579         setXMotionEventSpecificFields(&npEvent, event, postZoomPos);
580     else if (event->type() == eventNames().mouseoutEvent || event->type() == eventNames().mouseoverEvent)
581         setXCrossingEventSpecificFields(&npEvent, event, postZoomPos);
582     else
583         return;
584
585     if (!dispatchNPEvent(npEvent))
586         event->setDefaultHandled();
587 }
588
589 void PluginView::handleFocusInEvent()
590 {
591     XEvent npEvent;
592     initXEvent(&npEvent);
593
594     XFocusChangeEvent& event = npEvent.xfocus;
595     event.type = 9; /* int as Qt unsets FocusIn */
596     event.mode = NotifyNormal;
597     event.detail = NotifyDetailNone;
598
599     dispatchNPEvent(npEvent);
600 }
601
602 void PluginView::handleFocusOutEvent()
603 {
604     XEvent npEvent;
605     initXEvent(&npEvent);
606
607     XFocusChangeEvent& event = npEvent.xfocus;
608     event.type = 10; /* int as Qt unsets FocusOut */
609     event.mode = NotifyNormal;
610     event.detail = NotifyDetailNone;
611
612     dispatchNPEvent(npEvent);
613 }
614
615 void PluginView::setParent(ScrollView* parent)
616 {
617     Widget::setParent(parent);
618
619     if (parent)
620         init();
621 }
622
623 void PluginView::setNPWindowRect(const IntRect&)
624 {
625     if (!m_isWindowed)
626         setNPWindowIfNeeded();
627 }
628
629 void PluginView::setNPWindowIfNeeded()
630 {
631     if (!m_isStarted || !parent() || !m_plugin->pluginFuncs()->setwindow)
632         return;
633
634     // If the plugin didn't load sucessfully, no point in calling setwindow
635     if (m_status != PluginStatusLoadedSuccessfully)
636         return;
637
638     // On Unix, only call plugin if it's full-page or windowed
639     if (m_mode != NP_FULL && m_mode != NP_EMBED)
640         return;
641
642     // Check if the platformPluginWidget still exists
643     if (m_isWindowed && !platformPluginWidget())
644         return;
645
646     if (!m_hasPendingGeometryChange)
647         return;
648     m_hasPendingGeometryChange = false;
649
650     if (m_isWindowed) {
651         platformPluginWidget()->setGeometry(m_windowRect);
652
653         // Cut out areas of the plugin occluded by iframe shims
654         Vector<IntRect> cutOutRects;
655         QRegion clipRegion = QRegion(m_clipRect);
656         getPluginOcclusions(m_element, this->parent(), frameRect(), cutOutRects);
657         for (size_t i = 0; i < cutOutRects.size(); i++) {
658             cutOutRects[i].move(-frameRect().x(), -frameRect().y());
659             clipRegion = clipRegion.subtracted(QRegion(cutOutRects[i]));
660         }
661         // if setMask is set with an empty QRegion, no clipping will
662         // be performed, so in that case we hide the plugin view
663         platformPluginWidget()->setVisible(!clipRegion.isEmpty());
664         platformPluginWidget()->setMask(clipRegion);
665
666         m_npWindow.x = m_windowRect.x();
667         m_npWindow.y = m_windowRect.y();
668     } else {
669         m_npWindow.x = 0;
670         m_npWindow.y = 0;
671     }
672
673     // If the width or height are null, set the clipRect to null, indicating that
674     // the plugin is not visible/scrolled out.
675     if (!m_clipRect.width() || !m_clipRect.height()) {
676         m_npWindow.clipRect.left = 0;
677         m_npWindow.clipRect.right = 0;
678         m_npWindow.clipRect.top = 0;
679         m_npWindow.clipRect.bottom = 0;
680     } else {
681         // Clipping rectangle of the plug-in; the origin is the top left corner of the drawable or window. 
682         m_npWindow.clipRect.left = m_npWindow.x + m_clipRect.x();
683         m_npWindow.clipRect.top = m_npWindow.y + m_clipRect.y();
684         m_npWindow.clipRect.right = m_npWindow.x + m_clipRect.x() + m_clipRect.width();
685         m_npWindow.clipRect.bottom = m_npWindow.y + m_clipRect.y() + m_clipRect.height();
686     }
687
688     if (m_plugin->quirks().contains(PluginQuirkDontCallSetWindowMoreThanOnce)) {
689         // FLASH WORKAROUND: Only set initially. Multiple calls to
690         // setNPWindow() cause the plugin to crash in windowed mode.
691         if (!m_isWindowed || m_npWindow.width == -1 || m_npWindow.height == -1) {
692             m_npWindow.width = m_windowRect.width();
693             m_npWindow.height = m_windowRect.height();
694         }
695     } else {
696         m_npWindow.width = m_windowRect.width();
697         m_npWindow.height = m_windowRect.height();
698     }
699
700     PluginView::setCurrentPluginView(this);
701 #if USE(JSC)
702     JSC::JSLock::DropAllLocks dropAllLocks(JSC::SilenceAssertionsOnly);
703 #endif
704     setCallingPlugin(true);
705     m_plugin->pluginFuncs()->setwindow(m_instance, &m_npWindow);
706     setCallingPlugin(false);
707     PluginView::setCurrentPluginView(0);
708 }
709
710 void PluginView::setParentVisible(bool visible)
711 {
712     if (isParentVisible() == visible)
713         return;
714
715     Widget::setParentVisible(visible);
716
717     if (isSelfVisible() && platformPluginWidget())
718         platformPluginWidget()->setVisible(visible);
719 }
720
721 NPError PluginView::handlePostReadFile(Vector<char>& buffer, uint32_t len, const char* buf)
722 {
723     String filename(buf, len);
724
725     if (filename.startsWith("file:///"))
726         filename = filename.substring(8);
727
728     long long size;
729     if (!getFileSize(filename, size))
730         return NPERR_FILE_NOT_FOUND;
731
732     FILE* fileHandle = fopen((filename.utf8()).data(), "r");
733     if (!fileHandle)
734         return NPERR_FILE_NOT_FOUND;
735
736     buffer.resize(size);
737     int bytesRead = fread(buffer.data(), 1, size, fileHandle);
738
739     fclose(fileHandle);
740
741     if (bytesRead <= 0)
742         return NPERR_FILE_NOT_FOUND;
743
744     return NPERR_NO_ERROR;
745 }
746
747 bool PluginView::platformGetValueStatic(NPNVariable variable, void* value, NPError* result)
748 {
749     switch (variable) {
750     case NPNVToolkit:
751         *static_cast<uint32_t*>(value) = 0;
752         *result = NPERR_NO_ERROR;
753         return true;
754
755     case NPNVSupportsXEmbedBool:
756         *static_cast<NPBool*>(value) = true;
757         *result = NPERR_NO_ERROR;
758         return true;
759
760     case NPNVjavascriptEnabledBool:
761         *static_cast<NPBool*>(value) = true;
762         *result = NPERR_NO_ERROR;
763         return true;
764
765     case NPNVSupportsWindowless:
766         *static_cast<NPBool*>(value) = true;
767         *result = NPERR_NO_ERROR;
768         return true;
769
770 #if defined(MOZ_PLATFORM_MAEMO) && (MOZ_PLATFORM_MAEMO >= 5)
771     case NPNVSupportsWindowlessLocal:
772         *static_cast<NPBool*>(value) = true;
773         *result = NPERR_NO_ERROR;
774         return true;
775 #endif
776
777     default:
778         return false;
779     }
780 }
781
782 bool PluginView::platformGetValue(NPNVariable variable, void* value, NPError* result)
783 {
784     switch (variable) {
785     case NPNVxDisplay:
786         *(void **)value = QX11Info::display();
787         *result = NPERR_NO_ERROR;
788         return true;
789
790     case NPNVxtAppContext:
791         *result = NPERR_GENERIC_ERROR;
792         return true;
793
794     case NPNVnetscapeWindow: {
795         void* w = reinterpret_cast<void*>(value);
796         QWebPageClient* client = m_parentFrame->view()->hostWindow()->platformPageClient();
797         *((XID *)w) = client ? client->ownerWidget()->window()->winId() : 0;
798         *result = NPERR_NO_ERROR;
799         return true;
800     }
801
802     case NPNVToolkit:
803         if (m_plugin->quirks().contains(PluginQuirkRequiresGtkToolKit)) {
804             *((uint32_t *)value) = 2;
805             *result = NPERR_NO_ERROR;
806             return true;
807         }
808         return false;
809
810     default:
811         return false;
812     }
813 }
814
815 void PluginView::invalidateRect(const IntRect& rect)
816 {
817 #if USE(ACCELERATED_COMPOSITING) && !USE(TEXTURE_MAPPER)
818     if (m_platformLayer) {
819         m_platformLayer->update(QRectF(rect));
820         return;
821     }
822 #endif
823
824     if (m_isWindowed) {
825         if (platformWidget()) {
826             // update() will schedule a repaint of the widget so ensure
827             // its knowledge of its position on the page is up to date.
828             platformWidget()->setGeometry(m_windowRect);
829             platformWidget()->update(rect);
830         }
831         return;
832     }
833
834     invalidateWindowlessPluginRect(rect);
835 }
836
837 void PluginView::invalidateRect(NPRect* rect)
838 {
839     if (!rect) {
840         invalidate();
841         return;
842     }
843     IntRect r(rect->left, rect->top, rect->right - rect->left, rect->bottom - rect->top);
844     invalidateRect(r);
845 }
846
847 void PluginView::invalidateRegion(NPRegion region)
848 {
849     Q_UNUSED(region);
850     invalidate();
851 }
852
853 void PluginView::forceRedraw()
854 {
855     invalidate();
856 }
857
858 static Display *getPluginDisplay()
859 {
860     // The plugin toolkit might run using a different X connection. At the moment, we only
861     // support gdk based plugins (like flash) that use a different X connection.
862     // The code below has the same effect as this one:
863     // Display *gdkDisplay = gdk_x11_display_get_xdisplay(gdk_display_get_default());
864     QLibrary library(QLatin1String("libgdk-x11-2.0"), 0);
865     if (!library.load())
866         return 0;
867
868     typedef void *(*gdk_init_check_ptr)(void*, void*);
869     gdk_init_check_ptr gdk_init_check = (gdk_init_check_ptr)library.resolve("gdk_init_check");
870     if (!gdk_init_check)
871         return 0;
872
873     typedef void *(*gdk_display_get_default_ptr)();
874     gdk_display_get_default_ptr gdk_display_get_default = (gdk_display_get_default_ptr)library.resolve("gdk_display_get_default");
875     if (!gdk_display_get_default)
876         return 0;
877
878     typedef void *(*gdk_x11_display_get_xdisplay_ptr)(void *);
879     gdk_x11_display_get_xdisplay_ptr gdk_x11_display_get_xdisplay = (gdk_x11_display_get_xdisplay_ptr)library.resolve("gdk_x11_display_get_xdisplay");
880     if (!gdk_x11_display_get_xdisplay)
881         return 0;
882
883     gdk_init_check(0, 0);
884     return (Display*)gdk_x11_display_get_xdisplay(gdk_display_get_default());
885 }
886
887 static void getVisualAndColormap(int depth, Visual **visual, Colormap *colormap)
888 {
889     *visual = 0;
890     *colormap = 0;
891
892 #ifndef QT_NO_XRENDER
893     static const bool useXRender = qgetenv("QT_X11_NO_XRENDER").isNull(); // Should also check for XRender >= 0.5
894 #else
895     static const bool useXRender = false;
896 #endif
897
898     if (!useXRender && depth == 32)
899         return;
900
901     int nvi;
902     XVisualInfo templ;
903     templ.screen  = QX11Info::appScreen();
904     templ.depth   = depth;
905     templ.c_class = TrueColor;
906     XVisualInfo* xvi = XGetVisualInfo(QX11Info::display(), VisualScreenMask | VisualDepthMask | VisualClassMask, &templ, &nvi);
907
908     if (!xvi)
909         return;
910
911 #ifndef QT_NO_XRENDER
912     if (depth == 32) {
913         for (int idx = 0; idx < nvi; ++idx) {
914             XRenderPictFormat* format = XRenderFindVisualFormat(QX11Info::display(), xvi[idx].visual);
915             if (format->type == PictTypeDirect && format->direct.alphaMask) {
916                  *visual = xvi[idx].visual;
917                  break;
918             }
919          }
920     } else
921 #endif // QT_NO_XRENDER
922         *visual = xvi[0].visual;
923
924     XFree(xvi);
925
926     if (*visual)
927         *colormap = XCreateColormap(QX11Info::display(), QX11Info::appRootWindow(), *visual, AllocNone);
928 }
929
930 bool PluginView::platformStart()
931 {
932     ASSERT(m_isStarted);
933     ASSERT(m_status == PluginStatusLoadedSuccessfully);
934
935     if (m_plugin->pluginFuncs()->getvalue) {
936         PluginView::setCurrentPluginView(this);
937 #if USE(JSC)
938         JSC::JSLock::DropAllLocks dropAllLocks(JSC::SilenceAssertionsOnly);
939 #endif
940         setCallingPlugin(true);
941         m_plugin->pluginFuncs()->getvalue(m_instance, NPPVpluginNeedsXEmbed, &m_needsXEmbed);
942         setCallingPlugin(false);
943         PluginView::setCurrentPluginView(0);
944     }
945
946     if (m_isWindowed) {
947         QWebPageClient* client = m_parentFrame->view()->hostWindow()->platformPageClient();
948         if (m_needsXEmbed && client) {
949             setPlatformWidget(new PluginContainerQt(this, client->ownerWidget()));
950             // sync our XEmbed container window creation before sending the xid to plugins.
951             QApplication::syncX();
952         } else {
953             notImplemented();
954             m_status = PluginStatusCanNotLoadPlugin;
955             return false;
956         }
957     } else {
958         setPlatformWidget(0);
959         m_pluginDisplay = getPluginDisplay();
960
961 #if USE(ACCELERATED_COMPOSITING) && !USE(TEXTURE_MAPPER)
962         if (m_parentFrame->page()->chrome()->client()->allowsAcceleratedCompositing()
963             && m_parentFrame->page()->settings() 
964             && m_parentFrame->page()->settings()->acceleratedCompositingEnabled()) {
965             m_platformLayer = adoptPtr(new PluginGraphicsLayerQt(this));
966             // Trigger layer computation in RenderLayerCompositor
967             m_element->setNeedsStyleRecalc(SyntheticStyleChange);
968         }
969 #endif
970     }
971
972     // If the width and the height are not zero we show the PluginView.
973     if (!frameRect().isEmpty())
974         show();
975
976     NPSetWindowCallbackStruct* wsi = new NPSetWindowCallbackStruct();
977     wsi->type = 0;
978
979     if (m_isWindowed) {
980         const QX11Info* x11Info = &platformPluginWidget()->x11Info();
981
982         wsi->display = x11Info->display();
983         wsi->visual = (Visual*)x11Info->visual();
984         wsi->depth = x11Info->depth();
985         wsi->colormap = x11Info->colormap();
986
987         m_npWindow.type = NPWindowTypeWindow;
988         m_npWindow.window = (void*)platformPluginWidget()->winId();
989         m_npWindow.width = -1;
990         m_npWindow.height = -1;
991     } else {
992         const QX11Info* x11Info = &QApplication::desktop()->x11Info();
993
994         if (x11Info->depth() == 32 || !m_plugin->quirks().contains(PluginQuirkRequiresDefaultScreenDepth)) {
995             getVisualAndColormap(32, &m_visual, &m_colormap);
996             wsi->depth = 32;
997         }
998
999         if (!m_visual) {
1000             getVisualAndColormap(x11Info->depth(), &m_visual, &m_colormap);
1001             wsi->depth = x11Info->depth();
1002         }
1003
1004         wsi->display = x11Info->display();
1005         wsi->visual = m_visual;
1006         wsi->colormap = m_colormap;
1007
1008         m_npWindow.type = NPWindowTypeDrawable;
1009         m_npWindow.window = 0; // Not used?
1010         m_npWindow.x = 0;
1011         m_npWindow.y = 0;
1012         m_npWindow.width = -1;
1013         m_npWindow.height = -1;
1014     }
1015
1016     m_npWindow.ws_info = wsi;
1017
1018     if (!(m_plugin->quirks().contains(PluginQuirkDeferFirstSetWindowCall))) {
1019         updatePluginWidget();
1020         setNPWindowIfNeeded();
1021     }
1022
1023     return true;
1024 }
1025
1026 void PluginView::platformDestroy()
1027 {
1028     if (platformPluginWidget())
1029         delete platformPluginWidget();
1030
1031     if (m_drawable)
1032         XFreePixmap(QX11Info::display(), m_drawable);
1033
1034     if (m_colormap)
1035         XFreeColormap(QX11Info::display(), m_colormap);
1036 }
1037
1038 void PluginView::halt()
1039 {
1040 }
1041
1042 void PluginView::restart()
1043 {
1044 }
1045  
1046 #if USE(ACCELERATED_COMPOSITING)
1047 PlatformLayer* PluginView::platformLayer() const
1048 {
1049     return m_platformLayer.get();
1050 }
1051 #endif
1052
1053 } // namespace WebCore