Google Git
Sign in
android / platform / external / webkit / 595f429f16d56891f697a15c3ec2fd2ec9647c5f / . / WebKit / android / nav / WebView.cpp
blob: e0cdd3b8c95891444a6d4d0bfcbfbeaa5df2bea5 [file] [log] [blame]
/*
* Copyright 2007, The Android Open Source Project
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * 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 THE COPYRIGHT HOLDERS ``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.
*/
#define LOG_TAG "webviewglue"
#include <config.h>
#include "android_graphics.h"
#include "AndroidLog.h"
#include "AtomicString.h"
#include "CachedFrame.h"
#include "CachedNode.h"
#include "CachedRoot.h"
#include "FindCanvas.h"
#include "Frame.h"
#include "GraphicsJNI.h"
#include "IntPoint.h"
#include "IntRect.h"
#include "Node.h"
#include "PlatformGraphicsContext.h"
#include "PlatformString.h"
#include "SelectText.h"
#include "SkBlurMaskFilter.h"
#include "SkCanvas.h"
#include "SkCornerPathEffect.h"
#include "SkDumpCanvas.h"
#include "SkPath.h"
#include "SkPicture.h"
#include "SkPixelXorXfermode.h"
#include "SkRect.h"
#include "SkTime.h"
#include "WebCoreJni.h"
#include "WebViewCore.h"
#include "jni_utility.h"
#ifdef ANDROID_INSTRUMENT
#include "TimeCounter.h"
#endif
#ifdef GET_NATIVE_VIEW
#undef GET_NATIVE_VIEW
#endif
#define GET_NATIVE_VIEW(env, obj) ((WebView*)env->GetIntField(obj, gWebViewField))
#include <ui/KeycodeLabels.h>
#include <JNIHelp.h>
#include <jni.h>
namespace android {
static jfieldID gWebViewField;
//-------------------------------------
static jmethodID GetJMethod(JNIEnv* env, jclass clazz, const char name[], const char signature[])
{
jmethodID m = env->GetMethodID(clazz, name, signature);
LOG_ASSERT(m, "Could not find method %s", name);
return m;
}
//-------------------------------------
// This class provides JNI for making calls into native code from the UI side
// of the multi-threaded WebView.
class WebView
{
public:
enum FrameCachePermission {
DontAllowNewer,
AllowNewer,
AllowNewest
};
struct JavaGlue {
jobject m_obj;
jmethodID m_clearTextEntry;
jmethodID m_overrideLoading;
jmethodID m_scrollBy;
jmethodID m_sendMoveMouse;
jmethodID m_sendMoveMouseIfLatest;
jmethodID m_sendMotionUp;
jmethodID m_getScaledMaxXScroll;
jmethodID m_getScaledMaxYScroll;
jmethodID m_getVisibleRect;
jmethodID m_rebuildWebTextView;
jmethodID m_displaySoftKeyboard;
jmethodID m_viewInvalidate;
jmethodID m_viewInvalidateRect;
jmethodID m_postInvalidateDelayed;
jfieldID m_rectLeft;
jfieldID m_rectTop;
jmethodID m_rectWidth;
jmethodID m_rectHeight;
AutoJObject object(JNIEnv* env) {
return getRealObject(env, m_obj);
}
} m_javaGlue;
WebView(JNIEnv* env, jobject javaWebView, int viewImpl)
{
jclass clazz = env->FindClass("android/webkit/WebView");
// m_javaGlue = new JavaGlue;
m_javaGlue.m_obj = adoptGlobalRef(env, javaWebView);
m_javaGlue.m_scrollBy = GetJMethod(env, clazz, "setContentScrollBy", "(IIZ)V");
m_javaGlue.m_clearTextEntry = GetJMethod(env, clazz, "clearTextEntry", "()V");
m_javaGlue.m_overrideLoading = GetJMethod(env, clazz, "overrideLoading", "(Ljava/lang/String;)V");
m_javaGlue.m_sendMoveMouse = GetJMethod(env, clazz, "sendMoveMouse", "(IIII)V");
m_javaGlue.m_sendMoveMouseIfLatest = GetJMethod(env, clazz, "sendMoveMouseIfLatest", "()V");
m_javaGlue.m_sendMotionUp = GetJMethod(env, clazz, "sendMotionUp", "(IIIIII)V");
m_javaGlue.m_getScaledMaxXScroll = GetJMethod(env, clazz, "getScaledMaxXScroll", "()I");
m_javaGlue.m_getScaledMaxYScroll = GetJMethod(env, clazz, "getScaledMaxYScroll", "()I");
m_javaGlue.m_getVisibleRect = GetJMethod(env, clazz, "sendOurVisibleRect", "()Landroid/graphics/Rect;");
m_javaGlue.m_rebuildWebTextView = GetJMethod(env, clazz, "rebuildWebTextView", "()V");
m_javaGlue.m_displaySoftKeyboard = GetJMethod(env, clazz, "displaySoftKeyboard", "()V");
m_javaGlue.m_viewInvalidate = GetJMethod(env, clazz, "viewInvalidate", "()V");
m_javaGlue.m_viewInvalidateRect = GetJMethod(env, clazz, "viewInvalidate", "(IIII)V");
m_javaGlue.m_postInvalidateDelayed = GetJMethod(env, clazz,
"viewInvalidateDelayed", "(JIIII)V");
jclass rectClass = env->FindClass("android/graphics/Rect");
LOG_ASSERT(rectClass, "Could not find Rect class");
m_javaGlue.m_rectLeft = env->GetFieldID(rectClass, "left", "I");
m_javaGlue.m_rectTop = env->GetFieldID(rectClass, "top", "I");
m_javaGlue.m_rectWidth = GetJMethod(env, rectClass, "width", "()I");
m_javaGlue.m_rectHeight = GetJMethod(env, rectClass, "height", "()I");
env->SetIntField(javaWebView, gWebViewField, (jint)this);
m_viewImpl = (WebViewCore*) viewImpl;
m_frameCacheUI = 0;
m_navPictureUI = 0;
m_invalidNode = 0;
m_generation = 0;
m_heightCanMeasure = false;
m_followedLink = false;
m_lastDx = 0;
m_lastDxTime = 0;
m_ringAnimationEnd = 0;
m_selStart.setEmpty();
m_selEnd.setEmpty();
m_matches = 0;
m_hasCurrentLocation = false;
m_isFindPaintSetUp = false;
}
~WebView()
{
if (m_javaGlue.m_obj)
{
JNIEnv* env = JSC::Bindings::getJNIEnv();
env->DeleteGlobalRef(m_javaGlue.m_obj);
m_javaGlue.m_obj = 0;
}
delete m_frameCacheUI;
delete m_navPictureUI;
if (m_matches)
delete m_matches;
}
WebViewCore* getWebViewCore() const {
return m_viewImpl;
}
void clearCursor(int x, int y, bool inval)
{
DBG_NAV_LOGD("x=%d y=%d inval=%s", x, y, inval ? "true" : "false");
CachedRoot* root = getFrameCache(AllowNewer);
if (!root || !root->currentCursor())
return;
DBG_NAV_LOG("root->setCursor(0, 0)");
root->setCursor(0, 0);
if (inval)
viewInvalidate();
}
void clearTextEntry()
{
DEBUG_NAV_UI_LOGD("%s", __FUNCTION__);
JNIEnv* env = JSC::Bindings::getJNIEnv();
env->CallVoidMethod(m_javaGlue.object(env).get(), m_javaGlue.m_clearTextEntry);
checkException(env);
}
#if DUMP_NAV_CACHE
void debugDump()
{
CachedRoot* root = getFrameCache(DontAllowNewer);
if (root)
root->mDebug.print();
}
#endif
// Traverse our stored array of buttons that are in our picture, and update
// their subpictures according to their current state.
// Called from the UI thread. This is the one place in the UI thread where we
// access the buttons stored in the WebCore thread.
// hasFocus keeps track of whether the WebView has focus && windowFocus.
// If not, we do not want to draw the button in a selected or pressed state
void nativeRecordButtons(bool hasFocus, bool pressed, bool invalidate)
{
bool cursorIsOnButton = false;
const CachedNode* cachedCursor = 0;
// Lock the mutex, since we now share with the WebCore thread.
m_viewImpl->gButtonMutex.lock();
if (m_viewImpl->m_buttons.size()) {
// FIXME: In a future change, we should keep track of whether the selection
// has changed to short circuit (note that we would still need to update
// if we received new buttons from the WebCore thread).
WebCore::Node* cursor = 0;
CachedRoot* root = getFrameCache(DontAllowNewer);
if (root) {
cachedCursor = root->currentCursor();
if (cachedCursor)
cursor = (WebCore::Node*) cachedCursor->nodePointer();
}
// Traverse the array, and update each button, depending on whether it
// is selected.
Container* end = m_viewImpl->m_buttons.end();
for (Container* ptr = m_viewImpl->m_buttons.begin(); ptr != end; ptr++) {
WebCore::RenderSkinAndroid::State state;
if (ptr->matches(cursor)) {
cursorIsOnButton = true;
// If the WebView is out of focus/window focus, set the state to
// normal, but still keep track of the fact that the selected is a
// button
if (!hasFocus) {
state = WebCore::RenderSkinAndroid::kNormal;
} else if (m_followedLink || pressed) {
state = WebCore::RenderSkinAndroid::kPressed;
} else {
state = WebCore::RenderSkinAndroid::kFocused;
}
} else {
state = WebCore::RenderSkinAndroid::kNormal;
}
ptr->updateFocusState(state);
}
}
m_viewImpl->gButtonMutex.unlock();
if (invalidate && cachedCursor && cursorIsOnButton) {
const WebCore::IntRect& b = cachedCursor->getBounds();
viewInvalidateRect(b.x(), b.y(), b.right(), b.bottom());
}
}
// These two functions separate out the particular look of the drawn find
// matches from the code that draws them. This function sets up the paints that
// are used to draw the matches.
void setUpFindPaint()
{
// Set up the foreground paint
m_findPaint.setAntiAlias(true);
const SkScalar roundiness = SkIntToScalar(2);
SkCornerPathEffect* cornerEffect = new SkCornerPathEffect(roundiness);
m_findPaint.setPathEffect(cornerEffect);
m_findPaint.setARGB(255, 132, 190, 0);
// Set up the background blur paint.
m_findBlurPaint.setAntiAlias(true);
m_findBlurPaint.setARGB(204, 0, 0, 0);
m_findBlurPaint.setPathEffect(cornerEffect);
cornerEffect->unref();
SkMaskFilter* blurFilter = SkBlurMaskFilter::Create(SK_Scalar1,
SkBlurMaskFilter::kNormal_BlurStyle);
m_findBlurPaint.setMaskFilter(blurFilter)->unref();
m_isFindPaintSetUp = true;
}
// Draw the match specified by region to the canvas.
void drawMatch(const SkRegion& region, SkCanvas* canvas, bool focused)
{
// For the match which has focus, use a filled paint. For the others, use
// a stroked paint.
if (focused) {
m_findPaint.setStyle(SkPaint::kFill_Style);
m_findBlurPaint.setStyle(SkPaint::kFill_Style);
} else {
m_findPaint.setStyle(SkPaint::kStroke_Style);
m_findPaint.setStrokeWidth(SK_Scalar1);
m_findBlurPaint.setStyle(SkPaint::kStroke_Style);
m_findBlurPaint.setStrokeWidth(SkIntToScalar(2));
}
// Find the path for the current match
SkPath matchPath;
region.getBoundaryPath(&matchPath);
// Offset the path for a blurred shadow
SkPath blurPath;
matchPath.offset(SK_Scalar1, SkIntToScalar(2), &blurPath);
int saveCount = 0;
if (!focused) {
saveCount = canvas->save();
canvas->clipPath(matchPath, SkRegion::kDifference_Op);
}
// Draw the blurred background
canvas->drawPath(blurPath, m_findBlurPaint);
if (!focused) {
canvas->restoreToCount(saveCount);
}
// Draw the foreground
canvas->drawPath(matchPath, m_findPaint);
}
// Put a cap on the number of matches to draw. If the current page has more
// matches than this, only draw the focused match.
#define MAX_NUMBER_OF_MATCHES_TO_DRAW 101
void drawMatches(SkCanvas* canvas)
{
if (!m_matches || !m_matches->size()) {
return;
}
if (m_findIndex >= m_matches->size()) {
m_findIndex = 0;
}
const MatchInfo& matchInfo = (*m_matches)[m_findIndex];
const SkRegion& currentMatchRegion = matchInfo.getLocation();
const SkIRect& currentMatchBounds = currentMatchRegion.getBounds();
int left = currentMatchBounds.fLeft;
int top = currentMatchBounds.fTop;
int right = currentMatchBounds.fRight;
int bottom = currentMatchBounds.fBottom;
WebCore::IntRect visible;
getVisibleRect(&visible);
// Check to make sure that the highlighted match is on screen. If not,
// scroll it onscreen and return.
int dx = 0;
if (left < visible.x()) {
dx = left - visible.x();
// Only scroll right if the entire width can fit on screen.
} else if (right > visible.right() && right - left < visible.width()) {
dx = right - visible.right();
}
int dy = 0;
if (top < visible.y()) {
dy = top - visible.y();
// Only scroll down if the entire height can fit on screen
} else if (bottom > visible.bottom() && bottom - top < visible.height()) {
dy = bottom - visible.bottom();
}
if ((dx|dy)) {
scrollBy(dx, dy);
viewInvalidate();
return;
}
// Set up the paints used for drawing the matches
if (!m_isFindPaintSetUp)
setUpFindPaint();
// Draw the current match
drawMatch(currentMatchRegion, canvas, true);
// Now draw the picture, so that it shows up on top of the rectangle
canvas->drawPicture(*matchInfo.getPicture());
// Draw the rest
unsigned numberOfMatches = m_matches->size();
if (numberOfMatches > 1
&& numberOfMatches < MAX_NUMBER_OF_MATCHES_TO_DRAW) {
SkIRect visibleIRect(visible);
for(unsigned i = 0; i < numberOfMatches; i++) {
// The current match has already been drawn
if (i == m_findIndex)
continue;
const SkRegion& region = (*m_matches)[i].getLocation();
// Do not draw matches which intersect the current one, or if it is
// offscreen
if (currentMatchRegion.intersects(region)
|| !region.intersects(visibleIRect))
continue;
drawMatch(region, canvas, false);
}
}
}
void drawCursorRing(SkCanvas* canvas)
{
const CachedRoot* root = getFrameCache(AllowNewer);
if (!root) {
DBG_NAV_LOG("!root");
m_followedLink = false;
m_viewImpl->m_hasCursorBounds = false;
return;
}
const CachedNode* node = root->currentCursor();
if (!node) {
DBG_NAV_LOG("!node");
m_followedLink = false;
m_viewImpl->m_hasCursorBounds = false;
return;
}
if (!node->hasCursorRing()) {
DBG_NAV_LOG("!node->hasCursorRing()");
m_viewImpl->m_hasCursorBounds = false;
return;
}
const WTF::Vector<WebCore::IntRect>* rings = &node->cursorRings();
if (!rings->size()) {
DBG_NAV_LOG("!rings->size()");
m_viewImpl->m_hasCursorBounds = false;
return;
}
bool isButton = false;
m_viewImpl->gButtonMutex.lock();
// If this is a button drawn by us (rather than webkit) do not draw the
// cursor ring, since its cursor will be shown by a change in what we draw.
// Should be in sync with recordButtons, since that will be called
// before this.
if (m_viewImpl->m_buttons.size() > 0) {
WebCore::Node* cursorPointer = (WebCore::Node*) node->nodePointer();
Container* end = m_viewImpl->m_buttons.end();
for (Container* ptr = m_viewImpl->m_buttons.begin(); ptr != end; ptr++) {
if (ptr->matches(cursorPointer)) {
isButton = true;
break;
}
}
}
m_viewImpl->gButtonMutex.unlock();
WebCore::IntRect bounds = node->bounds();
m_viewImpl->gCursorBoundsMutex.lock();
m_viewImpl->m_hasCursorBounds = true;
if (m_viewImpl->m_cursorBounds != bounds)
DBG_NAV_LOGD("new cursor bounds=(%d,%d,w=%d,h=%d)",
bounds.x(), bounds.y(), bounds.width(), bounds.height());
m_viewImpl->m_cursorBounds = bounds;
m_viewImpl->gCursorBoundsMutex.unlock();
bounds.inflate(SkScalarCeil(CURSOR_RING_OUTER_DIAMETER));
if (canvas->quickReject(bounds, SkCanvas::kAA_EdgeType)) {
DBG_NAV_LOGD("canvas->quickReject cursorNode=%d (nodePointer=%p)"
" bounds=(%d,%d,w=%d,h=%d)", node->index(), node->nodePointer(),
bounds.x(), bounds.y(), bounds.width(), bounds.height());
m_followedLink = false;
return;
}
CursorRing::Flavor flavor = CursorRing::NORMAL_FLAVOR;
WTF::Vector<WebCore::IntRect> oneRing;
if (!isButton) {
flavor = node->type() != NORMAL_CACHEDNODETYPE ?
CursorRing::FAKE_FLAVOR : node->nodePointer() == m_invalidNode ?
CursorRing::INVALID_FLAVOR : CursorRing::NORMAL_FLAVOR;
if (flavor != CursorRing::INVALID_FLAVOR && m_followedLink) {
flavor = (CursorRing::Flavor) (flavor + CursorRing::NORMAL_ANIMATING);
}
bool useHitBounds = node->useHitBounds();
if (useHitBounds || node->useBounds()) {
oneRing.append(useHitBounds ? node->hitBounds() : node->bounds());
rings = &oneRing;
}
#if DEBUG_NAV_UI
const WebCore::IntRect& ring = (*rings)[0];
DBG_NAV_LOGD("cursorNode=%d (nodePointer=%p) flavor=%s rings=%d"
" (%d, %d, %d, %d)", node->index(), node->nodePointer(),
flavor == CursorRing::FAKE_FLAVOR ? "FAKE_FLAVOR" :
flavor == CursorRing::INVALID_FLAVOR ? "INVALID_FLAVOR" :
flavor == CursorRing::NORMAL_ANIMATING ? "NORMAL_ANIMATING" :
flavor == CursorRing::FAKE_ANIMATING ? "FAKE_ANIMATING" : "NORMAL_FLAVOR",
rings->size(), ring.x(), ring.y(), ring.width(), ring.height());
#endif
}
if (isButton || flavor >= CursorRing::NORMAL_ANIMATING) {
SkMSec time = SkTime::GetMSecs();
if (time < m_ringAnimationEnd) {
// views assume that inval bounds coordinates are non-negative
bounds.intersect(WebCore::IntRect(0, 0, INT_MAX, INT_MAX));
postInvalidateDelayed(m_ringAnimationEnd - time, bounds);
} else {
m_followedLink = false;
flavor = (CursorRing::Flavor) (flavor - CursorRing::NORMAL_ANIMATING);
}
}
if (!isButton)
CursorRing::DrawRing(canvas, *rings, flavor);
}
bool cursorIsTextInput(FrameCachePermission allowNewer)
{
CachedRoot* root = getFrameCache(allowNewer);
if (!root) {
DBG_NAV_LOG("!root");
return false;
}
const CachedNode* cursor = root->currentCursor();
if (!cursor) {
DBG_NAV_LOG("!cursor");
return false;
}
DBG_NAV_LOGD("%s",
cursor->isTextArea() || cursor->isTextField() ? "true" : "false");
return cursor->isTextArea() || cursor->isTextField();
}
void cursorRingBounds(WebCore::IntRect* bounds)
{
DBG_NAV_LOGD("%s", "");
CachedRoot* root = getFrameCache(DontAllowNewer);
if (root) {
const CachedNode* cachedNode = root->currentCursor();
if (cachedNode) {
cachedNode->cursorRingBounds(bounds);
DBG_NAV_LOGD("bounds={%d,%d,%d,%d}", bounds->x(), bounds->y(),
bounds->width(), bounds->height());
return;
}
}
*bounds = WebCore::IntRect(0, 0, 0, 0);
}
CachedRoot* getFrameCache(FrameCachePermission allowNewer)
{
if (!m_viewImpl->m_updatedFrameCache) {
DBG_NAV_LOG("!m_viewImpl->m_updatedFrameCache");
return m_frameCacheUI;
}
if (allowNewer == DontAllowNewer && m_viewImpl->m_lastGeneration < m_generation) {
DBG_NAV_LOGD("allowNewer==DontAllowNewer m_viewImpl->m_lastGeneration=%d"
" < m_generation=%d", m_viewImpl->m_lastGeneration, m_generation);
return m_frameCacheUI;
}
DBG_NAV_LOGD("%s", "m_viewImpl->m_updatedFrameCache == true");
bool hadCursor = m_frameCacheUI && m_frameCacheUI->currentCursor();
m_viewImpl->gFrameCacheMutex.lock();
delete m_frameCacheUI;
delete m_navPictureUI;
m_viewImpl->m_updatedFrameCache = false;
m_frameCacheUI = m_viewImpl->m_frameCacheKit;
m_navPictureUI = m_viewImpl->m_navPictureKit;
m_viewImpl->m_frameCacheKit = 0;
m_viewImpl->m_navPictureKit = 0;
m_viewImpl->gFrameCacheMutex.unlock();
if (hadCursor && (!m_frameCacheUI || !m_frameCacheUI->currentCursor()))
viewInvalidate(); // redraw in case cursor ring is still visible
return m_frameCacheUI;
}
int getScaledMaxXScroll()
{
LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
JNIEnv* env = JSC::Bindings::getJNIEnv();
int result = env->CallIntMethod(m_javaGlue.object(env).get(), m_javaGlue.m_getScaledMaxXScroll);
checkException(env);
return result;
}
int getScaledMaxYScroll()
{
LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
JNIEnv* env = JSC::Bindings::getJNIEnv();
int result = env->CallIntMethod(m_javaGlue.object(env).get(), m_javaGlue.m_getScaledMaxYScroll);
checkException(env);
return result;
}
void getVisibleRect(WebCore::IntRect* rect)
{
LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
JNIEnv* env = JSC::Bindings::getJNIEnv();
jobject jRect = env->CallObjectMethod(m_javaGlue.object(env).get(), m_javaGlue.m_getVisibleRect);
checkException(env);
int left = (int) env->GetIntField(jRect, m_javaGlue.m_rectLeft);
checkException(env);
rect->setX(left);
int top = (int) env->GetIntField(jRect, m_javaGlue.m_rectTop);
checkException(env);
rect->setY(top);
int width = (int) env->CallIntMethod(jRect, m_javaGlue.m_rectWidth);
checkException(env);
rect->setWidth(width);
int height = (int) env->CallIntMethod(jRect, m_javaGlue.m_rectHeight);
checkException(env);
rect->setHeight(height);
env->DeleteLocalRef(jRect);
checkException(env);
}
static CachedFrame::Direction KeyToDirection(KeyCode keyCode)
{
switch (keyCode) {
case kKeyCodeDpadRight:
DBG_NAV_LOGD("keyCode=%s", "right");
return CachedFrame::RIGHT;
case kKeyCodeDpadLeft:
DBG_NAV_LOGD("keyCode=%s", "left");
return CachedFrame::LEFT;
case kKeyCodeDpadDown:
DBG_NAV_LOGD("keyCode=%s", "down");
return CachedFrame::DOWN;
case kKeyCodeDpadUp:
DBG_NAV_LOGD("keyCode=%s", "up");
return CachedFrame::UP;
default:
LOGD("------- bad key sent to WebView::moveCursor");
return CachedFrame::UNINITIALIZED;
}
}
WebCore::String imageURI(int x, int y)
{
const CachedRoot* root = getFrameCache(DontAllowNewer);
return root ? root->imageURI(x, y) : WebCore::String();
}
bool cursorWantsKeyEvents()
{
const CachedRoot* root = getFrameCache(DontAllowNewer);
if (root) {
const CachedNode* focus = root->currentCursor();
if (focus)
return focus->wantsKeyEvents();
}
return false;
}
/* returns true if the key had no effect (neither scrolled nor changed cursor) */
bool moveCursor(int keyCode, int count, bool ignoreScroll, bool inval,
void* lastSentCursor, const WebCore::IntRect* lastSentBounds)
{
CachedRoot* root = getFrameCache(AllowNewer);
if (!root) {
DBG_NAV_LOG("!root");
return true;
}
m_viewImpl->m_moveGeneration++;
CachedFrame::Direction direction = KeyToDirection((KeyCode) keyCode);
const CachedFrame* cachedFrame, * oldFrame = 0;
const CachedNode* cursor = root->currentCursor(&oldFrame);
WebCore::IntPoint cursorLocation = root->cursorLocation();
DBG_NAV_LOGD("old cursor %d (nativeNode=%p) cursorLocation={%d, %d}",
cursor ? cursor->index() : 0,
cursor ? cursor->nodePointer() : 0, cursorLocation.x(), cursorLocation.y());
WebCore::IntRect visibleRect;
getVisibleRect(&visibleRect);
DBG_NAV_LOGD("getVisibleRect %d,%d,%d,%d",
visibleRect.x(), visibleRect.y(), visibleRect.width(), visibleRect.height());
root->setVisibleRect(visibleRect);
int xMax = getScaledMaxXScroll();
int yMax = getScaledMaxYScroll();
root->setMaxScroll(xMax, yMax);
CachedHistory savedHistory = *root->rootHistory();
const CachedNode* cachedNode = 0;
int dx = 0;
int dy = 0;
int counter = count;
if (!cursor || !cursor->isInput() || !m_followedLink)
root->setScrollOnly(m_followedLink);
while (--counter >= 0) {
WebCore::IntPoint scroll = WebCore::IntPoint(0, 0);
cachedNode = root->moveCursor(direction, &cachedFrame, &scroll);
dx += scroll.x();
dy += scroll.y();
}
if (cachedNode) {
m_viewImpl->gCursorBoundsMutex.lock();
m_viewImpl->m_hasCursorBounds = true;
m_viewImpl->m_cursorBounds = cachedNode->bounds();
m_viewImpl->gCursorBoundsMutex.unlock();
}
DBG_NAV_LOGD("new cursor %d (nativeNode=%p) cursorLocation={%d, %d}"
"bounds={%d,%d,w=%d,h=%d}", cachedNode ? cachedNode->index() : 0,
cachedNode ? cachedNode->nodePointer() : 0,
root->cursorLocation().x(), root->cursorLocation().y(),
cachedNode ? cachedNode->bounds().x() : 0,
cachedNode ? cachedNode->bounds().y() : 0,
cachedNode ? cachedNode->bounds().width() : 0,
cachedNode ? cachedNode->bounds().height() : 0);
// If !m_heightCanMeasure (such as in the browser), we want to scroll no
// matter what
if (!ignoreScroll && (!m_heightCanMeasure ||
!cachedNode ||
(cursor && cursor->nodePointer() == cachedNode->nodePointer())))
{
if (count == 1 && dx != 0 && dy == 0 && -m_lastDx == dx &&
SkTime::GetMSecs() - m_lastDxTime < 1000)
root->checkForJiggle(&dx);
DBG_NAV_LOGD("scrollBy %d,%d", dx, dy);
if ((dx | dy))
this->scrollBy(dx, dy);
m_lastDx = dx;
m_lastDxTime = SkTime::GetMSecs();
ignoreScroll = true; // if move re-executes, don't scroll the second time
}
bool result = false;
if (cachedNode) {
WebCore::IntPoint pos;
root->setCursor((CachedFrame*) cachedFrame, (CachedNode*) cachedNode);
root->getSimulatedMousePosition(&pos);
if (lastSentCursor == cachedNode->nodePointer() && lastSentBounds &&
*lastSentBounds == cachedNode->bounds())
{
sendMoveMouse((WebCore::Frame*) cachedFrame->framePointer(),
(WebCore::Node*) cachedNode->nodePointer(), pos.x(), pos.y());
} else {
sendMoveMouseIfLatest();
if (inval)
viewInvalidate();
DBG_NAV_LOGD("history.mDidFirstLayout=%s",
savedHistory.didFirstLayout() ? "true" : "false");
}
} else {
int docHeight = root->documentHeight();
int docWidth = root->documentWidth();
if (visibleRect.bottom() + dy > docHeight)
dy = docHeight - visibleRect.bottom();
else if (visibleRect.y() + dy < 0)
dy = -visibleRect.y();
if (visibleRect.right() + dx > docWidth)
dx = docWidth - visibleRect.right();
else if (visibleRect.x() < 0)
dx = -visibleRect.x();
result = direction == CachedFrame::LEFT ? dx >= 0 :
direction == CachedFrame::RIGHT ? dx <= 0 :
direction == CachedFrame::UP ? dy >= 0 : dy <= 0;
}
return result;
}
void notifyProgressFinished()
{
DBG_NAV_LOGD("cursorIsTextInput=%d", cursorIsTextInput(DontAllowNewer));
rebuildWebTextView();
#if DEBUG_NAV_UI
if (m_frameCacheUI) {
const CachedNode* focus = m_frameCacheUI->currentFocus();
DBG_NAV_LOGD("focus %d (nativeNode=%p)",
focus ? focus->index() : 0,
focus ? focus->nodePointer() : 0);
}
#endif
}
const CachedNode* findAt(CachedRoot* root, const WebCore::IntRect& rect,
const CachedFrame** framePtr, int* rxPtr, int* ryPtr)
{
*rxPtr = 0;
*ryPtr = 0;
*framePtr = 0;
if (!root)
return 0;
WebCore::IntRect visibleRect;
getVisibleRect(&visibleRect);
root->setVisibleRect(visibleRect);
return root->findAt(rect, framePtr, rxPtr, ryPtr);
}
void selectBestAt(const WebCore::IntRect& rect)
{
const CachedFrame* frame;
int rx, ry;
CachedRoot* root = getFrameCache(DontAllowNewer);
const CachedNode* node = findAt(root, rect, &frame, &rx, &ry);
if (!node) {
DBG_NAV_LOGD("no nodes found root=%p", root);
if (root)
root->setCursor(0, 0);
} else {
DBG_NAV_LOGD("CachedNode:%p (%d)", node, node->index());
root->setCursor(const_cast<CachedFrame*>(frame),
const_cast<CachedNode*>(node));
}
sendMoveMouseIfLatest();
viewInvalidate();
}
WebCore::IntRect getNavBounds()
{
CachedRoot* root = getFrameCache(DontAllowNewer);
return root ? root->rootHistory()->navBounds() :
WebCore::IntRect(0, 0, 0, 0);
}
void setNavBounds(const WebCore::IntRect& rect)
{
CachedRoot* root = getFrameCache(DontAllowNewer);
if (!root)
return;
root->rootHistory()->setNavBounds(rect);
}
void markNodeInvalid(WebCore::Node* node)
{
DBG_NAV_LOGD("node=%p", node);
m_invalidNode = node;
viewInvalidate();
}
bool motionUp(int x, int y, int slop)
{
bool pageScrolled = false;
m_followedLink = false;
const CachedFrame* frame;
WebCore::IntRect rect = WebCore::IntRect(x - slop, y - slop, slop * 2, slop * 2);
int rx, ry;
CachedRoot* root = getFrameCache(AllowNewer);
if (!root)
return false;
const CachedNode* result = findAt(root, rect, &frame, &rx, &ry);
if (!result) {
DBG_NAV_LOGD("no nodes found root=%p", root);
setNavBounds(rect);
if (root) {
root->clearCursor();
int dx = root->checkForCenter(x, y);
if (dx) {
scrollBy(dx, 0);
pageScrolled = true;
}
}
sendMotionUp(frame ? (WebCore::Frame*) frame->framePointer() : 0,
0, x, y, slop);
viewInvalidate();
clearTextEntry();
return pageScrolled;
}
DBG_NAV_LOGD("CachedNode:%p (%d) x=%d y=%d rx=%d ry=%d", result,
result->index(), x, y, rx, ry);
setNavBounds(WebCore::IntRect(rx, ry, 1, 1));
root->setCursor(const_cast<CachedFrame*>(frame),
const_cast<CachedNode*>(result));
bool newNodeWantsKeyEvents = result->wantsKeyEvents();
CachedNodeType type = result->type();
if (type == NORMAL_CACHEDNODETYPE || newNodeWantsKeyEvents) {
sendMotionUp(
frame ? (WebCore::Frame*) frame->framePointer() : 0,
result ? (WebCore::Node*) result->nodePointer() : 0, rx, ry,
slop);
}
viewInvalidate();
if (newNodeWantsKeyEvents) {
rebuildWebTextView();
displaySoftKeyboard();
} else {
setFollowedLink(true);
if (type != NORMAL_CACHEDNODETYPE)
overrideUrlLoading(result->getExport());
}
return pageScrolled;
}
void overrideUrlLoading(const WebCore::String& url)
{
JNIEnv* env = JSC::Bindings::getJNIEnv();
jstring jName = env->NewString((jchar*) url.characters(), url.length());
env->CallVoidMethod(m_javaGlue.object(env).get(),
m_javaGlue.m_overrideLoading, jName);
env->DeleteLocalRef(jName);
}
void setFindIsUp(bool up)
{
m_viewImpl->m_findIsUp = up;
if (!up)
m_hasCurrentLocation = false;
}
void setFollowedLink(bool followed)
{
if ((m_followedLink = followed) != false) {
m_ringAnimationEnd = SkTime::GetMSecs() + 500;
viewInvalidate();
}
}
void setHeightCanMeasure(bool measure)
{
m_heightCanMeasure = measure;
}
SkIRect m_selStart, m_selEnd;
SkRegion m_selRegion;
#define MIN_ARROW_DISTANCE (20 * 20)
void moveSelection(int x, int y, bool extendSelection)
{
CachedRoot* root = getFrameCache(DontAllowNewer);
if (!root)
return;
const SkPicture& picture = *m_navPictureUI;
WebCore::IntRect r;
getVisibleRect(&r);
SkIRect area;
area.set(r.x(), r.y(), r.right(), r.bottom());
if (!extendSelection)
m_selStart = m_selEnd = CopyPaste::findClosest(picture, area, x, y);
else
m_selEnd = CopyPaste::findClosest(picture, area, x, y);
DBG_NAV_LOGD("x=%d y=%d extendSelection=%s m_selStart=(%d, %d, %d, %d)"
" m_selEnd=(%d, %d, %d, %d)", x, y, extendSelection ? "true" : "false",
m_selStart.fLeft, m_selStart.fTop, m_selStart.fRight, m_selStart.fBottom,
m_selEnd.fLeft, m_selEnd.fTop, m_selEnd.fRight, m_selEnd.fBottom);
}
const SkRegion& getSelection()
{
return m_selRegion;
}
void drawSelection(SkCanvas* canvas, int x, int y, bool extendSelection)
{
if (!extendSelection) {
int dx = x - m_selStart.fLeft;
dx *= dx;
int otherX = x - m_selStart.fRight;
if (dx > (otherX *= otherX))
dx = otherX;
int dy = y - m_selStart.fTop;
int dist = dx * dx + dy * dy;
if (dist > MIN_ARROW_DISTANCE)
drawSelectionArrow(canvas, x, y);
else
drawSelectionPointer(canvas, x, y, true);
} else {
drawSelectionRegion(canvas);
drawSelectionPointer(canvas, x, y, false);
}
}
void drawSelectionRegion(SkCanvas* canvas)
{
CachedRoot* root = getFrameCache(DontAllowNewer);
if (!root)
return;
WebCore::IntRect r;
getVisibleRect(&r);
SkIRect area;
area.set(r.x(), r.y(), r.right(), r.bottom());
m_selRegion.setEmpty();
CopyPaste::buildSelection(*m_navPictureUI, area, m_selStart, m_selEnd, &m_selRegion);
SkPath path;
m_selRegion.getBoundaryPath(&path);
SkPaint paint;
paint.setAntiAlias(true);
paint.setColor(SkColorSetARGB(0x40, 255, 51, 204));
canvas->drawPath(path, paint);
}
void drawSelectionPointer(SkCanvas* canvas, int x, int y, bool gridded)
{
SkPath path;
getSelectionCaret(&path);
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
paint.setColor(SK_ColorBLACK);
SkPixelXorXfermode xorMode(SK_ColorWHITE);
paint.setXfermode(&xorMode);
int sc = canvas->save();
if (gridded) {
bool useLeft = x <= (m_selStart.fLeft + m_selStart.fRight) >> 1;
canvas->translate(SkIntToScalar(useLeft ? m_selStart.fLeft :
m_selStart.fRight), SkIntToScalar(m_selStart.fTop));
} else
canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
canvas->drawPath(path, paint);
canvas->restoreToCount(sc);
}
void drawSelectionArrow(SkCanvas* canvas, int x, int y)
{
SkPath path;
getSelectionArrow(&path);
SkPaint paint;
paint.setAntiAlias(true);
paint.setStyle(SkPaint::kStroke_Style);
paint.setColor(SK_ColorBLACK);
paint.setStrokeWidth(SK_Scalar1 * 2);
int sc = canvas->save();
canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
canvas->drawPath(path, paint);
paint.setStyle(SkPaint::kFill_Style);
paint.setColor(SK_ColorWHITE);
canvas->drawPath(path, paint);
canvas->restoreToCount(sc);
}
void getSelectionArrow(SkPath* path)
{
const int arrow[] = {
0, 14, 3, 11, 5, 15, 9, 15, 7, 11, 11, 11
};
for (unsigned index = 0; index < sizeof(arrow)/sizeof(arrow[0]); index += 2)
path->lineTo(SkIntToScalar(arrow[index]), SkIntToScalar(arrow[index + 1]));
path->close();
}
void getSelectionCaret(SkPath* path)
{
SkScalar height = SkIntToScalar(m_selStart.fBottom - m_selStart.fTop);
SkScalar dist = height / 4;
path->lineTo(0, height);
SkScalar bottom = height + dist;
path->lineTo(-dist, bottom);
SkScalar edge = bottom - SK_Scalar1/2;
path->moveTo(-dist, edge);
path->lineTo(dist, edge);
path->moveTo(dist, bottom);
path->lineTo(0, height);
}
void sendMoveMouse(WebCore::Frame* framePtr, WebCore::Node* nodePtr, int x, int y)
{
DBG_NAV_LOGD("framePtr=%p nodePtr=%p x=%d y=%d", framePtr, nodePtr, x, y);
JNIEnv* env = JSC::Bindings::getJNIEnv();
env->CallVoidMethod(m_javaGlue.object(env).get(), m_javaGlue.m_sendMoveMouse,
(jint) framePtr, (jint) nodePtr, x, y);
checkException(env);
}
void sendMoveMouseIfLatest()
{
LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
JNIEnv* env = JSC::Bindings::getJNIEnv();
env->CallVoidMethod(m_javaGlue.object(env).get(),
m_javaGlue.m_sendMoveMouseIfLatest);
checkException(env);
}
void sendMotionUp(
WebCore::Frame* framePtr, WebCore::Node* nodePtr, int x, int y, int slop)
{
m_viewImpl->m_touchGeneration = m_viewImpl->m_generation = ++m_generation;
DBG_NAV_LOGD("m_generation=%d framePtr=%p nodePtr=%p x=%d y=%d slop=%d",
m_generation, framePtr, nodePtr, x, y, slop);
LOG_ASSERT(m_javaGlue.m_obj, "A WebView was not associated with this WebViewNative!");
JNIEnv* env = JSC::Bindings::getJNIEnv();
env->CallVoidMethod(m_javaGlue.object(env).get(), m_javaGlue.m_sendMotionUp,
m_generation, (jint) framePtr, (jint) nodePtr, x, y, slop);
checkException(env);
}
// This function is only used by findNext and setMatches. In it, we store
// upper left corner of the match specified by m_findIndex in
// m_currentMatchLocation.
void inline storeCurrentMatchLocation()
{
SkASSERT(m_findIndex < m_matches->size());
const SkIRect& bounds = (*m_matches)[m_findIndex].getLocation().getBounds();
m_currentMatchLocation.set(bounds.fLeft, bounds.fTop);
m_hasCurrentLocation = true;
}
void findNext(bool forward)
{
if (!m_matches || !m_matches->size())
return;
if (forward) {
m_findIndex++;
if (m_findIndex == m_matches->size())
m_findIndex = 0;
} else {
if (m_findIndex == 0) {
m_findIndex = m_matches->size() - 1;
} else {
m_findIndex--;
}
}
storeCurrentMatchLocation();
viewInvalidate();
}
// With this call, WebView takes ownership of matches, and is responsible for
// deleting it.
void setMatches(WTF::Vector<MatchInfo>* matches)
{
if (m_matches)
delete m_matches;
m_matches = matches;
if (m_matches->size()) {
if (m_hasCurrentLocation) {
for (unsigned i = 0; i < m_matches->size(); i++) {
const SkIRect& rect = (*m_matches)[i].getLocation().getBounds();
if (rect.fLeft == m_currentMatchLocation.fX
&& rect.fTop == m_currentMatchLocation.fY) {
m_findIndex = i;
viewInvalidate();
return;
}
}
}
// If we did not have a stored location, or if we were unable to restore
// it, store the new one.
m_findIndex = 0;
storeCurrentMatchLocation();
} else {
m_hasCurrentLocation = false;
}
viewInvalidate();
}
void scrollBy(int dx, int dy)
{
LOG_ASSERT(m_javaGlue.m_obj, "A java object was not associated with this native WebView!");
JNIEnv* env = JSC::Bindings::getJNIEnv();
env->CallVoidMethod(m_javaGlue.object(env).get(), m_javaGlue.m_scrollBy,
dx, dy, true);
checkException(env);
}
bool hasCursorNode()
{
CachedRoot* root = getFrameCache(DontAllowNewer);
if (!root) {
DBG_NAV_LOG("!root");
return false;
}
const CachedNode* cursorNode = root->currentCursor();
DBG_NAV_LOGD("cursorNode=%d (nodePointer=%p)",
cursorNode ? cursorNode->index() : -1,
cursorNode ? cursorNode->nodePointer() : 0);
return cursorNode;
}
bool hasFocusNode()
{
CachedRoot* root = getFrameCache(DontAllowNewer);
if (!root) {
DBG_NAV_LOG("!root");
return false;
}
const CachedNode* focusNode = root->currentFocus();
DBG_NAV_LOGD("focusNode=%d (nodePointer=%p)",
focusNode ? focusNode->index() : -1,
focusNode ? focusNode->nodePointer() : 0);
return focusNode;
}
void rebuildWebTextView()
{
JNIEnv* env = JSC::Bindings::getJNIEnv();
env->CallVoidMethod(m_javaGlue.object(env).get(),
m_javaGlue.m_rebuildWebTextView);
checkException(env);
}
void displaySoftKeyboard()
{
JNIEnv* env = JSC::Bindings::getJNIEnv();
env->CallVoidMethod(m_javaGlue.object(env).get(),
m_javaGlue.m_displaySoftKeyboard);
checkException(env);
}
void viewInvalidate()
{
JNIEnv* env = JSC::Bindings::getJNIEnv();
env->CallVoidMethod(m_javaGlue.object(env).get(), m_javaGlue.m_viewInvalidate);
checkException(env);
}
void viewInvalidateRect(int l, int t, int r, int b)
{
JNIEnv* env = JSC::Bindings::getJNIEnv();
env->CallVoidMethod(m_javaGlue.object(env).get(), m_javaGlue.m_viewInvalidateRect, l, r, t, b);
checkException(env);
}
void postInvalidateDelayed(int64_t delay, const WebCore::IntRect& bounds)
{
JNIEnv* env = JSC::Bindings::getJNIEnv();
env->CallVoidMethod(m_javaGlue.object(env).get(), m_javaGlue.m_postInvalidateDelayed,
delay, bounds.x(), bounds.y(), bounds.right(), bounds.bottom());
checkException(env);
}
int moveGeneration()
{
return m_viewImpl->m_moveGeneration;
}
private: // local state for WebView
// private to getFrameCache(); other functions operate in a different thread
CachedRoot* m_frameCacheUI; // navigation data ready for use
WebViewCore* m_viewImpl;
WebCore::Node* m_invalidNode;
int m_generation; // associate unique ID with sent kit focus to match with ui
SkPicture* m_navPictureUI;
bool m_followedLink;
SkMSec m_ringAnimationEnd;
// Corresponds to the same-named boolean on the java side.
bool m_heightCanMeasure;
int m_lastDx;
SkMSec m_lastDxTime;
WTF::Vector<MatchInfo>* m_matches;
// Stores the location of the current match.
SkIPoint m_currentMatchLocation;
// Tells whether the value in m_currentMatchLocation is valid.
bool m_hasCurrentLocation;
// Tells whether we have done the setup to draw the Find matches.
bool m_isFindPaintSetUp;
// Paint used to draw our Find matches.
SkPaint m_findPaint;
// Paint used for the background of our Find matches.
SkPaint m_findBlurPaint;
unsigned m_findIndex;
}; // end of WebView class
/*
* Native JNI methods
*/
static jstring WebCoreStringToJString(JNIEnv *env, WebCore::String string)
{
int length = string.length();
if (!length)
return 0;
jstring ret = env->NewString((jchar *)string.characters(), length);
env->DeleteLocalRef(ret);
return ret;
}
static void nativeClearFocus(JNIEnv *env, jobject obj, int x, int y)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
view->clearCursor(x, y, true);
}
static void nativeCreate(JNIEnv *env, jobject obj, int viewImpl)
{
WebView* webview = new WebView(env, obj, viewImpl);
// NEED THIS OR SOMETHING LIKE IT!
//Release(obj);
}
static jint nativeCursorFramePointer(JNIEnv *env, jobject obj)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
if (!root)
return 0;
const CachedFrame* frame = 0;
(void) root->currentCursor(&frame);
return reinterpret_cast<int>(frame ? frame->framePointer() : 0);
}
static const CachedNode* getCursorNode(JNIEnv *env, jobject obj)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
return root ? root->currentCursor() : 0;
}
static const CachedNode* getFocusCandidate(JNIEnv *env, jobject obj)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
if (!root)
return 0;
const CachedNode* cursor = root->currentCursor();
if (cursor && cursor->wantsKeyEvents())
return cursor;
return root->currentFocus();
}
static const CachedNode* getFocusNode(JNIEnv *env, jobject obj)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
return root ? root->currentFocus() : 0;
}
static jboolean nativeCursorMatchesFocus(JNIEnv *env, jobject obj)
{
const CachedNode* cursor = getCursorNode(env, obj);
const CachedNode* focus = getFocusNode(env, obj);
return cursor && focus && cursor->nodePointer() == focus->nodePointer();
}
static jobject nativeCursorNodeBounds(JNIEnv *env, jobject obj)
{
const CachedNode* node = getCursorNode(env, obj);
WebCore::IntRect bounds = node ? node->getBounds()
: WebCore::IntRect(0, 0, 0, 0);
jclass rectClass = env->FindClass("android/graphics/Rect");
jmethodID init = env->GetMethodID(rectClass, "<init>", "(IIII)V");
jobject rect = env->NewObject(rectClass, init, bounds.x(),
bounds.y(), bounds.right(), bounds.bottom());
return rect;
}
static jint nativeCursorNodePointer(JNIEnv *env, jobject obj)
{
const CachedNode* node = getCursorNode(env, obj);
return reinterpret_cast<int>(node ? node->nodePointer() : 0);
}
static WebCore::IntRect jrect_to_webrect(JNIEnv* env, jobject obj)
{
int L, T, R, B;
GraphicsJNI::get_jrect(env, obj, &L, &T, &R, &B);
return WebCore::IntRect(L, T, R - L, B - T);
}
static bool nativeCursorIntersects(JNIEnv *env, jobject obj, jobject visRect)
{
const CachedNode* node = getCursorNode(env, obj);
return node ? node->getBounds().intersects(jrect_to_webrect(env, visRect))
: false;
}
static bool nativeCursorIsAnchor(JNIEnv *env, jobject obj)
{
const CachedNode* node = getCursorNode(env, obj);
return node ? node->isAnchor() : false;
}
static bool nativeCursorIsTextInput(JNIEnv *env, jobject obj)
{
const CachedNode* node = getCursorNode(env, obj);
return node ? node->isTextField() || node->isTextArea() : false;
}
static jobject nativeCursorText(JNIEnv *env, jobject obj)
{
const CachedNode* node = getCursorNode(env, obj);
if (!node)
return 0;
WebCore::String value = node->getExport();
return !value.isEmpty() ? env->NewString((jchar *)value.characters(),
value.length()) : 0;
}
static void nativeDebugDump(JNIEnv *env, jobject obj)
{
#if DUMP_NAV_CACHE
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
view->debugDump();
#endif
}
static void nativeDrawMatches(JNIEnv *env, jobject obj, jobject canv)
{
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, canv);
if (!canv) {
DBG_NAV_LOG("!canv");
return;
}
WebView* view = GET_NATIVE_VIEW(env, obj);
if (!view) {
DBG_NAV_LOG("!view");
return;
}
view->drawMatches(canvas);
}
static void nativeDrawCursorRing(JNIEnv *env, jobject obj, jobject canv)
{
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, canv);
if (!canv) {
DBG_NAV_LOG("!canv");
return;
}
WebView* view = GET_NATIVE_VIEW(env, obj);
if (!view) {
DBG_NAV_LOG("!view");
return;
}
view->drawCursorRing(canvas);
}
static void nativeDrawSelection(JNIEnv *env, jobject obj,
jobject canv, jint x, jint y, bool ex)
{
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, canv);
if (!canv) {
DBG_NAV_LOG("!canv");
return;
}
WebView* view = GET_NATIVE_VIEW(env, obj);
if (!view) {
DBG_NAV_LOG("!view");
return;
}
view->drawSelection(canvas, x, y, ex);
}
static void nativeDrawSelectionRegion(JNIEnv *env, jobject obj, jobject canv)
{
SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, canv);
if (!canv) {
DBG_NAV_LOG("!canv");
return;
}
WebView* view = GET_NATIVE_VIEW(env, obj);
if (!view) {
DBG_NAV_LOG("!view");
return;
}
view->drawSelectionRegion(canvas);
}
static jobject nativeImageURI(JNIEnv *env, jobject obj, jint x, jint y)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
WebCore::String uri = view->imageURI(x, y);
jstring ret = 0;
unsigned len = uri.length();
if (len) {
ret = env->NewString((jchar*) uri.characters(), len);
env->DeleteLocalRef(ret);
}
return ret;
}
static bool nativeFocusIsPassword(JNIEnv *env, jobject obj)
{
const CachedNode* node = getFocusCandidate(env, obj);
return node ? node->isPassword() : false;
}
static bool nativeFocusIsRtlText(JNIEnv *env, jobject obj)
{
const CachedNode* node = getFocusCandidate(env, obj);
return node ? node->isRtlText() : false;
}
static bool nativeFocusIsTextField(JNIEnv *env, jobject obj)
{
const CachedNode* node = getFocusCandidate(env, obj);
return node ? node->isTextField() : false;
}
static bool nativeFocusIsTextInput(JNIEnv *env, jobject obj)
{
const CachedNode* node = getFocusCandidate(env, obj);
return node ? node->isTextField() || node->isTextArea() : false;
}
static jint nativeFocusMaxLength(JNIEnv *env, jobject obj)
{
const CachedNode* node = getFocusCandidate(env, obj);
return node ? node->maxLength() : false;
}
static jobject nativeFocusName(JNIEnv *env, jobject obj)
{
const CachedNode* node = getFocusCandidate(env, obj);
if (!node)
return 0;
const WebCore::String& name = node->name();
return env->NewString((jchar*)name.characters(), name.length());
}
static jobject nativeFocusNodeBounds(JNIEnv *env, jobject obj)
{
const CachedNode* node = getFocusCandidate(env, obj);
WebCore::IntRect bounds = node ? node->getBounds()
: WebCore::IntRect(0, 0, 0, 0);
jclass rectClass = env->FindClass("android/graphics/Rect");
jmethodID init = env->GetMethodID(rectClass, "<init>", "(IIII)V");
jobject rect = env->NewObject(rectClass, init, bounds.x(),
bounds.y(), bounds.right(), bounds.bottom());
return rect;
}
static jint nativeFocusNodePointer(JNIEnv *env, jobject obj)
{
const CachedNode* node = getFocusCandidate(env, obj);
return reinterpret_cast<int>(node ? node->nodePointer() : 0);
}
static jobject nativeFocusText(JNIEnv *env, jobject obj)
{
const CachedNode* node = getFocusCandidate(env, obj);
if (!node)
return 0;
WebCore::String value = node->getExport();
return !value.isEmpty() ? env->NewString((jchar *)value.characters(),
value.length()) : 0;
}
static jint nativeFocusTextSize(JNIEnv *env, jobject obj)
{
const CachedNode* node = getFocusCandidate(env, obj);
return node ? node->textSize() : 0;
}
static bool nativeCursorWantsKeyEvents(JNIEnv* env, jobject jwebview) {
WebView* view = GET_NATIVE_VIEW(env, jwebview);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
return view->cursorWantsKeyEvents();
}
static void nativeInstrumentReport(JNIEnv *env, jobject obj)
{
#ifdef ANDROID_INSTRUMENT
TimeCounter::reportNow();
#endif
}
static void nativeSelectBestAt(JNIEnv *env, jobject obj, jobject jrect)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
WebCore::IntRect rect = jrect_to_webrect(env, jrect);
view->selectBestAt(rect);
}
static jint nativeTextGeneration(JNIEnv *env, jobject obj)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
return root ? root->textGeneration() : 0;
}
static void nativeMarkNodeInvalid(JNIEnv *env, jobject obj, int node)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
view->markNodeInvalid((WebCore::Node*) node);
}
static bool nativeMotionUp(JNIEnv *env, jobject obj,
int x, int y, int slop)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
return view->motionUp(x, y, slop);
}
static bool nativeHasCursorNode(JNIEnv *env, jobject obj)
{
return GET_NATIVE_VIEW(env, obj)->hasCursorNode();
}
static bool nativeHasFocusNode(JNIEnv *env, jobject obj)
{
return GET_NATIVE_VIEW(env, obj)->hasFocusNode();
}
static bool nativeMoveFocus(JNIEnv *env, jobject obj,
int key, int count, bool ignoreScroll)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
DBG_NAV_LOGD("env=%p obj=%p view=%p", env, obj, view);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
return view->moveCursor(key, count, ignoreScroll, true, 0, 0);
}
static void nativeRecomputeFocus(JNIEnv *env, jobject obj)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
// view->recomputeFocus();
}
static void nativeRecordButtons(JNIEnv* env, jobject obj, bool hasFocus,
bool pressed, bool invalidate)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
view->nativeRecordButtons(hasFocus, pressed, invalidate);
}
static void nativeSetFindIsDown(JNIEnv *env, jobject obj)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
view->setFindIsUp(false);
}
static void nativeSetFollowedLink(JNIEnv *env, jobject obj, bool followed)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
view->setFollowedLink(followed);
}
static void nativeSetHeightCanMeasure(JNIEnv *env, jobject obj, bool measure)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in nativeSetHeightCanMeasure");
view->setHeightCanMeasure(measure);
}
static jobject nativeGetCursorRingBounds(JNIEnv *env, jobject obj)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
jclass rectClass = env->FindClass("android/graphics/Rect");
LOG_ASSERT(rectClass, "Could not find Rect class!");
jmethodID init = env->GetMethodID(rectClass, "<init>", "(IIII)V");
LOG_ASSERT(init, "Could not find constructor for Rect");
WebCore::IntRect webRect;
view->cursorRingBounds(&webRect);
jobject rect = env->NewObject(rectClass, init, webRect.x(),
webRect.y(), webRect.right(), webRect.bottom());
return rect;
}
static int nativeFindAll(JNIEnv *env, jobject obj, jstring findLower,
jstring findUpper)
{
// If one or the other is null, do not search.
if (!(findLower && findUpper))
return 0;
// Obtain the characters for both the lower case string and the upper case
// string representing the same word.
const jchar* findLowerChars = env->GetStringChars(findLower, 0);
const jchar* findUpperChars = env->GetStringChars(findUpper, 0);
// If one or the other is null, do not search.
if (!(findLowerChars && findUpperChars)) {
if (findLowerChars)
env->ReleaseStringChars(findLower, findLowerChars);
if (findUpperChars)
env->ReleaseStringChars(findUpper, findUpperChars);
checkException(env);
return 0;
}
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in nativeFindAll");
view->setFindIsUp(true);
CachedRoot* root = view->getFrameCache(WebView::AllowNewer);
if (!root) {
env->ReleaseStringChars(findLower, findLowerChars);
env->ReleaseStringChars(findUpper, findUpperChars);
checkException(env);
return 0;
}
int length = env->GetStringLength(findLower);
// If the lengths of the strings do not match, then they are not the same
// word, so do not search.
if (!length || env->GetStringLength(findUpper) != length) {
env->ReleaseStringChars(findLower, findLowerChars);
env->ReleaseStringChars(findUpper, findUpperChars);
checkException(env);
return 0;
}
int width = root->documentWidth();
int height = root->documentHeight();
// Create a FindCanvas, which allows us to fake draw into it so we can
// figure out where our search string is rendered (and how many times).
FindCanvas canvas(width, height, (const UChar*) findLowerChars,
(const UChar*) findUpperChars, length << 1);
SkBitmap bitmap;
bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
canvas.setBitmapDevice(bitmap);
canvas.drawPicture(*(root->getPicture()));
WTF::Vector<MatchInfo>* matches = canvas.detachMatches();
// With setMatches, the WebView takes ownership of matches
view->setMatches(matches);
env->ReleaseStringChars(findLower, findLowerChars);
env->ReleaseStringChars(findUpper, findUpperChars);
checkException(env);
return canvas.found();
}
static void nativeFindNext(JNIEnv *env, jobject obj, bool forward)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in nativeFindNext");
view->findNext(forward);
}
static void nativeUpdateCachedTextfield(JNIEnv *env, jobject obj, jstring updatedText, jint generation)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in nativeUpdateCachedTextfield");
CachedRoot* root = view->getFrameCache(WebView::DontAllowNewer);
if (!root)
return;
const CachedNode* cachedFocusNode = root->currentFocus();
if (!cachedFocusNode || (!cachedFocusNode->isTextField() && !cachedFocusNode->isTextArea()))
return;
WebCore::String webcoreString = to_string(env, updatedText);
(const_cast<CachedNode*>(cachedFocusNode))->setExport(webcoreString);
root->setTextGeneration(generation);
checkException(env);
}
static void nativeDestroy(JNIEnv *env, jobject obj)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOGD("nativeDestroy view: %p", view);
LOG_ASSERT(view, "view not set in nativeDestroy");
delete view;
}
static int nativeMoveGeneration(JNIEnv *env, jobject obj)
{
return GET_NATIVE_VIEW(env, obj)->moveGeneration();
}
static void nativeMoveSelection(JNIEnv *env, jobject obj, int x, int y, bool ex)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
view->moveSelection(x, y, ex);
}
static jobject nativeGetSelection(JNIEnv *env, jobject obj)
{
WebView* view = GET_NATIVE_VIEW(env, obj);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
return GraphicsJNI::createRegion(env, new SkRegion(view->getSelection()));
}
#ifdef ANDROID_DUMP_DISPLAY_TREE
static void dumpToFile(const char text[], void* file) {
fwrite(text, 1, strlen(text), reinterpret_cast<FILE*>(file));
fwrite("\n", 1, 1, reinterpret_cast<FILE*>(file));
}
#endif
static void nativeDumpDisplayTree(JNIEnv* env, jobject jwebview, jstring jurl)
{
#ifdef ANDROID_DUMP_DISPLAY_TREE
WebView* view = GET_NATIVE_VIEW(env, jwebview);
LOG_ASSERT(view, "view not set in %s", __FUNCTION__);
if (view && view->getWebViewCore()) {
FILE* file = fopen(DISPLAY_TREE_LOG_FILE, "w");
if (file) {
SkFormatDumper dumper(dumpToFile, file);
// dump the URL
if (jurl) {
const char* str = env->GetStringUTFChars(jurl, 0);
SkDebugf("Dumping %s to %s\n", str, DISPLAY_TREE_LOG_FILE);
dumpToFile(str, file);
env->ReleaseStringUTFChars(jurl, str);
}
// now dump the display tree
SkDumpCanvas canvas(&dumper);
// this will playback the picture into the canvas, which will
// spew its contents to the dumper
view->getWebViewCore()->drawContent(&canvas, 0);
// we're done with the file now
fwrite("\n", 1, 1, file);
fclose(file);
}
}
#endif
}
/*
* JNI registration
*/
static JNINativeMethod gJavaWebViewMethods[] = {
{ "nativeClearFocus", "(II)V",
(void*) nativeClearFocus },
{ "nativeCreate", "(I)V",
(void*) nativeCreate },
{ "nativeCursorFramePointer", "()I",
(void*) nativeCursorFramePointer },
{ "nativeCursorMatchesFocus", "()Z",
(void*) nativeCursorMatchesFocus },
{ "nativeCursorNodeBounds", "()Landroid/graphics/Rect;",
(void*) nativeCursorNodeBounds },
{ "nativeCursorNodePointer", "()I",
(void*) nativeCursorNodePointer },
{ "nativeCursorIntersects", "(Landroid/graphics/Rect;)Z",
(void*) nativeCursorIntersects },
{ "nativeCursorIsAnchor", "()Z",
(void*) nativeCursorIsAnchor },
{ "nativeCursorIsTextInput", "()Z",
(void*) nativeCursorIsTextInput },
{ "nativeCursorText", "()Ljava/lang/String;",
(void*) nativeCursorText },
{ "nativeCursorWantsKeyEvents", "()Z",
(void*)nativeCursorWantsKeyEvents },
{ "nativeDebugDump", "()V",
(void*) nativeDebugDump },
{ "nativeDestroy", "()V",
(void*) nativeDestroy },
{ "nativeDrawCursorRing", "(Landroid/graphics/Canvas;)V",
(void*) nativeDrawCursorRing },
{ "nativeDrawMatches", "(Landroid/graphics/Canvas;)V",
(void*) nativeDrawMatches },
{ "nativeDrawSelection", "(Landroid/graphics/Canvas;IIZ)V",
(void*) nativeDrawSelection },
{ "nativeDrawSelectionRegion", "(Landroid/graphics/Canvas;)V",
(void*) nativeDrawSelectionRegion },
{ "nativeDumpDisplayTree", "(Ljava/lang/String;)V",
(void*) nativeDumpDisplayTree },
{ "nativeFindAll", "(Ljava/lang/String;Ljava/lang/String;)I",
(void*) nativeFindAll },
{ "nativeFindNext", "(Z)V",
(void*) nativeFindNext },
{ "nativeFocusIsPassword", "()Z",
(void*) nativeFocusIsPassword },
{ "nativeFocusIsRtlText", "()Z",
(void*) nativeFocusIsRtlText },
{ "nativeFocusIsTextField", "()Z",
(void*) nativeFocusIsTextField },
{ "nativeFocusIsTextInput", "()Z",
(void*) nativeFocusIsTextInput },
{ "nativeFocusMaxLength", "()I",
(void*) nativeFocusMaxLength },
{ "nativeFocusName", "()Ljava/lang/String;",
(void*) nativeFocusName },
{ "nativeFocusNodeBounds", "()Landroid/graphics/Rect;",
(void*) nativeFocusNodeBounds },
{ "nativeFocusNodePointer", "()I",
(void*) nativeFocusNodePointer },
{ "nativeFocusText", "()Ljava/lang/String;",
(void*) nativeFocusText },
{ "nativeFocusTextSize", "()I",
(void*) nativeFocusTextSize },
{ "nativeGetCursorRingBounds", "()Landroid/graphics/Rect;",
(void*) nativeGetCursorRingBounds },
{ "nativeGetSelection", "()Landroid/graphics/Region;",
(void*) nativeGetSelection },
{ "nativeHasCursorNode", "()Z",
(void*) nativeHasCursorNode },
{ "nativeHasFocusNode", "()Z",
(void*) nativeHasFocusNode },
{ "nativeImageURI", "(II)Ljava/lang/String;",
(void*) nativeImageURI },
{ "nativeInstrumentReport", "()V",
(void*) nativeInstrumentReport },
{ "nativeMarkNodeInvalid", "(I)V",
(void*) nativeMarkNodeInvalid },
{ "nativeMotionUp", "(III)Z",
(void*) nativeMotionUp },
{ "nativeMoveFocus", "(IIZ)Z",
(void*) nativeMoveFocus },
{ "nativeMoveGeneration", "()I",
(void*) nativeMoveGeneration },
{ "nativeMoveSelection", "(IIZ)V",
(void*) nativeMoveSelection },
{ "nativeRecomputeFocus", "()V",
(void*) nativeRecomputeFocus },
{ "nativeRecordButtons", "(ZZZ)V",
(void*) nativeRecordButtons },
{ "nativeSelectBestAt", "(Landroid/graphics/Rect;)V",
(void*) nativeSelectBestAt },
{ "nativeSetFindIsDown", "()V",
(void*) nativeSetFindIsDown },
{ "nativeSetFollowedLink", "(Z)V",
(void*) nativeSetFollowedLink },
{ "nativeSetHeightCanMeasure", "(Z)V",
(void*) nativeSetHeightCanMeasure },
{ "nativeTextGeneration", "()I",
(void*) nativeTextGeneration },
{ "nativeUpdateCachedTextfield", "(Ljava/lang/String;I)V",
(void*) nativeUpdateCachedTextfield }
};
int register_webview(JNIEnv* env)
{
jclass clazz = env->FindClass("android/webkit/WebView");
LOG_ASSERT(clazz, "Unable to find class android/webkit/WebView");
gWebViewField = env->GetFieldID(clazz, "mNativeClass", "I");
LOG_ASSERT(gWebViewField, "Unable to find android/webkit/WebView.mNativeClass");
return jniRegisterNativeMethods(env, "android/webkit/WebView", gJavaWebViewMethods, NELEM(gJavaWebViewMethods));
}
} // namespace android