382 lines
13 KiB
Plaintext
382 lines
13 KiB
Plaintext
// Copyright (c) 2008-2009 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#import <Cocoa/Cocoa.h>
|
|
#import "webwidget_host.h"
|
|
#import "base/logging.h"
|
|
#import "skia/ext/platform_canvas.h"
|
|
#import "third_party/WebKit/Source/WebKit/chromium/public/mac/WebInputEventFactory.h"
|
|
#import "third_party/WebKit/Source/WebKit/chromium/public/mac/WebScreenInfoFactory.h"
|
|
#import "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
|
|
#import "third_party/WebKit/Source/WebKit/chromium/public/WebPopupMenu.h"
|
|
#import "third_party/WebKit/Source/WebKit/chromium/public/WebScreenInfo.h"
|
|
#import "third_party/WebKit/Source/WebKit/chromium/public/WebSize.h"
|
|
#import "third_party/skia/include/core/SkRegion.h"
|
|
#import "ui/gfx/rect.h"
|
|
#import "ui/gfx/size.h"
|
|
#import "webkit/glue/webkit_glue.h"
|
|
|
|
using WebKit::WebInputEvent;
|
|
using WebKit::WebInputEventFactory;
|
|
using WebKit::WebKeyboardEvent;
|
|
using WebKit::WebMouseEvent;
|
|
using WebKit::WebMouseWheelEvent;
|
|
using WebKit::WebPopupMenu;
|
|
using WebKit::WebScreenInfo;
|
|
using WebKit::WebScreenInfoFactory;
|
|
using WebKit::WebSize;
|
|
using WebKit::WebWidgetClient;
|
|
|
|
namespace {
|
|
|
|
inline SkIRect convertToSkiaRect(const gfx::Rect& r)
|
|
{
|
|
return SkIRect::MakeLTRB(r.x(), r.y(), r.right(), r.bottom());
|
|
}
|
|
|
|
inline gfx::Rect convertFromSkiaRect(const SkIRect& r)
|
|
{
|
|
return gfx::Rect(r.x(), r.y(), r.width(), r.height());
|
|
}
|
|
|
|
} // namespace
|
|
|
|
/*static*/
|
|
WebWidgetHost* WebWidgetHost::Create(NSView* parent_view,
|
|
WebWidgetClient* client,
|
|
PaintDelegate* paint_delegate) {
|
|
WebWidgetHost* host = new WebWidgetHost();
|
|
|
|
const NSRect bounds = [parent_view bounds];
|
|
host->view_ = [[NSView alloc] initWithFrame:bounds];
|
|
[parent_view addSubview:host->view_];
|
|
|
|
host->painting_ = false;
|
|
host->layouting_ = false;
|
|
host->webwidget_ = WebPopupMenu::create(client);
|
|
host->webwidget_->resize(WebSize(NSWidth(bounds), NSHeight(bounds)));
|
|
return host;
|
|
}
|
|
|
|
WebWidgetHost::WebWidgetHost()
|
|
: view_(NULL),
|
|
paint_delegate_(NULL),
|
|
webwidget_(NULL),
|
|
canvas_w_(0),
|
|
canvas_h_(0),
|
|
popup_(false),
|
|
has_update_task_(false),
|
|
ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
|
|
set_painting(false);
|
|
}
|
|
|
|
WebWidgetHost::~WebWidgetHost() {
|
|
}
|
|
|
|
void WebWidgetHost::DidInvalidateRect(const gfx::Rect& damaged_rect) {
|
|
const gfx::Rect client_rect(NSRectToCGRect([view_ bounds]));
|
|
const gfx::Rect damaged_rect_in_client = client_rect.Intersect(damaged_rect);
|
|
|
|
if (!damaged_rect_in_client.IsEmpty()) {
|
|
UpdatePaintRect(damaged_rect_in_client);
|
|
NSRect cocoa_rect = NSRectFromCGRect(damaged_rect_in_client.ToCGRect());
|
|
cocoa_rect.origin.y = client_rect.height() - NSMaxY(cocoa_rect);
|
|
[view_ setNeedsDisplayInRect:cocoa_rect];
|
|
}
|
|
}
|
|
|
|
void WebWidgetHost::DidScrollRect(int dx, int dy, const gfx::Rect& clip_rect) {
|
|
DCHECK(dx || dy);
|
|
|
|
const gfx::Rect client_rect(NSRectToCGRect([view_ bounds]));
|
|
gfx::Rect rect = clip_rect.Intersect(client_rect);
|
|
|
|
const int x = rect.x();
|
|
const int y = rect.y();
|
|
const int r = rect.right();
|
|
const int b = rect.bottom();
|
|
const int w = rect.width();
|
|
const int h = rect.height();
|
|
const int Dx = ABS(dx);
|
|
const int Dy = ABS(dy);
|
|
|
|
// If we're in a state right now where we cannot draw into the view then just
|
|
// mark the scrolling rect as dirty and it will be completely redrawn instead.
|
|
// The Paint() method can end up calling this method indirectly if the view
|
|
// needs to be laid out; calling scrollRect:by: in this situation leads to
|
|
// unwanted behavior. Finally, scrolling the rectangle by more than the size
|
|
// of the view means we can just invalidate the entire scroll rect.
|
|
if (![view_ canDraw] || painting_ || layouting_ || Dx >= w || Dy >= h) {
|
|
DidInvalidateRect(clip_rect);
|
|
return;
|
|
}
|
|
|
|
// The scrolling rect must not scroll outside the clip rect because that will
|
|
// clobber the scrollbars. As a result we shorten the rectangle a bit from the
|
|
// leading side of the scroll (could be either horizontally or vertically).
|
|
rect = gfx::Rect(dx>=0? x: x + Dx, dy>=0? y: y + Dy, w - Dx, h - Dy);
|
|
|
|
// Convert the scroll rectangle to the view's coordinate system and perform
|
|
// the scroll directly without invalidating the view. In theory this could
|
|
// cause some kind of performance issue since we're not coalescing redraw
|
|
// events. In practice, however, we get much smoother scrolling of big views
|
|
// since just copying the pixels within the window is much faster than
|
|
// redrawing them.
|
|
NSRect cocoa_rect = NSRectFromCGRect(rect.ToCGRect());
|
|
cocoa_rect.origin.y = client_rect.height() - NSMaxY(cocoa_rect);
|
|
[view_ scrollRect:cocoa_rect by:NSMakeSize(dx, -dy)];
|
|
|
|
// Repaint the rectangle that was revealed when scrolling the given rectangle.
|
|
// The invalidated area will be painted before the view contents are flushed
|
|
// to the screen buffer.
|
|
rect = gfx::Rect(dx>=0? x: r - Dx, dy>=0? y: b - Dy,
|
|
dx>0? Dx: w, dy>0? Dy: h);
|
|
DidInvalidateRect(rect);
|
|
|
|
// If any part of the scrolled rect was marked as dirty make sure to redraw
|
|
// it in the new scrolled-to location. Otherwise we can end up with artifacts
|
|
// for overlapping elements. If there are multiple dirty regions in the scroll
|
|
// rect the rectangle union of those regions will be redrawn.
|
|
SkRegion moved_paint_rgn(paint_rgn_);
|
|
moved_paint_rgn.translate(dx, dy);
|
|
moved_paint_rgn.op(convertToSkiaRect(client_rect), SkRegion::kIntersect_Op);
|
|
DidInvalidateRect(convertFromSkiaRect(moved_paint_rgn.getBounds()));
|
|
}
|
|
|
|
void WebWidgetHost::Paint(SkRegion& update_rgn) {
|
|
gfx::Rect client_rect(NSRectToCGRect([view_ bounds]));
|
|
|
|
// Union the rectangle that WebKit think needs repainting with the rectangle
|
|
// of the view that must be painted now. In most situations this will not
|
|
// affect the painted rectangle. In some situations we could end up re-
|
|
// painting areas that are already in the canvas and only dirty in the view
|
|
// itself. However, if we don't do this we can get artifacts when scrolling
|
|
// because contents of the canvas are no longer correct after scrolling only
|
|
// in the view.
|
|
paint_rgn_.op(update_rgn, SkRegion::kUnion_Op);
|
|
|
|
// When we are not using accelerated compositing the canvas area is allowed
|
|
// to differ in size from the client by a certain number of pixels (128 in
|
|
// this case). When accelerated compositing is in effect the size must match
|
|
// exactly.
|
|
const int extra_w = (webwidget_->isAcceleratedCompositingActive()? 0: 128);
|
|
const int extra_h = (webwidget_->isAcceleratedCompositingActive()? 0: 128);
|
|
const int min_w = client_rect.width();
|
|
const int min_h = client_rect.height();
|
|
const int max_w = client_rect.width() + extra_w * 2;
|
|
const int max_h = client_rect.height() + extra_h * 2;
|
|
|
|
const bool too_small = (canvas_w_ < min_w || canvas_h_ < min_h);
|
|
const bool too_large = (canvas_w_ > max_w || canvas_h_ > max_h);
|
|
|
|
if (!canvas_.get() || too_small || too_large) {
|
|
canvas_w_ = client_rect.width() + extra_w;
|
|
canvas_h_ = client_rect.height() + extra_h;
|
|
canvas_.reset(new skia::PlatformCanvas(canvas_w_, canvas_h_, true));
|
|
paint_rgn_.setRect(convertToSkiaRect(client_rect));
|
|
}
|
|
|
|
// Animate the view and layout any views that have not been laid out yet. The
|
|
// latter may result in more invalidation. Keep track of the fact that we are
|
|
// laying out views, because this will sometimes cause ScrollRect to be called
|
|
// and we don't want to try to scrollRect:by: then.
|
|
layouting_ = true;
|
|
webwidget_->animate(0.0);
|
|
webwidget_->layout();
|
|
layouting_ = false;
|
|
|
|
// Draw into the graphics context of the canvas instead of the view's context.
|
|
// The view's context is pushed onto the context stack to be restored below.
|
|
CGContextRef bitmap = skia::GetBitmapContext(skia::GetTopDevice(*canvas_));
|
|
NSGraphicsContext* paint_context =
|
|
[NSGraphicsContext graphicsContextWithGraphicsPort:bitmap flipped:YES];
|
|
[NSGraphicsContext saveGraphicsState];
|
|
[NSGraphicsContext setCurrentContext:paint_context];
|
|
|
|
// Paint the canvas if necessary. The painting operation can cause additional
|
|
// regions to be invalidated because some elements are laid out the first time
|
|
// they are painted.
|
|
while (!paint_rgn_.isEmpty()) {
|
|
SkRegion draw_rgn;
|
|
draw_rgn.swap(paint_rgn_);
|
|
|
|
SkRegion::Cliperator iterator(draw_rgn, convertToSkiaRect(client_rect));
|
|
for (; !iterator.done(); iterator.next())
|
|
PaintRect(convertFromSkiaRect(iterator.rect()));
|
|
|
|
// If any more rectangles were made dirty during the paint operation, make
|
|
// sure they are copied to the window buffer, by including the paint region.
|
|
// If nothing needs additional painting, this is a no-op.
|
|
update_rgn.op(paint_rgn_, SkRegion::kUnion_Op);
|
|
}
|
|
|
|
// Set the context back to our view and copy the bitmap that we just painted
|
|
// into to the view. Only the regions that were updated are copied.
|
|
[NSGraphicsContext restoreGraphicsState];
|
|
NSGraphicsContext* view_context = [NSGraphicsContext currentContext];
|
|
CGContextRef context = static_cast<CGContextRef>([view_context graphicsPort]);
|
|
|
|
SkRegion::Cliperator iterator(update_rgn, convertToSkiaRect(client_rect));
|
|
for (; !iterator.done(); iterator.next()) {
|
|
const SkIRect& r = iterator.rect();
|
|
CGRect copy_rect = { { r.x(), r.y() }, { r.width(), r.height() } };
|
|
const float x = r.x();
|
|
const float y = client_rect.height() - r.bottom();
|
|
skia::DrawToNativeContext(canvas_.get(), context, x, y, ©_rect);
|
|
}
|
|
}
|
|
|
|
void WebWidgetHost::ScheduleComposite() {
|
|
[view_ setNeedsDisplay:YES];
|
|
}
|
|
|
|
void WebWidgetHost::SetTooltipText(const CefString& tooltip_text)
|
|
{
|
|
// TODO(port): Implement this method as part of tooltip support.
|
|
}
|
|
|
|
void WebWidgetHost::InvalidateRect(const gfx::Rect& rect)
|
|
{
|
|
// TODO(port): Implement this method as part of off-screen rendering support.
|
|
NOTIMPLEMENTED();
|
|
}
|
|
|
|
bool WebWidgetHost::GetImage(int width, int height, void* rgba_buffer)
|
|
{
|
|
if (!canvas_.get())
|
|
return false;
|
|
|
|
// TODO(port): Implement this method as part of off-screen rendering support.
|
|
NOTIMPLEMENTED();
|
|
return false;
|
|
}
|
|
|
|
WebScreenInfo WebWidgetHost::GetScreenInfo() {
|
|
return WebScreenInfoFactory::screenInfo(view_);
|
|
}
|
|
|
|
void WebWidgetHost::Resize(const gfx::Rect& rect) {
|
|
SetSize(rect.width(), rect.height());
|
|
}
|
|
|
|
void WebWidgetHost::MouseEvent(NSEvent *event) {
|
|
const WebMouseEvent& web_event = WebInputEventFactory::mouseEvent(
|
|
event, view_);
|
|
webwidget_->handleInputEvent(web_event);
|
|
}
|
|
|
|
void WebWidgetHost::WheelEvent(NSEvent *event) {
|
|
webwidget_->handleInputEvent(
|
|
WebInputEventFactory::mouseWheelEvent(event, view_));
|
|
}
|
|
|
|
void WebWidgetHost::KeyEvent(NSEvent *event) {
|
|
WebKeyboardEvent keyboard_event(WebInputEventFactory::keyboardEvent(event));
|
|
last_key_event_ = keyboard_event;
|
|
webwidget_->handleInputEvent(keyboard_event);
|
|
|
|
if ([event type] != NSKeyDown)
|
|
return;
|
|
|
|
if ([event modifierFlags] & (NSNumericPadKeyMask | NSFunctionKeyMask)) {
|
|
// Don't send a Char event for non-char keys like arrows, function keys and
|
|
// clear.
|
|
switch ([event keyCode]) {
|
|
case 81: // =
|
|
case 75: // /
|
|
case 67: // *
|
|
case 78: // -
|
|
case 69: // +
|
|
case 76: // Enter
|
|
case 65: // .
|
|
case 82: // 0
|
|
case 83: // 1
|
|
case 84: // 2
|
|
case 85: // 3
|
|
case 86: // 4
|
|
case 87: // 5
|
|
case 88: // 6
|
|
case 89: // 7
|
|
case 91: // 8
|
|
case 92: // 9
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Send a Char event here to emulate the keyboard events.
|
|
// TODO(hbono): Bug 20852 <http://crbug.com/20852> implement the NSTextInput
|
|
// protocol and remove this code.
|
|
keyboard_event.type = WebInputEvent::Char;
|
|
last_key_event_ = keyboard_event;
|
|
webwidget_->handleInputEvent(keyboard_event);
|
|
}
|
|
|
|
void WebWidgetHost::SetFocus(bool enable) {
|
|
webwidget_->setFocus(enable);
|
|
}
|
|
|
|
void WebWidgetHost::PaintRect(const gfx::Rect& rect) {
|
|
#ifndef NDEBUG
|
|
DCHECK(!painting_);
|
|
#endif
|
|
DCHECK(canvas_.get());
|
|
|
|
if (!rect.IsEmpty()) {
|
|
set_painting(true);
|
|
webwidget_->paint(webkit_glue::ToWebCanvas(canvas_.get()), rect);
|
|
set_painting(false);
|
|
}
|
|
}
|
|
|
|
void WebWidgetHost::SendKeyEvent(cef_key_type_t type, int key, int modifiers,
|
|
bool sysChar, bool imeChar)
|
|
{
|
|
// TODO(port): Implement this method as part of off-screen rendering support.
|
|
NOTIMPLEMENTED();
|
|
}
|
|
|
|
void WebWidgetHost::SendMouseClickEvent(int x, int y,
|
|
cef_mouse_button_type_t type,
|
|
bool mouseUp, int clickCount)
|
|
{
|
|
// TODO(port): Implement this method as part of off-screen rendering support.
|
|
NOTIMPLEMENTED();
|
|
}
|
|
|
|
void WebWidgetHost::SendMouseMoveEvent(int x, int y, bool mouseLeave)
|
|
{
|
|
// TODO(port): Implement this method as part of off-screen rendering support.
|
|
NOTIMPLEMENTED();
|
|
}
|
|
|
|
void WebWidgetHost::SendMouseWheelEvent(int x, int y, int delta)
|
|
{
|
|
// TODO(port): Implement this method as part of off-screen rendering support.
|
|
NOTIMPLEMENTED();
|
|
}
|
|
|
|
void WebWidgetHost::SendFocusEvent(bool setFocus)
|
|
{
|
|
// TODO(port): Implement this method as part of off-screen rendering support.
|
|
NOTIMPLEMENTED();
|
|
}
|
|
|
|
void WebWidgetHost::SendCaptureLostEvent()
|
|
{
|
|
// TODO(port): Implement this method as part of off-screen rendering support.
|
|
NOTIMPLEMENTED();
|
|
}
|
|
|
|
void WebWidgetHost::EnsureTooltip()
|
|
{
|
|
// TODO(port): Implement this method as part of tooltip support.
|
|
}
|
|
|
|
void WebWidgetHost::ResetTooltip()
|
|
{
|
|
// TODO(port): Implement this method as part of tooltip support.
|
|
}
|