void PluginView::updatePluginWidget()
{
if (!parent())
return;
ASSERT(parent()->isFrameView());
FrameView* frameView = toFrameView(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 (m_status != PluginStatusLoadedSuccessfully)
return;
if (!m_isWindowed && !m_windowRect.isEmpty()) {
Display* display = getPluginDisplay(nullptr);
if (m_drawable)
XFreePixmap(display, m_drawable);
m_drawable = XCreatePixmap(display, getRootWindow(m_parentFrame.get()),
m_windowRect.width(), m_windowRect.height(),
((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->depth);
XSync(display, false); // make sure that the server knows about the Drawable
}
setNPWindowIfNeeded();
}
void PluginView::updatePluginWidget()
{
if (!parent() || !m_isWindowed || !platformPluginWidget())
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;
// do not call setNPWindowIfNeeded immediately, will be called on paint()
m_hasPendingGeometryChange = true;
// in order to move/resize the plugin window at the same time as the
// rest of frame during e.g. scrolling, we set the window geometry
// in the paint() function, but as paint() isn't called when the
// plugin window is outside the frame which can be caused by a
// scroll, we need to move/resize immediately.
if (!m_windowRect.intersects(frameView->frameRect()))
setNPWindowIfNeeded();
}
void PluginView::updateWindow() const
{
if (!parent() || !m_isWindowed)
return;
ASSERT(parent()->isFrameView());
FrameView* frameView = static_cast<FrameView*>(parent());
IntRect oldWindowRect = m_windowRect;
IntRect oldClipRect = m_clipRect;
m_windowRect = IntRect(frameView->contentsToWindow(frameGeometry().location()), frameGeometry().size());
m_clipRect = windowClipRect();
m_clipRect.move(-m_windowRect.x(), -m_windowRect.y());
GtkAllocation allocation = { m_windowRect.x(), m_windowRect.y(), m_windowRect.width(), m_windowRect.height() };
if (m_window) {
gtk_widget_size_allocate(m_window, &allocation);
#if defined(GDK_WINDOWING_X11)
if (!m_needsXEmbed) {
gtk_xtbin_set_position(GTK_XTBIN(m_window), m_windowRect.x(), m_windowRect.y());
gtk_xtbin_resize(m_window, m_windowRect.width(), m_windowRect.height());
}
#endif
}
}
void ChromeClient::mouseDidMoveOverElement(const HitTestResult& hit, unsigned modifierFlags)
{
// check if the element is a link...
bool isLink = hit.isLiveLink();
if (isLink) {
KURL url = hit.absoluteLinkURL();
if (!url.isEmpty() && url != m_hoveredLinkURL) {
TextDirection dir;
CString titleString = hit.title(dir).utf8();
CString urlString = url.string().utf8();
g_signal_emit_by_name(m_webView, "hovering-over-link", titleString.data(), urlString.data());
m_hoveredLinkURL = url;
}
} else if (!isLink && !m_hoveredLinkURL.isEmpty()) {
g_signal_emit_by_name(m_webView, "hovering-over-link", 0, 0);
m_hoveredLinkURL = KURL();
}
if (Node* node = hit.innerNonSharedNode()) {
Frame* frame = node->document()->frame();
FrameView* view = frame ? frame->view() : 0;
m_webView->priv->tooltipArea = view ? view->contentsToWindow(node->getRect()) : IntRect();
} else
m_webView->priv->tooltipArea = IntRect();
}
static gboolean webkit_web_view_popup_menu_handler(GtkWidget* widget)
{
static const int contextMenuMargin = 1;
// The context menu event was generated from the keyboard, so show the context menu by the current selection.
Page* page = core(webView_s);
FrameView* view = page->mainFrame()->view();
Position start = page->mainFrame()->selection()->selection().start();
Position end = page->mainFrame()->selection()->selection().end();
int rightAligned = FALSE;
IntPoint location;
if (!start.node() || !end.node())
location = IntPoint(rightAligned ? view->contentsWidth() - contextMenuMargin : contextMenuMargin, contextMenuMargin);
else {
RenderObject* renderer = start.node()->renderer();
if (!renderer)
return FALSE;
// Calculate the rect of the first line of the selection (cribbed from -[WebCoreFrameBridge firstRectForDOMRange:]).
int extraWidthToEndOfLine = 0;
InlineBox* startInlineBox;
int startCaretOffset;
start.getInlineBoxAndOffset(DOWNSTREAM, startInlineBox, startCaretOffset);
IntRect startCaretRect = renderer->localCaretRect(startInlineBox, startCaretOffset, &extraWidthToEndOfLine);
InlineBox* endInlineBox;
int endCaretOffset;
end.getInlineBoxAndOffset(UPSTREAM, endInlineBox, endCaretOffset);
IntRect endCaretRect = renderer->localCaretRect(endInlineBox, endCaretOffset);
IntRect firstRect;
if (startCaretRect.y() == endCaretRect.y())
firstRect = IntRect(MIN(startCaretRect.x(), endCaretRect.x()),
startCaretRect.y(),
abs(endCaretRect.x() - startCaretRect.x()),
MAX(startCaretRect.height(), endCaretRect.height()));
else
firstRect = IntRect(startCaretRect.x(),
startCaretRect.y(),
startCaretRect.width() + extraWidthToEndOfLine,
startCaretRect.height());
location = IntPoint(rightAligned ? firstRect.right() : firstRect.x(), firstRect.bottom());
}
int x, y;
gdk_window_get_origin(GTK_WIDGET(view->root()->hostWindow()->platformWindow())->window, &x, &y);
// FIXME: The IntSize(0, -1) is a hack to get the hit-testing to result in the selected element.
// Ideally we'd have the position of a context menu event be separate from its target node.
location = view->contentsToWindow(location) + IntSize(0, -1);
IntPoint global = location + IntSize(x, y);
PlatformMouseEvent event(location, global, NoButton, MouseEventPressed, 0, false, false, false, false, gtk_get_current_event_time());
return false;//webkit_web_view_forward_context_menu_event(WEBKIT_WEB_VIEW(widget), event);
}
void FocusController::findHorizontallyFocusableNodeInRect(FocusDirection direction, Node* start, KeyboardEvent* event, const IntRect* rect, Node** candidateNode, IntRect& candidateNodeRect)
{
#if PLATFORM(WKC)
CRASH_IF_STACK_OVERFLOW(WKC_STACK_MARGIN_DEFAULT);
#endif
// ASSERT(direction == FocusDirectionLeft || direction == FocusDirectionRight);
if (!start)
return ;
Node* node = start;
HTMLFrameOwnerElement* owner;
Document* document;
IntRect nodeRect;
while (node) {
if (!isNodeInSpecificRect(node, rect)) {
node = getClosestNode(node, direction);
continue;
}
owner = 0;
if (node->isFrameOwnerElement()) {
owner = static_cast<HTMLFrameOwnerElement*>(node);
if (!owner->contentFrame()) {
*candidateNode = 0;
return;
}
document = owner->contentFrame()->document();
findHorizontallyFocusableNodeInRect(direction, document, event, rect, candidateNode, candidateNodeRect);
} else if (isScrollableContainerNode(node) && !node->renderer()->isTextArea()) {
findHorizontallyFocusableNodeInRect(direction, node->firstChild(), event, rect, candidateNode, candidateNodeRect);
} else {
if (node->isFocusable() && !node->isFrameOwnerElement()) {
nodeRect = node->renderer()->absoluteBoundingBoxRect();
FrameView* frameView = node->document()->view();
if (!frameView) {
*candidateNode = 0;
return;
}
nodeRect = frameView->contentsToWindow(nodeRect);
nodeRect.intersect(*rect);
if (!nodeRect.isEmpty()) {
if (candidateNodeRect.isEmpty()) {
*candidateNode = node;
candidateNodeRect = nodeRect;
}
if (direction == FocusDirectionRight && candidateNodeRect.x() > nodeRect.x()) {
*candidateNode = node;
candidateNodeRect = nodeRect;
} else if (direction == FocusDirectionLeft && candidateNodeRect.x() < nodeRect.x()) {
*candidateNode = node;
candidateNodeRect = nodeRect;
}
}
}
}
node = getClosestNode(node, direction);
}
}
WebCore::IntRect DOMHTMLInputElement::rectOnScreen()
{
RenderObject* renderer = m_element->renderer();
FrameView* view = m_element->document()->view();
if (!renderer || !view)
return WebCore::IntRect();
WebCore::IntRect coreRect = renderer->absoluteBoundingBoxRect();
coreRect.setLocation(view->contentsToWindow(coreRect.location()));
return coreRect;
}
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;
// The plugin had a zero width or height before but was resized, we need to show it again.
if (oldWindowRect.isEmpty())
show();
if (!m_isWindowed && m_windowRect.size() != oldWindowRect.size()) {
if (m_drawable)
XFreePixmap(QX11Info::display(), m_drawable);
m_drawable = XCreatePixmap(QX11Info::display(), QX11Info::appRootWindow(), m_windowRect.width(), m_windowRect.height(),
((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->depth);
QApplication::syncX(); // make sure that the server knows about the Drawable
}
// do not call setNPWindowIfNeeded immediately, will be called on paint()
m_hasPendingGeometryChange = true;
// (i) in order to move/resize the plugin window at the same time as the
// rest of frame during e.g. scrolling, we set the window geometry
// in the paint() function, but as paint() isn't called when the
// plugin window is outside the frame which can be caused by a
// scroll, we need to move/resize immediately.
// (ii) if we are running layout tests from DRT, paint() won't ever get called
// so we need to call setNPWindowIfNeeded() if window geometry has changed
if (!m_windowRect.intersects(frameView->frameRect())
|| (s_isRunningUnderDRT && platformPluginWidget() && (m_windowRect != oldWindowRect || m_clipRect != oldClipRect)))
setNPWindowIfNeeded();
if (!m_platformLayer) {
// Make sure we get repainted afterwards. This is necessary for downward
// scrolling to move the plugin widget properly.
// Note that we don't invalidate the frameRect() here. This is because QWebFrame::renderRelativeCoords()
// imitates ScrollView and adds the scroll offset back on to the rect we damage here (making the co-ordinates absolute
// to the frame again) before passing it to FrameView.
invalidate();
}
}
IntRect WebHitTestResult::Data::elementBoundingBoxInWindowCoordinates(const HitTestResult& hitTestResult)
{
Node* node = hitTestResult.innerNonSharedNode();
if (!node)
return IntRect();
Frame* frame = node->document().frame();
if (!frame)
return IntRect();
FrameView* view = frame->view();
if (!view)
return IntRect();
return view->contentsToWindow(node->pixelSnappedBoundingBox());
}
void ScrollbarGtk::frameRectsChanged()
{
if (!parent())
return;
ASSERT(parent()->isFrameView());
FrameView* frameView = static_cast<FrameView*>(parent());
IntRect windowRect = IntRect(frameView->contentsToWindow(frameRect().location()), frameRect().size());
IntSize sz = frameRect().size();
sz.clampNegativeToZero();
GtkAllocation allocation = { windowRect.x(), windowRect.y(), sz.width(), sz.height() };
gtk_widget_size_allocate(platformWidget(), &allocation);
}
void PlatformScrollbar::geometryChanged() const
{
if (!parent())
return;
ASSERT(parent()->isFrameView());
FrameView* frameView = static_cast<FrameView*>(parent());
IntRect windowRect = IntRect(frameView->contentsToWindow(frameGeometry().location()), frameGeometry().size());
IntSize sz = frameGeometry().size();
sz.clampNegativeToZero();
// GtkAllocation allocation = { windowRect.x(), windowRect.y(), sz.width(), sz.height() };
// gtk_widget_size_allocate(gtkWidget(), &allocation);
}
void PluginView::updatePluginWidget()
{
if (!parent())
return;
ASSERT(parent()->isFrameView());
FrameView* frameView = toFrameView(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;
// The plugin had a zero width or height before but was resized, we need to show it again.
if (oldWindowRect.isEmpty())
show();
if (!m_isWindowed && m_windowRect.size() != oldWindowRect.size()) {
if (m_drawable)
XFreePixmap(x11Display(), m_drawable);
m_drawable = XCreatePixmap(x11Display(), rootWindowID(), m_windowRect.width(), m_windowRect.height(),
((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->depth);
syncX(); // make sure that the server knows about the Drawable
}
// do not call setNPWindowIfNeeded immediately, will be called on paint()
m_hasPendingGeometryChange = true;
// (i) in order to move/resize the plugin window at the same time as the
// rest of frame during e.g. scrolling, we set the window geometry
// in the paint() function, but as paint() isn't called when the
// plugin window is outside the frame which can be caused by a
// scroll, we need to move/resize immediately.
// (ii) if we are running layout tests from DRT, paint() won't ever get called
// so we need to call setNPWindowIfNeeded() if window geometry has changed
if (!m_windowRect.intersects(frameView->frameRect())
|| (s_isRunningUnderDRT && platformPluginWidget() && (m_windowRect != oldWindowRect || m_clipRect != oldClipRect)))
setNPWindowIfNeeded();
invalidate();
}
void PluginView::updatePluginWidget()
{
if (!parent() || !m_private)
return;
ASSERT(parent()->isFrameView());
FrameView* frameView = toFrameView(parent());
IntRect oldWindowRect = m_windowRect;
IntRect oldClipRect = m_clipRect;
m_windowRect = IntRect(frameView->contentsToWindow(frameRect().location()), frameRect().size());
ScrollView* theRoot = root();
if (!theRoot)
return; // ASSERT(parent()->isFrameView()) should prevent this but check just in case
// Map rect to content coordinate space of main frame.
m_windowRect.move(theRoot->scrollOffset());
m_clipRect = calculateClipRect();
// Notify the plugin if it may or may not be on/offscreen.
handleScrollEvent();
bool zoomFactorChanged = ((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->zoomFactor
!= frameView->hostWindow()->platformPageClient()->currentZoomFactor();
if (!zoomFactorChanged && m_windowRect == oldWindowRect && m_clipRect == oldClipRect)
return;
// Do not call setNPWindowIfNeeded immediately, will be called on paint().
m_private->m_hasPendingGeometryChange = true;
// (i) In order to move/resize the plugin window at the same time as the
// rest of frame during e.g. scrolling, we set the window geometry
// in the paint() function, but as paint() isn't called when the
// plugin window is outside the frame which can be caused by a
// scroll, we need to move/resize immediately.
// (ii) If we are running layout tests from DRT, paint() won't ever get called
// so we need to call setNPWindowIfNeeded() if window geometry has changed.
if (m_clipRect.isEmpty() || (platformPluginWidget() && (m_windowRect != oldWindowRect || m_clipRect != oldClipRect || zoomFactorChanged)))
setNPWindowIfNeeded();
// Make sure we get repainted afterwards. This is necessary for downward
// scrolling to move the plugin widget properly.
invalidate();
}
HRESULT STDMETHODCALLTYPE DOMHTMLInputElement::rectOnScreen(
/* [retval][out] */ LPRECT rect)
{
rect->left = rect->top = rect->right = rect->bottom = 0;
RenderObject* renderer = m_element->renderer();
FrameView* view = m_element->document()->view();
if (!renderer || !view)
return E_FAIL;
IntRect coreRect = renderer->absoluteBoundingBoxRect();
coreRect.setLocation(view->contentsToWindow(coreRect.location()));
rect->left = coreRect.x();
rect->top = coreRect.y();
rect->right = coreRect.right();
rect->bottom = coreRect.bottom();
return S_OK;
}
void PluginView::setNPWindowIfNeeded()
{
if (!m_isStarted || !parent() || !m_plugin->pluginFuncs()->setwindow)
return;
CGContextRef newContextRef = cgHandleFor(platformPluginWidget());
if (!newContextRef)
return;
WindowRef newWindowRef = nativeWindowFor(platformPluginWidget());
if (!newWindowRef)
return;
ASSERT(parent()->isFrameView());
FrameView* frameView = static_cast<FrameView*>(parent());
IntRect newGeometry = IntRect(frameView->contentsToWindow(frameRect().location()), frameRect().size());
// TODO: also compare clip rects
if (newGeometry == m_windowRect
&& newWindowRef == m_npCgContext.window
&& newContextRef == m_npCgContext.context)
return;
m_npWindow.window = (void*)&m_npCgContext;
m_npCgContext.window = newWindowRef;
m_npCgContext.context = newContextRef;
m_windowRect = newGeometry;
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 = 0;
m_npWindow.clipRect.top = 0;
m_npWindow.clipRect.right = m_windowRect.width();
m_npWindow.clipRect.bottom = m_windowRect.height();
PluginView::setCurrentPluginView(this);
JSC::JSLock::DropAllLocks dropAllLocks(false);
setCallingPlugin(true);
m_plugin->pluginFuncs()->setwindow(m_instance, &m_npWindow);
setCallingPlugin(false);
PluginView::setCurrentPluginView(0);
}
bool snapTo(const SubtargetGeometry& geom, const IntPoint& touchPoint, const IntRect& touchArea, IntPoint& adjustedPoint)
{
FrameView* view = geom.node()->document()->view();
FloatQuad quad = geom.quad();
if (quad.isRectilinear()) {
IntRect contentBounds = geom.boundingBox();
// Convert from frame coordinates to window coordinates.
IntRect bounds = view->contentsToWindow(contentBounds);
if (bounds.contains(touchPoint)) {
adjustedPoint = touchPoint;
return true;
}
if (bounds.intersects(touchArea)) {
bounds.intersect(touchArea);
adjustedPoint = bounds.center();
return true;
}
return false;
}
// The following code tries to adjust the point to place inside a both the touchArea and the non-rectilinear quad.
// FIXME: This will return the point inside the touch area that is the closest to the quad center, but does not
// guarantee that the point will be inside the quad. Corner-cases exist where the quad will intersect but this
// will fail to adjust the point to somewhere in the intersection.
// Convert quad from content to window coordinates.
FloatPoint p1 = contentsToWindow(view, quad.p1());
FloatPoint p2 = contentsToWindow(view, quad.p2());
FloatPoint p3 = contentsToWindow(view, quad.p3());
FloatPoint p4 = contentsToWindow(view, quad.p4());
quad = FloatQuad(p1, p2, p3, p4);
if (quad.containsPoint(touchPoint)) {
adjustedPoint = touchPoint;
return true;
}
// Pull point towards the center of the element.
FloatPoint center = quad.center();
adjustPointToRect(center, touchArea);
adjustedPoint = roundedIntPoint(center);
return quad.containsPoint(adjustedPoint);
}
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;
setNPWindowIfNeeded();
}
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 (platformPluginWidget() && (m_windowRect != oldWindowRect || m_clipRect != oldClipRect)) {
HRGN rgn;
setCallingPlugin(true);
// To prevent flashes while scrolling, we disable drawing during the window
// update process by clipping the window to the zero rect.
bool clipToZeroRect = !m_plugin->quirks().contains(PluginQuirkDontClipToZeroRectWhenScrolling);
if (clipToZeroRect) {
rgn = ::CreateRectRgn(0, 0, 0, 0);
::SetWindowRgn(platformPluginWidget(), rgn, FALSE);
} else {
rgn = ::CreateRectRgn(m_clipRect.x(), m_clipRect.y(), m_clipRect.right(), m_clipRect.bottom());
::SetWindowRgn(platformPluginWidget(), rgn, TRUE);
}
if (m_windowRect != oldWindowRect)
::MoveWindow(platformPluginWidget(), m_windowRect.x(), m_windowRect.y(), m_windowRect.width(), m_windowRect.height(), TRUE);
if (clipToZeroRect) {
rgn = ::CreateRectRgn(m_clipRect.x(), m_clipRect.y(), m_clipRect.right(), m_clipRect.bottom());
::SetWindowRgn(platformPluginWidget(), rgn, TRUE);
}
setCallingPlugin(false);
}
}
void EmbeddedWidget::frameRectsChanged()
{
if (!parent())
return;
ASSERT(parent()->isFrameView());
FrameView* frameView = toFrameView(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_window)
return;
if (m_windowRect == oldWindowRect && m_clipRect == oldClipRect)
return;
HRGN rgn;
// To prevent flashes while scrolling, we disable drawing during the window
// update process by clipping the window to the zero rect.
bool clipToZeroRect = true;
if (clipToZeroRect) {
rgn = ::CreateRectRgn(0, 0, 0, 0);
::SetWindowRgn(m_window, rgn, FALSE);
} else {
rgn = ::CreateRectRgn(m_clipRect.x(), m_clipRect.y(), m_clipRect.maxX(), m_clipRect.maxY());
::SetWindowRgn(m_window, rgn, TRUE);
}
if (m_windowRect != oldWindowRect)
::MoveWindow(m_window, m_windowRect.x(), m_windowRect.y(), m_windowRect.width(), m_windowRect.height(), TRUE);
if (clipToZeroRect) {
rgn = ::CreateRectRgn(m_clipRect.x(), m_clipRect.y(), m_clipRect.maxX(), m_clipRect.maxY());
::SetWindowRgn(m_window, rgn, TRUE);
}
}
HBITMAP imageFromSelection(Frame* frame, bool forceBlackText)
{
if (!frame->view())
return 0;
frame->view()->setPaintRestriction(forceBlackText ? PaintRestrictionSelectionOnlyBlackText : PaintRestrictionSelectionOnly);
FloatRect fr = frame->selection()->bounds();
IntRect ir((int)fr.x(), (int)fr.y(), (int)fr.width(), (int)fr.height());
if (ir.isEmpty())
return 0;
int w;
int h;
FrameView* view = frame->view();
if (view->parent()) {
ir.setLocation(view->parent()->convertChildToSelf(view, ir.location()));
w = ir.width() * view->zoomFactor() + 0.5;
h = ir.height() * view->zoomFactor() + 0.5;
} else {
ir = view->contentsToWindow(ir);
w = ir.width();
h = ir.height();
}
OwnPtr<HDC> bmpDC(CreateCompatibleDC(g_screenDC));
HBITMAP hBmp = MemoryManager::createCompatibleBitmap(g_screenDC, w, h);
if (!hBmp)
return 0;
HBITMAP hbmpOld = (HBITMAP)SelectObject(bmpDC.get(), hBmp);
{
GraphicsContext gc(bmpDC.get());
frame->document()->updateLayout();
view->paint(&gc, ir);
}
SelectObject(bmpDC.get(), hbmpOld);
frame->view()->setPaintRestriction(PaintRestrictionNone);
return hBmp;
}
void WebContextMenu::show()
{
ContextMenuController& controller = m_page->corePage()->contextMenuController();
Frame* frame = controller.hitTestResult().innerNodeFrame();
if (!frame)
return;
FrameView* view = frame->view();
if (!view)
return;
Vector<WebContextMenuItemData> menuItems;
RefPtr<API::Object> userData;
menuItemsWithUserData(menuItems, userData);
ContextMenuContextData contextMenuContextData(controller.context());
// Mark the WebPage has having a shown context menu then notify the UIProcess.
m_page->contextMenuShowing();
m_page->send(Messages::WebPageProxy::ShowContextMenu(view->contentsToWindow(controller.hitTestResult().roundedPointInInnerNodeFrame()), contextMenuContextData, menuItems, InjectedBundleUserMessageEncoder(userData.get())));
}
void PluginView::updatePluginWidget()
{
FrameView* frameView = static_cast<FrameView*>(parent());
PLUGIN_LOG("--%p UpdatePluginWidget frame=[%p] \n", instance(), frameView);
if (frameView) {
m_windowRect = frameView->contentsToWindow(frameRect());
IntRect oldPageRect = m_pageRect;
// only the top ScrollView can have the offset
m_pageRect = m_windowRect;
ScrollView* top = parent();
while (top->parent())
top = top->parent();
m_pageRect.move(top->scrollOffset());
if (m_pageRect != oldPageRect)
setNPWindowIfNeeded();
}
}
void PluginView::updateWindow() const
{
if (!parent() || !m_isWindowed)
return;
ASSERT(parent()->isFrameView());
FrameView* frameView = static_cast<FrameView*>(parent());
IntRect oldWindowRect = m_windowRect;
IntRect oldClipRect = m_clipRect;
m_windowRect = IntRect(frameView->contentsToWindow(frameGeometry().location()), frameGeometry().size());
m_clipRect = windowClipRect();
m_clipRect.move(-m_windowRect.x(), -m_windowRect.y());
if (m_window) {
m_window->move(m_windowRect.x(), m_windowRect.y());
m_window->resize(m_windowRect.width(), m_windowRect.height());
m_window->setMask(QRegion(m_clipRect.x(), m_clipRect.y(), m_clipRect.width(), m_clipRect.height()));
}
}
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;
// in order to move/resize the plugin window at the same time as the rest of frame
// during e.g. scrolling, we set the mask and geometry in the paint() function, but
// as paint() isn't called when the plugin window is outside the frame which can
// be caused by a scroll, we need to move/resize immediately.
if (!m_windowRect.intersects(frameView->frameRect()))
setNPWindowIfNeeded();
}
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 (!m_isWindowed && m_windowRect.size() != oldWindowRect.size()) {
if (m_drawable)
XFreePixmap(QX11Info::display(), m_drawable);
m_drawable = XCreatePixmap(QX11Info::display(), QX11Info::appRootWindow(), m_windowRect.width(), m_windowRect.height(),
((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->depth);
QApplication::syncX(); // make sure that the server knows about the Drawable
}
// do not call setNPWindowIfNeeded immediately, will be called on paint()
m_hasPendingGeometryChange = true;
// in order to move/resize the plugin window at the same time as the
// rest of frame during e.g. scrolling, we set the window geometry
// in the paint() function, but as paint() isn't called when the
// plugin window is outside the frame which can be caused by a
// scroll, we need to move/resize immediately.
if (!m_windowRect.intersects(frameView->frameRect()))
setNPWindowIfNeeded();
}
void WebContextMenu::show()
{
ContextMenuController* controller = m_page->corePage()->contextMenuController();
if (!controller)
return;
ContextMenu* menu = controller->contextMenu();
if (!menu)
return;
Node* node = controller->hitTestResult().innerNonSharedNode();
if (!node)
return;
Frame* frame = node->document()->frame();
if (!frame)
return;
FrameView* view = frame->view();
if (!view)
return;
// Give the bundle client a chance to process the menu.
#if USE(CROSS_PLATFORM_CONTEXT_MENUS)
const Vector<ContextMenuItem>& coreItems = menu->items();
#else
Vector<ContextMenuItem> coreItems = contextMenuItemVector(menu->platformDescription());
#endif
Vector<WebContextMenuItemData> proposedMenu = kitItems(coreItems, menu);
Vector<WebContextMenuItemData> newMenu;
RefPtr<APIObject> userData;
RefPtr<InjectedBundleHitTestResult> hitTestResult = InjectedBundleHitTestResult::create(controller->hitTestResult());
if (m_page->injectedBundleContextMenuClient().getCustomMenuFromDefaultItems(m_page, hitTestResult.get(), proposedMenu, newMenu, userData))
proposedMenu = newMenu;
ContextMenuState contextMenuState;
contextMenuState.absoluteImageURLString = controller->hitTestResult().absoluteImageURL().string();
contextMenuState.absoluteLinkURLString = controller->hitTestResult().absoluteLinkURL().string();
// Notify the UIProcess.
m_page->send(Messages::WebPageProxy::ShowContextMenu(view->contentsToWindow(controller->hitTestResult().point()), contextMenuState, proposedMenu, InjectedBundleUserMessageEncoder(userData.get())));
}
static void contentsToAtk(AccessibilityObject* coreObject, AtkCoordType coordType, IntRect rect, gint* x, gint* y, gint* width = 0, gint* height = 0)
{
FrameView* frameView = coreObject->documentFrameView();
if (frameView) {
switch (coordType) {
case ATK_XY_WINDOW:
rect = frameView->contentsToWindow(rect);
break;
case ATK_XY_SCREEN:
rect = frameView->contentsToScreen(rect);
break;
}
}
if (x)
*x = rect.x();
if (y)
*y = rect.y();
if (width)
*width = rect.width();
if (height)
*height = rect.height();
}