/* -*- Mode: c++; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: nil; -*- * ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is Mozilla Android code. * * The Initial Developer of the Original Code is Mozilla Foundation. * Portions created by the Initial Developer are Copyright (C) 2010 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Vladimir Vukicevic * Matt Brubeck * Vivien Nicolas * * Alternatively, the contents of this file may be used under the terms of * either the GNU General Public License Version 2 or later (the "GPL"), or * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ #include #include #include #include "mozilla/dom/ContentParent.h" #include "mozilla/dom/ContentChild.h" #include "mozilla/unused.h" #include "mozilla/Preferences.h" #include "mozilla/layers/RenderTrace.h" using mozilla::dom::ContentParent; using mozilla::dom::ContentChild; using mozilla::unused; #include "nsAppShell.h" #include "nsIdleService.h" #include "nsWindow.h" #include "nsIObserverService.h" #include "nsFocusManager.h" #include "nsRenderingContext.h" #include "nsIDOMSimpleGestureEvent.h" #include "nsDOMTouchEvent.h" #include "nsGkAtoms.h" #include "nsWidgetsCID.h" #include "nsGfxCIID.h" #include "gfxImageSurface.h" #include "gfxContext.h" #include "Layers.h" #include "BasicLayers.h" #include "LayerManagerOGL.h" #include "GLContext.h" #include "GLContextProvider.h" #include "nsTArray.h" #include "AndroidBridge.h" #include "imgIEncoder.h" #include "nsStringGlue.h" #include "nsAutoPtr.h" using namespace mozilla; using namespace mozilla::widget; NS_IMPL_ISUPPORTS_INHERITED0(nsWindow, nsBaseWidget) // The dimensions of the current android view static gfxIntSize gAndroidBounds = gfxIntSize(0, 0); static gfxIntSize gAndroidScreenBounds; #ifdef MOZ_JAVA_COMPOSITOR #include "mozilla/layers/CompositorChild.h" #include "mozilla/layers/CompositorParent.h" #include "mozilla/Mutex.h" #include "nsThreadUtils.h" #endif class ContentCreationNotifier; static nsCOMPtr gContentCreationNotifier; // A helper class to send updates when content processes // are created. Currently an update for the screen size is sent. class ContentCreationNotifier : public nsIObserver { NS_DECL_ISUPPORTS NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic, const PRUnichar* aData) { if (!strcmp(aTopic, "ipc:content-created")) { nsCOMPtr cpo = do_QueryInterface(aSubject); ContentParent* cp = static_cast(cpo.get()); unused << cp->SendScreenSizeChanged(gAndroidScreenBounds); } else if (!strcmp(aTopic, "xpcom-shutdown")) { nsCOMPtr obs(do_GetService("@mozilla.org/observer-service;1")); if (obs) { obs->RemoveObserver(static_cast(this), "xpcom-shutdown"); obs->RemoveObserver(static_cast(this), "ipc:content-created"); } gContentCreationNotifier = nsnull; } return NS_OK; } }; NS_IMPL_ISUPPORTS1(ContentCreationNotifier, nsIObserver) static bool gMenu; static bool gMenuConsumed; // All the toplevel windows that have been created; these are in // stacking order, so the window at gAndroidBounds[0] is the topmost // one. static nsTArray gTopLevelWindows; static nsRefPtr sGLContext; static bool sFailedToCreateGLContext = false; static bool sValidSurface; static bool sSurfaceExists = false; static void *sNativeWindow = nsnull; // Multitouch swipe thresholds in inches static const double SWIPE_MAX_PINCH_DELTA_INCHES = 0.4; static const double SWIPE_MIN_DISTANCE_INCHES = 0.6; static nsWindow* TopWindow() { if (!gTopLevelWindows.IsEmpty()) return gTopLevelWindows[0]; return nsnull; } void nsWindow::LogWindow(nsWindow *win, int index, int indent) { char spaces[] = " "; spaces[indent < 20 ? indent : 20] = 0; ALOG("%s [% 2d] 0x%08x [parent 0x%08x] [% 3d,% 3d % 3dx% 3d] vis %d type %d", spaces, index, (intptr_t)win, (intptr_t)win->mParent, win->mBounds.x, win->mBounds.y, win->mBounds.width, win->mBounds.height, win->mIsVisible, win->mWindowType); } void nsWindow::DumpWindows() { DumpWindows(gTopLevelWindows); } void nsWindow::DumpWindows(const nsTArray& wins, int indent) { for (PRUint32 i = 0; i < wins.Length(); ++i) { nsWindow *w = wins[i]; LogWindow(w, i, indent); DumpWindows(w->mChildren, indent+1); } } nsWindow::nsWindow() : mIsVisible(false), mParent(nsnull), mFocus(nsnull), mIMEComposing(false) { } nsWindow::~nsWindow() { gTopLevelWindows.RemoveElement(this); nsWindow *top = FindTopLevel(); if (top->mFocus == this) top->mFocus = nsnull; ALOG("nsWindow %p destructor", (void*)this); #ifdef MOZ_JAVA_COMPOSITOR SetCompositor(NULL, NULL, NULL); #endif } bool nsWindow::IsTopLevel() { return mWindowType == eWindowType_toplevel || mWindowType == eWindowType_dialog || mWindowType == eWindowType_invisible; } NS_IMETHODIMP nsWindow::Create(nsIWidget *aParent, nsNativeWidget aNativeParent, const nsIntRect &aRect, EVENT_CALLBACK aHandleEventFunction, nsDeviceContext *aContext, nsWidgetInitData *aInitData) { ALOG("nsWindow[%p]::Create %p [%d %d %d %d]", (void*)this, (void*)aParent, aRect.x, aRect.y, aRect.width, aRect.height); nsWindow *parent = (nsWindow*) aParent; if (!AndroidBridge::Bridge()) { aNativeParent = nsnull; } if (aNativeParent) { if (parent) { ALOG("Ignoring native parent on Android window [%p], since parent was specified (%p %p)", (void*)this, (void*)aNativeParent, (void*)aParent); } else { parent = (nsWindow*) aNativeParent; } } mBounds = aRect; // for toplevel windows, bounds are fixed to full screen size if (!parent) { mBounds.x = 0; mBounds.y = 0; mBounds.width = gAndroidBounds.width; mBounds.height = gAndroidBounds.height; } BaseCreate(nsnull, mBounds, aHandleEventFunction, aContext, aInitData); NS_ASSERTION(IsTopLevel() || parent, "non top level windowdoesn't have a parent!"); if (IsTopLevel()) { gTopLevelWindows.AppendElement(this); } if (parent) { parent->mChildren.AppendElement(this); mParent = parent; } float dpi = GetDPI(); mSwipeMaxPinchDelta = SWIPE_MAX_PINCH_DELTA_INCHES * dpi; mSwipeMinDistance = SWIPE_MIN_DISTANCE_INCHES * dpi; return NS_OK; } NS_IMETHODIMP nsWindow::Destroy(void) { nsBaseWidget::mOnDestroyCalled = true; for (PRUint32 i = 0; i < mChildren.Length(); ++i) { // why do we still have children? ALOG("### Warning: Destroying window %p and reparenting child %p to null!", (void*)this, (void*)mChildren[i]); mChildren[i]->SetParent(nsnull); } if (IsTopLevel()) gTopLevelWindows.RemoveElement(this); if (mParent) mParent->mChildren.RemoveElement(this); nsBaseWidget::OnDestroy(); return NS_OK; } NS_IMETHODIMP nsWindow::ConfigureChildren(const nsTArray& config) { for (PRUint32 i = 0; i < config.Length(); ++i) { nsWindow *childWin = (nsWindow*) config[i].mChild; childWin->Resize(config[i].mBounds.x, config[i].mBounds.y, config[i].mBounds.width, config[i].mBounds.height, false); } return NS_OK; } void nsWindow::RedrawAll() { nsIntRect entireRect(0, 0, gAndroidBounds.width, gAndroidBounds.height); AndroidGeckoEvent *event = new AndroidGeckoEvent(AndroidGeckoEvent::DRAW, entireRect); nsAppShell::gAppShell->PostEvent(event); } NS_IMETHODIMP nsWindow::SetParent(nsIWidget *aNewParent) { if ((nsIWidget*)mParent == aNewParent) return NS_OK; // If we had a parent before, remove ourselves from its list of // children. If we didn't have a parent, then remove ourselves // from the list of toplevel windows if we're about to get a // parent. if (mParent) mParent->mChildren.RemoveElement(this); mParent = (nsWindow*)aNewParent; if (mParent) mParent->mChildren.AppendElement(this); // if we are now in the toplevel window's hierarchy, schedule a redraw if (FindTopLevel() == TopWindow()) RedrawAll(); return NS_OK; } NS_IMETHODIMP nsWindow::ReparentNativeWidget(nsIWidget *aNewParent) { NS_PRECONDITION(aNewParent, ""); return NS_OK; } nsIWidget* nsWindow::GetParent() { return mParent; } float nsWindow::GetDPI() { if (AndroidBridge::Bridge()) return AndroidBridge::Bridge()->GetDPI(); return 160.0f; } NS_IMETHODIMP nsWindow::Show(bool aState) { ALOG("nsWindow[%p]::Show %d", (void*)this, aState); if (mWindowType == eWindowType_invisible) { ALOG("trying to show invisible window! ignoring.."); return NS_ERROR_FAILURE; } if (aState == mIsVisible) return NS_OK; mIsVisible = aState; if (IsTopLevel()) { // XXX should we bring this to the front when it's shown, // if it's a toplevel widget? // XXX we should synthesize a NS_MOUSE_EXIT (for old top // window)/NS_MOUSE_ENTER (for new top window) since we need // to pretend that the top window always has focus. Not sure // if Show() is the right place to do this, though. if (aState) { // It just became visible, so send a resize update if necessary // and bring it to the front. Resize(0, 0, gAndroidBounds.width, gAndroidBounds.height, false); BringToFront(); } else if (TopWindow() == this) { // find the next visible window to show unsigned int i; for (i = 1; i < gTopLevelWindows.Length(); i++) { nsWindow *win = gTopLevelWindows[i]; if (!win->mIsVisible) continue; win->BringToFront(); break; } } } else if (FindTopLevel() == TopWindow()) { RedrawAll(); } #ifdef DEBUG_ANDROID_WIDGET DumpWindows(); #endif return NS_OK; } NS_IMETHODIMP nsWindow::SetModal(bool aState) { ALOG("nsWindow[%p]::SetModal %d ignored", (void*)this, aState); return NS_OK; } NS_IMETHODIMP nsWindow::IsVisible(bool& aState) { aState = mIsVisible; return NS_OK; } NS_IMETHODIMP nsWindow::ConstrainPosition(bool aAllowSlop, PRInt32 *aX, PRInt32 *aY) { ALOG("nsWindow[%p]::ConstrainPosition %d [%d %d]", (void*)this, aAllowSlop, *aX, *aY); // constrain toplevel windows; children we don't care about if (IsTopLevel()) { *aX = 0; *aY = 0; } return NS_OK; } NS_IMETHODIMP nsWindow::Move(PRInt32 aX, PRInt32 aY) { if (IsTopLevel()) return NS_OK; return Resize(aX, aY, mBounds.width, mBounds.height, true); } NS_IMETHODIMP nsWindow::Resize(PRInt32 aWidth, PRInt32 aHeight, bool aRepaint) { return Resize(mBounds.x, mBounds.y, aWidth, aHeight, aRepaint); } NS_IMETHODIMP nsWindow::Resize(PRInt32 aX, PRInt32 aY, PRInt32 aWidth, PRInt32 aHeight, bool aRepaint) { ALOG("nsWindow[%p]::Resize [%d %d %d %d] (repaint %d)", (void*)this, aX, aY, aWidth, aHeight, aRepaint); bool needSizeDispatch = aWidth != mBounds.width || aHeight != mBounds.height; mBounds.x = aX; mBounds.y = aY; mBounds.width = aWidth; mBounds.height = aHeight; if (needSizeDispatch) OnSizeChanged(gfxIntSize(aWidth, aHeight)); // Should we skip honoring aRepaint here? if (aRepaint && FindTopLevel() == TopWindow()) RedrawAll(); return NS_OK; } NS_IMETHODIMP nsWindow::SetZIndex(PRInt32 aZIndex) { ALOG("nsWindow[%p]::SetZIndex %d ignored", (void*)this, aZIndex); return NS_OK; } NS_IMETHODIMP nsWindow::PlaceBehind(nsTopLevelWidgetZPlacement aPlacement, nsIWidget *aWidget, bool aActivate) { return NS_OK; } NS_IMETHODIMP nsWindow::SetSizeMode(PRInt32 aMode) { switch (aMode) { case nsSizeMode_Minimized: AndroidBridge::Bridge()->MoveTaskToBack(); break; case nsSizeMode_Fullscreen: MakeFullScreen(true); break; } return NS_OK; } NS_IMETHODIMP nsWindow::Enable(bool aState) { ALOG("nsWindow[%p]::Enable %d ignored", (void*)this, aState); return NS_OK; } NS_IMETHODIMP nsWindow::IsEnabled(bool *aState) { *aState = true; return NS_OK; } NS_IMETHODIMP nsWindow::Invalidate(const nsIntRect &aRect) { AndroidGeckoEvent *event = new AndroidGeckoEvent(AndroidGeckoEvent::DRAW, aRect); nsAppShell::gAppShell->PostEvent(event); return NS_OK; } nsWindow* nsWindow::FindTopLevel() { nsWindow *toplevel = this; while (toplevel) { if (toplevel->IsTopLevel()) return toplevel; toplevel = toplevel->mParent; } ALOG("nsWindow::FindTopLevel(): couldn't find a toplevel or dialog window in this [%p] widget's hierarchy!", (void*)this); return this; } NS_IMETHODIMP nsWindow::SetFocus(bool aRaise) { if (!aRaise) ALOG("nsWindow::SetFocus: can't set focus without raising, ignoring aRaise = false!"); if (!AndroidBridge::Bridge()) return NS_OK; nsWindow *top = FindTopLevel(); top->mFocus = this; top->BringToFront(); return NS_OK; } void nsWindow::BringToFront() { // If the window to be raised is the same as the currently raised one, // do nothing. We need to check the focus manager as well, as the first // window that is created will be first in the window list but won't yet // be focused. nsCOMPtr fm = do_GetService(FOCUSMANAGER_CONTRACTID); nsCOMPtr existingTopWindow; fm->GetActiveWindow(getter_AddRefs(existingTopWindow)); if (existingTopWindow && FindTopLevel() == TopWindow()) return; if (!IsTopLevel()) { FindTopLevel()->BringToFront(); return; } nsRefPtr kungFuDeathGrip(this); nsWindow *oldTop = nsnull; nsWindow *newTop = this; if (!gTopLevelWindows.IsEmpty()) oldTop = gTopLevelWindows[0]; gTopLevelWindows.RemoveElement(this); gTopLevelWindows.InsertElementAt(0, this); if (oldTop) { nsGUIEvent event(true, NS_DEACTIVATE, oldTop); DispatchEvent(&event); } if (Destroyed()) { // somehow the deactivate event handler destroyed this window. // try to recover by grabbing the next window in line and activating // that instead if (gTopLevelWindows.IsEmpty()) return; newTop = gTopLevelWindows[0]; } nsGUIEvent event(true, NS_ACTIVATE, newTop); DispatchEvent(&event); // force a window resize nsAppShell::gAppShell->ResendLastResizeEvent(newTop); RedrawAll(); } NS_IMETHODIMP nsWindow::GetScreenBounds(nsIntRect &aRect) { nsIntPoint p = WidgetToScreenOffset(); aRect.x = p.x; aRect.y = p.y; aRect.width = mBounds.width; aRect.height = mBounds.height; return NS_OK; } nsIntPoint nsWindow::WidgetToScreenOffset() { nsIntPoint p(0, 0); nsWindow *w = this; while (w && !w->IsTopLevel()) { p.x += w->mBounds.x; p.y += w->mBounds.y; w = w->mParent; } return p; } NS_IMETHODIMP nsWindow::DispatchEvent(nsGUIEvent *aEvent, nsEventStatus &aStatus) { aStatus = DispatchEvent(aEvent); return NS_OK; } nsEventStatus nsWindow::DispatchEvent(nsGUIEvent *aEvent) { if (mEventCallback) { nsEventStatus status = (*mEventCallback)(aEvent); switch (aEvent->message) { case NS_COMPOSITION_START: mIMEComposing = true; break; case NS_COMPOSITION_END: mIMEComposing = false; break; case NS_TEXT_TEXT: mIMEComposingText = static_cast(aEvent)->theText; break; case NS_KEY_PRESS: // Sometimes the text changes after a key press do not generate notifications (see Bug 723810) // Call the corresponding methods explicitly to send those changes back to Java OnIMETextChange(0, 0, 0); OnIMESelectionChange(); break; } return status; } return nsEventStatus_eIgnore; } NS_IMETHODIMP nsWindow::MakeFullScreen(bool aFullScreen) { AndroidBridge::Bridge()->SetFullScreen(aFullScreen); return NS_OK; } NS_IMETHODIMP nsWindow::SetWindowClass(const nsAString& xulWinType) { return NS_OK; } mozilla::layers::LayerManager* nsWindow::GetLayerManager(PLayersChild*, LayersBackend, LayerManagerPersistence, bool* aAllowRetaining) { if (aAllowRetaining) { *aAllowRetaining = true; } if (mLayerManager) { return mLayerManager; } nsWindow *topWindow = TopWindow(); if (!topWindow) { printf_stderr(" -- no topwindow\n"); mLayerManager = CreateBasicLayerManager(); return mLayerManager; } #ifdef MOZ_JAVA_COMPOSITOR bool useCompositor = Preferences::GetBool("layers.offmainthreadcomposition.enabled", false); if (useCompositor) { CreateCompositor(); if (mLayerManager) { SetCompositor(mCompositorParent, mCompositorChild, mCompositorThread); return mLayerManager; } // If we get here, then off main thread compositing failed to initialize. sFailedToCreateGLContext = true; } #endif mUseAcceleratedRendering = GetShouldAccelerate(); if (!mUseAcceleratedRendering || sFailedToCreateGLContext) { printf_stderr(" -- creating basic, not accelerated\n"); mLayerManager = CreateBasicLayerManager(); return mLayerManager; } if (!mLayerManager) { if (!sGLContext) { // the window we give doesn't matter here sGLContext = mozilla::gl::GLContextProvider::CreateForWindow(this); } if (sGLContext) { nsRefPtr layerManager = new mozilla::layers::LayerManagerOGL(this); if (layerManager && layerManager->Initialize(sGLContext)) mLayerManager = layerManager; sValidSurface = true; } if (!sGLContext || !mLayerManager) { sGLContext = nsnull; sFailedToCreateGLContext = true; mLayerManager = CreateBasicLayerManager(); } } return mLayerManager; } void nsWindow::OnGlobalAndroidEvent(AndroidGeckoEvent *ae) { if (!AndroidBridge::Bridge()) return; nsWindow *win = TopWindow(); if (!win) return; switch (ae->Type()) { case AndroidGeckoEvent::FORCED_RESIZE: win->mBounds.width = 0; win->mBounds.height = 0; // also resize the children for (PRUint32 i = 0; i < win->mChildren.Length(); i++) { win->mChildren[i]->mBounds.width = 0; win->mChildren[i]->mBounds.height = 0; } case AndroidGeckoEvent::SIZE_CHANGED: { nsTArray points = ae->Points(); NS_ASSERTION(points.Length() == 2, "Size changed does not have enough coordinates"); int nw = points[0].x; int nh = points[0].y; if (ae->Type() == AndroidGeckoEvent::FORCED_RESIZE || nw != gAndroidBounds.width || nh != gAndroidBounds.height) { gAndroidBounds.width = nw; gAndroidBounds.height = nh; // tell all the windows about the new size for (size_t i = 0; i < gTopLevelWindows.Length(); ++i) { if (gTopLevelWindows[i]->mIsVisible) gTopLevelWindows[i]->Resize(gAndroidBounds.width, gAndroidBounds.height, false); } } int newScreenWidth = points[1].x; int newScreenHeight = points[1].y; if (newScreenWidth == gAndroidScreenBounds.width && newScreenHeight == gAndroidScreenBounds.height) break; gAndroidScreenBounds.width = newScreenWidth; gAndroidScreenBounds.height = newScreenHeight; if (XRE_GetProcessType() != GeckoProcessType_Default) break; // Tell the content process the new screen size. nsTArray cplist; ContentParent::GetAll(cplist); for (PRUint32 i = 0; i < cplist.Length(); ++i) unused << cplist[i]->SendScreenSizeChanged(gAndroidScreenBounds); if (gContentCreationNotifier) break; // If the content process is not created yet, wait until it's // created and then tell it the screen size. nsCOMPtr obs = do_GetService("@mozilla.org/observer-service;1"); if (!obs) break; nsCOMPtr notifier = new ContentCreationNotifier; if (NS_SUCCEEDED(obs->AddObserver(notifier, "ipc:content-created", false))) { if (NS_SUCCEEDED(obs->AddObserver(notifier, "xpcom-shutdown", false))) gContentCreationNotifier = notifier; else obs->RemoveObserver(notifier, "ipc:content-created"); } break; } case AndroidGeckoEvent::MOTION_EVENT: { win->UserActivity(); if (!gTopLevelWindows.IsEmpty()) { nsIntPoint pt(0,0); nsTArray points = ae->Points(); if (points.Length() > 0) { pt = points[0]; } pt.x = clamped(pt.x, 0, NS_MAX(gAndroidBounds.width - 1, 0)); pt.y = clamped(pt.y, 0, NS_MAX(gAndroidBounds.height - 1, 0)); nsWindow *target = win->FindWindowForPoint(pt); #if 0 ALOG("MOTION_EVENT %f,%f -> %p (visible: %d children: %d)", pt.x, pt.y, (void*)target, target ? target->mIsVisible : 0, target ? target->mChildren.Length() : 0); DumpWindows(); #endif if (target) { bool preventDefaultActions = target->OnMultitouchEvent(ae); if (!preventDefaultActions && ae->Count() == 2) { target->OnGestureEvent(ae); } #ifndef MOZ_ONLY_TOUCH_EVENTS if (!preventDefaultActions && ae->Count() < 2) target->OnMotionEvent(ae); #endif } } break; } case AndroidGeckoEvent::KEY_EVENT: win->UserActivity(); if (win->mFocus) win->mFocus->OnKeyEvent(ae); break; case AndroidGeckoEvent::VIEWPORT: case AndroidGeckoEvent::BROADCAST: { if (ae->Characters().Length() == 0) break; nsCOMPtr obsServ = mozilla::services::GetObserverService(); const NS_ConvertUTF16toUTF8 topic(ae->Characters()); const nsPromiseFlatString& data = PromiseFlatString(ae->CharactersExtra()); obsServ->NotifyObservers(nsnull, topic.get(), data.get()); if (ae->Type() == AndroidGeckoEvent::VIEWPORT) { // We know that we've caused a complete invalidation // and don't want to wait for the refresh driver // to kick off a draw so we start one now. // There are other smaller invalidations for touch hilighting that // happen earlier so we don't necessarily want to have the // refresh driver naively start a paint when we get the first // invalidation. nsIntRect rect(0, 0, win->mBounds.width, win->mBounds.height); nsAutoPtr event(new AndroidGeckoEvent(AndroidGeckoEvent::DRAW, rect)); win->OnDraw(event); } break; } case AndroidGeckoEvent::DRAW: layers::renderTraceEventStart("Global draw start", "414141"); win->OnDraw(ae); layers::renderTraceEventEnd("414141"); break; case AndroidGeckoEvent::IME_EVENT: win->UserActivity(); if (win->mFocus) { win->mFocus->OnIMEEvent(ae); } else { NS_WARNING("Sending unexpected IME event to top window"); win->OnIMEEvent(ae); } break; case AndroidGeckoEvent::SURFACE_CREATED: sSurfaceExists = true; if (AndroidBridge::Bridge()->HasNativeWindowAccess()) { AndroidGeckoSurfaceView& sview(AndroidBridge::Bridge()->SurfaceView()); jobject surface = sview.GetSurface(); if (surface) { sNativeWindow = AndroidBridge::Bridge()->AcquireNativeWindow(surface); if (sNativeWindow) { AndroidBridge::Bridge()->SetNativeWindowFormat(sNativeWindow, 0, 0, AndroidBridge::WINDOW_FORMAT_RGB_565); } } } break; case AndroidGeckoEvent::SURFACE_DESTROYED: if (sGLContext && sValidSurface) { sGLContext->ReleaseSurface(); } if (sNativeWindow) { AndroidBridge::Bridge()->ReleaseNativeWindow(sNativeWindow); sNativeWindow = nsnull; } sSurfaceExists = false; sValidSurface = false; break; #ifdef MOZ_JAVA_COMPOSITOR case AndroidGeckoEvent::COMPOSITOR_PAUSE: // The compositor gets paused when the app is about to go into the // background. While the compositor is paused, we need to ensure that // no layer tree updates (from draw events) occur, since the compositor // cannot make a GL context current in order to process updates. if (sCompositorChild) { sCompositorChild->SendPause(); } sCompositorPaused = true; break; case AndroidGeckoEvent::COMPOSITOR_RESUME: // When we receive this, the compositor has already been told to // resume. (It turns out that waiting till we reach here to tell // the compositor to resume takes too long, resulting in a black // flash.) This means it's now safe for layer updates to occur. // Since we might have prevented one or more draw events from // occurring while the compositor was paused, we need to schedule // a draw event now. sCompositorPaused = false; win->RedrawAll(); break; #endif case AndroidGeckoEvent::GECKO_EVENT_SYNC: AndroidBridge::Bridge()->AcknowledgeEventSync(); break; default: break; } } void nsWindow::OnAndroidEvent(AndroidGeckoEvent *ae) { if (!AndroidBridge::Bridge()) return; switch (ae->Type()) { case AndroidGeckoEvent::DRAW: OnDraw(ae); break; default: ALOG("Window got targetted android event type %d, but didn't handle!", ae->Type()); break; } } bool nsWindow::DrawTo(gfxASurface *targetSurface) { nsIntRect boundsRect(0, 0, mBounds.width, mBounds.height); return DrawTo(targetSurface, boundsRect); } bool nsWindow::DrawTo(gfxASurface *targetSurface, const nsIntRect &invalidRect) { mozilla::layers::RenderTraceScope trace("DrawTo", "717171"); if (!mIsVisible) return false; nsRefPtr kungFuDeathGrip(this); nsEventStatus status; nsIntRect boundsRect(0, 0, mBounds.width, mBounds.height); // Figure out if any of our children cover this widget completely PRInt32 coveringChildIndex = -1; for (PRUint32 i = 0; i < mChildren.Length(); ++i) { if (mChildren[i]->mBounds.IsEmpty()) continue; if (mChildren[i]->mBounds.Contains(boundsRect)) { coveringChildIndex = PRInt32(i); } } // If we have no covering child, then we need to render this. if (coveringChildIndex == -1) { nsPaintEvent event(true, NS_PAINT, this); nsIntRect tileRect(0, 0, gAndroidBounds.width, gAndroidBounds.height); event.region = boundsRect.Intersect(invalidRect).Intersect(tileRect); switch (GetLayerManager(nsnull)->GetBackendType()) { case LayerManager::LAYERS_BASIC: { nsRefPtr ctx = new gfxContext(targetSurface); { mozilla::layers::RenderTraceScope trace2("Basic DrawTo", "727272"); AutoLayerManagerSetup setupLayerManager(this, ctx, BasicLayerManager::BUFFER_NONE); status = DispatchEvent(&event); } // XXX uhh.. we can't just ignore this because we no longer have // what we needed before, but let's keep drawing the children anyway? #if 0 if (status == nsEventStatus_eIgnore) return false; #endif // XXX if we got an ignore for the parent, do we still want to draw the children? // We don't really have a good way not to... break; } case LayerManager::LAYERS_OPENGL: { static_cast(GetLayerManager(nsnull))-> SetClippingRegion(nsIntRegion(boundsRect)); status = DispatchEvent(&event); break; } default: NS_ERROR("Invalid layer manager"); } // We had no covering child, so make sure we draw all the children, // starting from index 0. coveringChildIndex = 0; } gfxPoint offset; if (targetSurface) offset = targetSurface->GetDeviceOffset(); for (PRUint32 i = coveringChildIndex; i < mChildren.Length(); ++i) { if (mChildren[i]->mBounds.IsEmpty() || !mChildren[i]->mBounds.Intersects(boundsRect)) { continue; } if (targetSurface) targetSurface->SetDeviceOffset(offset + gfxPoint(mChildren[i]->mBounds.x, mChildren[i]->mBounds.y)); bool ok = mChildren[i]->DrawTo(targetSurface, invalidRect); if (!ok) { ALOG("nsWindow[%p]::DrawTo child %d[%p] returned FALSE!", (void*) this, i, (void*)mChildren[i]); } } if (targetSurface) targetSurface->SetDeviceOffset(offset); return true; } void nsWindow::OnDraw(AndroidGeckoEvent *ae) { if (!IsTopLevel()) { ALOG("##### redraw for window %p, which is not a toplevel window -- sending to toplevel!", (void*) this); DumpWindows(); return; } if (!mIsVisible) { ALOG("##### redraw for window %p, which is not visible -- ignoring!", (void*) this); DumpWindows(); return; } nsRefPtr kungFuDeathGrip(this); AndroidBridge::AutoLocalJNIFrame jniFrame; #ifdef MOZ_JAVA_COMPOSITOR // We're paused, or we haven't been given a window-size yet, so do nothing if (sCompositorPaused || gAndroidBounds.width <= 0 || gAndroidBounds.height <= 0) { return; } /* * Check to see whether the presentation shell corresponding to the document on the screen * is suppressing painting. If it is, we bail out, as continuing would result in a mismatch * between the content on the screen and the current viewport metrics. */ nsCOMPtr metadataProvider = AndroidBridge::Bridge()->GetDrawMetadataProvider(); layers::renderTraceEventStart("Check supress", "424242"); bool paintingSuppressed = false; if (metadataProvider) { metadataProvider->PaintingSuppressed(&paintingSuppressed); } if (paintingSuppressed) { return; } layers::renderTraceEventEnd("Check supress", "424242"); layers::renderTraceEventStart("Get surface", "424545"); static unsigned char bits2[32 * 32 * 2]; nsRefPtr targetSurface = new gfxImageSurface(bits2, gfxIntSize(32, 32), 32 * 2, gfxASurface::ImageFormatRGB16_565); layers::renderTraceEventEnd("Get surface", "424545"); layers::renderTraceEventStart("Widget draw to", "434646"); nsIntRect dirtyRect = ae->Rect().Intersect(nsIntRect(0, 0, gAndroidBounds.width, gAndroidBounds.height)); if (targetSurface->CairoStatus()) { ALOG("### Failed to create a valid surface from the bitmap"); } else { DrawTo(targetSurface, dirtyRect); } layers::renderTraceEventEnd("Widget draw to", "434646"); return; #endif if (!sSurfaceExists) { return; } AndroidGeckoSurfaceView& sview(AndroidBridge::Bridge()->SurfaceView()); NS_ASSERTION(!sview.isNull(), "SurfaceView is null!"); AndroidBridge::Bridge()->HideProgressDialogOnce(); if (GetLayerManager(nsnull)->GetBackendType() == LayerManager::LAYERS_BASIC) { if (sNativeWindow) { unsigned char *bits; int width, height, format, stride; if (!AndroidBridge::Bridge()->LockWindow(sNativeWindow, &bits, &width, &height, &format, &stride)) { ALOG("failed to lock buffer - skipping draw"); return; } if (!bits || format != AndroidBridge::WINDOW_FORMAT_RGB_565 || width != mBounds.width || height != mBounds.height) { ALOG("surface is not expected dimensions or format - skipping draw"); AndroidBridge::Bridge()->UnlockWindow(sNativeWindow); return; } nsRefPtr targetSurface = new gfxImageSurface(bits, gfxIntSize(mBounds.width, mBounds.height), stride * 2, gfxASurface::ImageFormatRGB16_565); if (targetSurface->CairoStatus()) { ALOG("### Failed to create a valid surface from the bitmap"); } else { DrawTo(targetSurface); } AndroidBridge::Bridge()->UnlockWindow(sNativeWindow); } else if (AndroidBridge::Bridge()->HasNativeBitmapAccess()) { jobject bitmap = sview.GetSoftwareDrawBitmap(); if (!bitmap) { ALOG("no bitmap to draw into - skipping draw"); return; } if (!AndroidBridge::Bridge()->ValidateBitmap(bitmap, mBounds.width, mBounds.height)) return; void *buf = AndroidBridge::Bridge()->LockBitmap(bitmap); if (buf == nsnull) { ALOG("### Software drawing, but failed to lock bitmap."); return; } nsRefPtr targetSurface = new gfxImageSurface((unsigned char *)buf, gfxIntSize(mBounds.width, mBounds.height), mBounds.width * 2, gfxASurface::ImageFormatRGB16_565); if (targetSurface->CairoStatus()) { ALOG("### Failed to create a valid surface from the bitmap"); } else { DrawTo(targetSurface); } AndroidBridge::Bridge()->UnlockBitmap(bitmap); sview.Draw2D(bitmap, mBounds.width, mBounds.height); } else { jobject bytebuf = sview.GetSoftwareDrawBuffer(); if (!bytebuf) { ALOG("no buffer to draw into - skipping draw"); return; } JNIEnv *env = AndroidBridge::GetJNIEnv(); if (!env) return; void *buf = env->GetDirectBufferAddress(bytebuf); int cap = env->GetDirectBufferCapacity(bytebuf); if (!buf || cap != (mBounds.width * mBounds.height * 2)) { ALOG("### Software drawing, but unexpected buffer size %d expected %d (or no buffer %p)!", cap, mBounds.width * mBounds.height * 2, buf); return; } nsRefPtr targetSurface = new gfxImageSurface((unsigned char *)buf, gfxIntSize(mBounds.width, mBounds.height), mBounds.width * 2, gfxASurface::ImageFormatRGB16_565); if (targetSurface->CairoStatus()) { ALOG("### Failed to create a valid surface"); } else { DrawTo(targetSurface); } sview.Draw2D(bytebuf, mBounds.width * 2); } } else { int drawType = sview.BeginDrawing(); if (drawType == AndroidGeckoSurfaceView::DRAW_DISABLED) { return; } if (drawType == AndroidGeckoSurfaceView::DRAW_ERROR) { ALOG("##### BeginDrawing failed!"); return; } if (!sValidSurface) { sGLContext->RenewSurface(); sValidSurface = true; } NS_ASSERTION(sGLContext, "Drawing with GLES without a GL context?"); DrawTo(nsnull); sview.EndDrawing(); } } void nsWindow::OnSizeChanged(const gfxIntSize& aSize) { int w = aSize.width; int h = aSize.height; ALOG("nsWindow: %p OnSizeChanged [%d %d]", (void*)this, w, h); nsRefPtr kungFuDeathGrip(this); nsSizeEvent event(true, NS_SIZE, this); InitEvent(event); nsIntRect wsz(0, 0, w, h); event.windowSize = &wsz; event.mWinWidth = w; event.mWinHeight = h; mBounds.width = w; mBounds.height = h; DispatchEvent(&event); } void nsWindow::InitEvent(nsGUIEvent& event, nsIntPoint* aPoint) { if (aPoint) { event.refPoint.x = aPoint->x; event.refPoint.y = aPoint->y; } else { event.refPoint.x = 0; event.refPoint.y = 0; } event.time = PR_Now() / 1000; } gfxIntSize nsWindow::GetAndroidScreenBounds() { if (XRE_GetProcessType() == GeckoProcessType_Content) { return ContentChild::GetSingleton()->GetScreenSize(); } return gAndroidScreenBounds; } void * nsWindow::GetNativeData(PRUint32 aDataType) { switch (aDataType) { // used by GLContextProviderEGL, NULL is EGL_DEFAULT_DISPLAY case NS_NATIVE_DISPLAY: return NULL; case NS_NATIVE_WIDGET: return (void *) this; } return nsnull; } void nsWindow::OnMotionEvent(AndroidGeckoEvent *ae) { PRUint32 msg; switch (ae->Action() & AndroidMotionEvent::ACTION_MASK) { case AndroidMotionEvent::ACTION_DOWN: msg = NS_MOUSE_BUTTON_DOWN; break; case AndroidMotionEvent::ACTION_MOVE: msg = NS_MOUSE_MOVE; break; case AndroidMotionEvent::ACTION_UP: case AndroidMotionEvent::ACTION_CANCEL: msg = NS_MOUSE_BUTTON_UP; break; default: return; } send_again: nsMouseEvent event(true, msg, this, nsMouseEvent::eReal, nsMouseEvent::eNormal); // XXX can we synthesize different buttons? event.button = nsMouseEvent::eLeftButton; if (msg != NS_MOUSE_MOVE) event.clickCount = 1; // XXX add the double-click handling logic here if (ae->Points().Length() > 0) DispatchMotionEvent(event, ae, ae->Points()[0]); if (Destroyed()) return; if (msg == NS_MOUSE_BUTTON_DOWN) { msg = NS_MOUSE_MOVE; goto send_again; } } static double getDistance(const nsIntPoint &p1, const nsIntPoint &p2) { double deltaX = p2.x - p1.x; double deltaY = p2.y - p1.y; return sqrt(deltaX*deltaX + deltaY*deltaY); } bool nsWindow::OnMultitouchEvent(AndroidGeckoEvent *ae) { // This is set to true once we have called SetPreventPanning() exactly // once for a given sequence of touch events. It is reset on the start // of the next sequence. static bool sDefaultPreventedNotified = false; static bool sLastWasDownEvent = false; bool preventDefaultActions = false; bool isDownEvent = false; switch (ae->Action() & AndroidMotionEvent::ACTION_MASK) { case AndroidMotionEvent::ACTION_DOWN: case AndroidMotionEvent::ACTION_POINTER_DOWN: { nsTouchEvent event(true, NS_TOUCH_START, this); preventDefaultActions = DispatchMultitouchEvent(event, ae); isDownEvent = true; break; } case AndroidMotionEvent::ACTION_MOVE: { nsTouchEvent event(true, NS_TOUCH_MOVE, this); preventDefaultActions = DispatchMultitouchEvent(event, ae); break; } case AndroidMotionEvent::ACTION_UP: case AndroidMotionEvent::ACTION_POINTER_UP: { nsTouchEvent event(true, NS_TOUCH_END, this); preventDefaultActions = DispatchMultitouchEvent(event, ae); break; } case AndroidMotionEvent::ACTION_OUTSIDE: case AndroidMotionEvent::ACTION_CANCEL: { nsTouchEvent event(true, NS_TOUCH_CANCEL, this); preventDefaultActions = DispatchMultitouchEvent(event, ae); break; } } // if the last event we got was a down event, then by now we know for sure whether // this block has been default-prevented or not. if we haven't already sent the // notification for this block, do so now. if (sLastWasDownEvent && !sDefaultPreventedNotified) { // if this event is a down event, that means it's the start of a new block, and the // previous block should not be default-prevented bool defaultPrevented = isDownEvent ? false : preventDefaultActions; AndroidBridge::Bridge()->NotifyDefaultPrevented(defaultPrevented); sDefaultPreventedNotified = true; } // now, if this event is a down event, then we might already know that it has been // default-prevented. if so, we send the notification right away; otherwise we wait // for the next event. if (isDownEvent) { if (preventDefaultActions) { AndroidBridge::Bridge()->NotifyDefaultPrevented(true); sDefaultPreventedNotified = true; } else { sDefaultPreventedNotified = false; } } sLastWasDownEvent = isDownEvent; return preventDefaultActions; } bool nsWindow::DispatchMultitouchEvent(nsTouchEvent &event, AndroidGeckoEvent *ae) { nsIntPoint offset = WidgetToScreenOffset(); event.isShift = false; event.isControl = false; event.isMeta = false; event.isAlt = false; event.time = ae->Time(); int action = ae->Action() & AndroidMotionEvent::ACTION_MASK; if (action == AndroidMotionEvent::ACTION_UP || action == AndroidMotionEvent::ACTION_POINTER_UP) { event.touches.SetCapacity(1); int pointerIndex = ae->PointerIndex(); nsCOMPtr t(new nsDOMTouch(ae->PointIndicies()[pointerIndex], ae->Points()[pointerIndex] - offset, ae->PointRadii()[pointerIndex], ae->Orientations()[pointerIndex], ae->Pressures()[pointerIndex])); event.touches.AppendElement(t); } else { int count = ae->Count(); event.touches.SetCapacity(count); for (int i = 0; i < count; i++) { nsCOMPtr t(new nsDOMTouch(ae->PointIndicies()[i], ae->Points()[i] - offset, ae->PointRadii()[i], ae->Orientations()[i], ae->Pressures()[i])); event.touches.AppendElement(t); } } nsEventStatus status; DispatchEvent(&event, status); return (status == nsEventStatus_eConsumeNoDefault); } void nsWindow::OnGestureEvent(AndroidGeckoEvent *ae) { PRUint32 msg = 0; nsIntPoint midPoint; midPoint.x = ((ae->Points()[0].x + ae->Points()[1].x) / 2); midPoint.y = ((ae->Points()[0].y + ae->Points()[1].y) / 2); nsIntPoint refPoint = midPoint - WidgetToScreenOffset(); double pinchDist = getDistance(ae->Points()[0], ae->Points()[1]); double pinchDelta = 0; switch (ae->Action() & AndroidMotionEvent::ACTION_MASK) { case AndroidMotionEvent::ACTION_POINTER_DOWN: msg = NS_SIMPLE_GESTURE_MAGNIFY_START; mStartPoint = new nsIntPoint(midPoint); mStartDist = mLastDist = pinchDist; mGestureFinished = false; break; case AndroidMotionEvent::ACTION_MOVE: msg = NS_SIMPLE_GESTURE_MAGNIFY_UPDATE; pinchDelta = pinchDist - mLastDist; mLastDist = pinchDist; break; case AndroidMotionEvent::ACTION_POINTER_UP: msg = NS_SIMPLE_GESTURE_MAGNIFY; pinchDelta = pinchDist - mStartDist; mStartPoint = nsnull; break; default: return; } if (!mGestureFinished) { nsRefPtr kungFuDeathGrip(this); DispatchGestureEvent(msg, 0, pinchDelta, refPoint, ae->Time()); if (Destroyed()) return; // If the cumulative pinch delta goes past the threshold, treat this // as a pinch only, and not a swipe. if (fabs(pinchDist - mStartDist) > mSwipeMaxPinchDelta) mStartPoint = nsnull; // If we have traveled more than SWIPE_MIN_DISTANCE from the start // point, stop the pinch gesture and fire a swipe event. if (mStartPoint) { double swipeDistance = getDistance(midPoint, *mStartPoint); if (swipeDistance > mSwipeMinDistance) { PRUint32 direction = 0; nsIntPoint motion = midPoint - *mStartPoint; if (motion.x < -swipeDistance/2) direction |= nsIDOMSimpleGestureEvent::DIRECTION_LEFT; if (motion.x > swipeDistance/2) direction |= nsIDOMSimpleGestureEvent::DIRECTION_RIGHT; if (motion.y < -swipeDistance/2) direction |= nsIDOMSimpleGestureEvent::DIRECTION_UP; if (motion.y > swipeDistance/2) direction |= nsIDOMSimpleGestureEvent::DIRECTION_DOWN; // Finish the pinch gesture, then fire the swipe event: msg = NS_SIMPLE_GESTURE_MAGNIFY; DispatchGestureEvent(msg, 0, pinchDist - mStartDist, refPoint, ae->Time()); if (Destroyed()) return; msg = NS_SIMPLE_GESTURE_SWIPE; DispatchGestureEvent(msg, direction, 0, refPoint, ae->Time()); // Don't generate any more gesture events for this touch. mGestureFinished = true; } } } } void nsWindow::DispatchGestureEvent(PRUint32 msg, PRUint32 direction, double delta, const nsIntPoint &refPoint, PRUint64 time) { nsSimpleGestureEvent event(true, msg, this, direction, delta); event.isShift = false; event.isControl = false; event.isMeta = false; event.isAlt = false; event.time = time; event.refPoint = refPoint; DispatchEvent(&event); } void nsWindow::DispatchMotionEvent(nsInputEvent &event, AndroidGeckoEvent *ae, const nsIntPoint &refPoint) { nsIntPoint offset = WidgetToScreenOffset(); event.isShift = false; event.isControl = false; event.isMeta = false; event.isAlt = false; event.time = ae->Time(); // XXX possibly bound the range of event.refPoint here. // some code may get confused. event.refPoint = refPoint - offset; DispatchEvent(&event); } void nsWindow::InitKeyEvent(nsKeyEvent& event, AndroidGeckoEvent& key) { switch (key.KeyCode()) { case AndroidKeyEvent::KEYCODE_UNKNOWN: case AndroidKeyEvent::KEYCODE_HOME: break; case AndroidKeyEvent::KEYCODE_BACK: event.keyCode = NS_VK_ESCAPE; break; case AndroidKeyEvent::KEYCODE_CALL: case AndroidKeyEvent::KEYCODE_ENDCALL: break; case AndroidKeyEvent::KEYCODE_0: case AndroidKeyEvent::KEYCODE_1: case AndroidKeyEvent::KEYCODE_2: case AndroidKeyEvent::KEYCODE_3: case AndroidKeyEvent::KEYCODE_4: case AndroidKeyEvent::KEYCODE_5: case AndroidKeyEvent::KEYCODE_6: case AndroidKeyEvent::KEYCODE_7: case AndroidKeyEvent::KEYCODE_8: case AndroidKeyEvent::KEYCODE_9: event.keyCode = key.KeyCode() - AndroidKeyEvent::KEYCODE_0 + NS_VK_0; break; case AndroidKeyEvent::KEYCODE_STAR: event.keyCode = NS_VK_MULTIPLY; break; case AndroidKeyEvent::KEYCODE_POUND: break; case AndroidKeyEvent::KEYCODE_DPAD_UP: event.keyCode = NS_VK_UP; break; case AndroidKeyEvent::KEYCODE_DPAD_DOWN: event.keyCode = NS_VK_DOWN; break; case AndroidKeyEvent::KEYCODE_SOFT_LEFT: case AndroidKeyEvent::KEYCODE_DPAD_LEFT: event.keyCode = NS_VK_LEFT; break; case AndroidKeyEvent::KEYCODE_SOFT_RIGHT: case AndroidKeyEvent::KEYCODE_DPAD_RIGHT: event.keyCode = NS_VK_RIGHT; break; case AndroidKeyEvent::KEYCODE_VOLUME_UP: case AndroidKeyEvent::KEYCODE_VOLUME_DOWN: case AndroidKeyEvent::KEYCODE_POWER: case AndroidKeyEvent::KEYCODE_CAMERA: case AndroidKeyEvent::KEYCODE_CLEAR: break; case AndroidKeyEvent::KEYCODE_A: case AndroidKeyEvent::KEYCODE_B: case AndroidKeyEvent::KEYCODE_C: case AndroidKeyEvent::KEYCODE_D: case AndroidKeyEvent::KEYCODE_E: case AndroidKeyEvent::KEYCODE_F: case AndroidKeyEvent::KEYCODE_G: case AndroidKeyEvent::KEYCODE_H: case AndroidKeyEvent::KEYCODE_I: case AndroidKeyEvent::KEYCODE_J: case AndroidKeyEvent::KEYCODE_K: case AndroidKeyEvent::KEYCODE_L: case AndroidKeyEvent::KEYCODE_M: case AndroidKeyEvent::KEYCODE_N: case AndroidKeyEvent::KEYCODE_O: case AndroidKeyEvent::KEYCODE_P: case AndroidKeyEvent::KEYCODE_Q: case AndroidKeyEvent::KEYCODE_R: case AndroidKeyEvent::KEYCODE_S: case AndroidKeyEvent::KEYCODE_T: case AndroidKeyEvent::KEYCODE_U: case AndroidKeyEvent::KEYCODE_V: case AndroidKeyEvent::KEYCODE_W: case AndroidKeyEvent::KEYCODE_X: case AndroidKeyEvent::KEYCODE_Y: case AndroidKeyEvent::KEYCODE_Z: event.keyCode = key.KeyCode() - AndroidKeyEvent::KEYCODE_A + NS_VK_A; break; case AndroidKeyEvent::KEYCODE_COMMA: event.keyCode = NS_VK_COMMA; break; case AndroidKeyEvent::KEYCODE_PERIOD: event.keyCode = NS_VK_PERIOD; break; case AndroidKeyEvent::KEYCODE_ALT_LEFT: case AndroidKeyEvent::KEYCODE_ALT_RIGHT: case AndroidKeyEvent::KEYCODE_SHIFT_LEFT: case AndroidKeyEvent::KEYCODE_SHIFT_RIGHT: break; case AndroidKeyEvent::KEYCODE_TAB: event.keyCode = NS_VK_TAB; break; case AndroidKeyEvent::KEYCODE_SPACE: event.keyCode = NS_VK_SPACE; break; case AndroidKeyEvent::KEYCODE_SYM: case AndroidKeyEvent::KEYCODE_EXPLORER: case AndroidKeyEvent::KEYCODE_ENVELOPE: break; case AndroidKeyEvent::KEYCODE_DPAD_CENTER: event.keyCode = NS_VK_ENTER; break; case AndroidKeyEvent::KEYCODE_ENTER: event.keyCode = NS_VK_RETURN; break; case AndroidKeyEvent::KEYCODE_DEL: event.keyCode = NS_VK_BACK; break; case AndroidKeyEvent::KEYCODE_GRAVE: break; case AndroidKeyEvent::KEYCODE_MINUS: event.keyCode = NS_VK_SUBTRACT; break; case AndroidKeyEvent::KEYCODE_EQUALS: event.keyCode = NS_VK_EQUALS; break; case AndroidKeyEvent::KEYCODE_LEFT_BRACKET: event.keyCode = NS_VK_OPEN_BRACKET; break; case AndroidKeyEvent::KEYCODE_RIGHT_BRACKET: event.keyCode = NS_VK_CLOSE_BRACKET; break; case AndroidKeyEvent::KEYCODE_BACKSLASH: event.keyCode = NS_VK_BACK_SLASH; break; case AndroidKeyEvent::KEYCODE_SEMICOLON: event.keyCode = NS_VK_SEMICOLON; break; case AndroidKeyEvent::KEYCODE_APOSTROPHE: event.keyCode = NS_VK_QUOTE; break; case AndroidKeyEvent::KEYCODE_SLASH: event.keyCode = NS_VK_SLASH; break; case AndroidKeyEvent::KEYCODE_AT: case AndroidKeyEvent::KEYCODE_NUM: case AndroidKeyEvent::KEYCODE_HEADSETHOOK: case AndroidKeyEvent::KEYCODE_FOCUS: break; case AndroidKeyEvent::KEYCODE_PLUS: event.keyCode = NS_VK_ADD; break; case AndroidKeyEvent::KEYCODE_MENU: case AndroidKeyEvent::KEYCODE_NOTIFICATION: case AndroidKeyEvent::KEYCODE_SEARCH: case AndroidKeyEvent::KEYCODE_MEDIA_PLAY_PAUSE: case AndroidKeyEvent::KEYCODE_MEDIA_STOP: case AndroidKeyEvent::KEYCODE_MEDIA_NEXT: case AndroidKeyEvent::KEYCODE_MEDIA_PREVIOUS: case AndroidKeyEvent::KEYCODE_MEDIA_REWIND: case AndroidKeyEvent::KEYCODE_MEDIA_FAST_FORWARD: case AndroidKeyEvent::KEYCODE_MUTE: break; default: ALOG("Unknown key code!"); break; } // Android gives us \n, so filter out some control characters. if (event.message == NS_KEY_PRESS && key.UnicodeChar() >= ' ') { event.charCode = key.UnicodeChar(); if (key.UnicodeChar()) event.keyCode = 0; } event.isShift = !!(key.MetaState() & AndroidKeyEvent::META_SHIFT_ON); event.isControl = gMenu; event.isAlt = !!(key.MetaState() & AndroidKeyEvent::META_ALT_ON); event.isMeta = false; event.time = key.Time(); if (gMenu) gMenuConsumed = true; } void nsWindow::HandleSpecialKey(AndroidGeckoEvent *ae) { nsRefPtr kungFuDeathGrip(this); nsCOMPtr command; bool isDown = ae->Action() == AndroidKeyEvent::ACTION_DOWN; bool isLongPress = !!(ae->Flags() & AndroidKeyEvent::FLAG_LONG_PRESS); bool doCommand = false; PRUint32 keyCode = ae->KeyCode(); if (isDown) { switch (keyCode) { case AndroidKeyEvent::KEYCODE_BACK: if (isLongPress) { command = nsGkAtoms::Clear; doCommand = true; } break; case AndroidKeyEvent::KEYCODE_VOLUME_UP: command = nsGkAtoms::VolumeUp; doCommand = true; break; case AndroidKeyEvent::KEYCODE_VOLUME_DOWN: command = nsGkAtoms::VolumeDown; doCommand = true; break; case AndroidKeyEvent::KEYCODE_MENU: gMenu = true; gMenuConsumed = isLongPress; break; } } else { switch (keyCode) { case AndroidKeyEvent::KEYCODE_BACK: { nsKeyEvent pressEvent(true, NS_KEY_PRESS, this); InitKeyEvent(pressEvent, *ae); DispatchEvent(&pressEvent); return; } case AndroidKeyEvent::KEYCODE_MENU: gMenu = false; if (!gMenuConsumed) { command = nsGkAtoms::Menu; doCommand = true; } break; case AndroidKeyEvent::KEYCODE_SEARCH: command = nsGkAtoms::Search; doCommand = true; break; default: ALOG("Unknown special key code!"); return; } } if (doCommand) { nsCommandEvent event(true, nsGkAtoms::onAppCommand, command, this); InitEvent(event); DispatchEvent(&event); } } void nsWindow::OnKeyEvent(AndroidGeckoEvent *ae) { nsRefPtr kungFuDeathGrip(this); PRUint32 msg; switch (ae->Action()) { case AndroidKeyEvent::ACTION_DOWN: msg = NS_KEY_DOWN; break; case AndroidKeyEvent::ACTION_UP: msg = NS_KEY_UP; break; case AndroidKeyEvent::ACTION_MULTIPLE: { nsTextEvent event(true, NS_TEXT_TEXT, this); event.theText.Assign(ae->Characters()); DispatchEvent(&event); } return; default: ALOG("Unknown key action event!"); return; } bool firePress = ae->Action() == AndroidKeyEvent::ACTION_DOWN; switch (ae->KeyCode()) { case AndroidKeyEvent::KEYCODE_SHIFT_LEFT: case AndroidKeyEvent::KEYCODE_SHIFT_RIGHT: case AndroidKeyEvent::KEYCODE_ALT_LEFT: case AndroidKeyEvent::KEYCODE_ALT_RIGHT: firePress = false; break; case AndroidKeyEvent::KEYCODE_BACK: case AndroidKeyEvent::KEYCODE_MENU: case AndroidKeyEvent::KEYCODE_SEARCH: case AndroidKeyEvent::KEYCODE_VOLUME_UP: case AndroidKeyEvent::KEYCODE_VOLUME_DOWN: HandleSpecialKey(ae); return; } nsEventStatus status; nsKeyEvent event(true, msg, this); InitKeyEvent(event, *ae); DispatchEvent(&event, status); if (Destroyed()) return; if (!firePress) return; nsKeyEvent pressEvent(true, NS_KEY_PRESS, this); InitKeyEvent(pressEvent, *ae); if (status == nsEventStatus_eConsumeNoDefault) { pressEvent.flags |= NS_EVENT_FLAG_NO_DEFAULT; } #ifdef DEBUG_ANDROID_WIDGET __android_log_print(ANDROID_LOG_INFO, "Gecko", "Dispatching key pressEvent with keyCode %d charCode %d shift %d alt %d sym/ctrl %d metamask %d", pressEvent.keyCode, pressEvent.charCode, pressEvent.isShift, pressEvent.isAlt, pressEvent.isControl, ae->MetaState()); #endif DispatchEvent(&pressEvent); } #ifdef DEBUG_ANDROID_IME #define ALOGIME(args...) ALOG(args) #else #define ALOGIME(args...) #endif void nsWindow::OnIMEAddRange(AndroidGeckoEvent *ae) { //ALOGIME("IME: IME_ADD_RANGE"); nsTextRange range; range.mStartOffset = ae->Offset(); range.mEndOffset = range.mStartOffset + ae->Count(); range.mRangeType = ae->RangeType(); range.mRangeStyle.mDefinedStyles = ae->RangeStyles(); range.mRangeStyle.mLineStyle = nsTextRangeStyle::LINESTYLE_SOLID; range.mRangeStyle.mForegroundColor = NS_RGBA( ((ae->RangeForeColor() >> 16) & 0xff), ((ae->RangeForeColor() >> 8) & 0xff), (ae->RangeForeColor() & 0xff), ((ae->RangeForeColor() >> 24) & 0xff)); range.mRangeStyle.mBackgroundColor = NS_RGBA( ((ae->RangeBackColor() >> 16) & 0xff), ((ae->RangeBackColor() >> 8) & 0xff), (ae->RangeBackColor() & 0xff), ((ae->RangeBackColor() >> 24) & 0xff)); mIMERanges.AppendElement(range); return; } void nsWindow::OnIMEEvent(AndroidGeckoEvent *ae) { nsRefPtr kungFuDeathGrip(this); switch (ae->Action()) { case AndroidGeckoEvent::IME_COMPOSITION_END: { ALOGIME("IME: IME_COMPOSITION_END"); nsCompositionEvent event(true, NS_COMPOSITION_END, this); InitEvent(event, nsnull); event.data = mIMELastDispatchedComposingText; mIMELastDispatchedComposingText.Truncate(); DispatchEvent(&event); } return; case AndroidGeckoEvent::IME_COMPOSITION_BEGIN: { ALOGIME("IME: IME_COMPOSITION_BEGIN"); mIMELastDispatchedComposingText.Truncate(); nsCompositionEvent event(true, NS_COMPOSITION_START, this); InitEvent(event, nsnull); DispatchEvent(&event); } return; case AndroidGeckoEvent::IME_ADD_RANGE: { OnIMEAddRange(ae); } return; case AndroidGeckoEvent::IME_SET_TEXT: { OnIMEAddRange(ae); nsTextEvent event(true, NS_TEXT_TEXT, this); InitEvent(event, nsnull); event.theText.Assign(ae->Characters()); event.rangeArray = mIMERanges.Elements(); event.rangeCount = mIMERanges.Length(); if (mIMEComposing && event.theText != mIMELastDispatchedComposingText) { nsCompositionEvent compositionUpdate(true, NS_COMPOSITION_UPDATE, this); InitEvent(compositionUpdate, nsnull); compositionUpdate.data = event.theText; mIMELastDispatchedComposingText = event.theText; DispatchEvent(&compositionUpdate); if (Destroyed()) return; } ALOGIME("IME: IME_SET_TEXT: l=%u, r=%u", event.theText.Length(), mIMERanges.Length()); DispatchEvent(&event); mIMERanges.Clear(); } return; case AndroidGeckoEvent::IME_GET_TEXT: { ALOGIME("IME: IME_GET_TEXT: o=%u, l=%u", ae->Offset(), ae->Count()); nsQueryContentEvent event(true, NS_QUERY_TEXT_CONTENT, this); InitEvent(event, nsnull); event.InitForQueryTextContent(ae->Offset(), ae->Count()); DispatchEvent(&event); if (!event.mSucceeded) { ALOGIME("IME: -> failed"); AndroidBridge::Bridge()->ReturnIMEQueryResult( nsnull, 0, 0, 0); return; } else if (!event.mWasAsync) { AndroidBridge::Bridge()->ReturnIMEQueryResult( event.mReply.mString.get(), event.mReply.mString.Length(), 0, 0); } //ALOGIME("IME: -> l=%u", event.mReply.mString.Length()); } return; case AndroidGeckoEvent::IME_DELETE_TEXT: { ALOGIME("IME: IME_DELETE_TEXT"); nsKeyEvent event(true, NS_KEY_PRESS, this); InitEvent(event, nsnull); event.keyCode = NS_VK_BACK; DispatchEvent(&event); } return; case AndroidGeckoEvent::IME_SET_SELECTION: { ALOGIME("IME: IME_SET_SELECTION: o=%u, l=%d", ae->Offset(), ae->Count()); nsSelectionEvent selEvent(true, NS_SELECTION_SET, this); InitEvent(selEvent, nsnull); selEvent.mOffset = PRUint32(ae->Count() >= 0 ? ae->Offset() : ae->Offset() + ae->Count()); selEvent.mLength = PRUint32(NS_ABS(ae->Count())); selEvent.mReversed = ae->Count() >= 0 ? false : true; DispatchEvent(&selEvent); } return; case AndroidGeckoEvent::IME_GET_SELECTION: { ALOGIME("IME: IME_GET_SELECTION"); nsQueryContentEvent event(true, NS_QUERY_SELECTED_TEXT, this); InitEvent(event, nsnull); DispatchEvent(&event); if (!event.mSucceeded) { ALOGIME("IME: -> failed"); AndroidBridge::Bridge()->ReturnIMEQueryResult( nsnull, 0, 0, 0); return; } else if (!event.mWasAsync) { AndroidBridge::Bridge()->ReturnIMEQueryResult( event.mReply.mString.get(), event.mReply.mString.Length(), event.GetSelectionStart(), event.GetSelectionEnd() - event.GetSelectionStart()); } //ALOGIME("IME: -> o=%u, l=%u", event.mReply.mOffset, event.mReply.mString.Length()); } return; } } nsWindow * nsWindow::FindWindowForPoint(const nsIntPoint& pt) { if (!mBounds.Contains(pt)) return nsnull; // children mBounds are relative to their parent nsIntPoint childPoint(pt.x - mBounds.x, pt.y - mBounds.y); for (PRUint32 i = 0; i < mChildren.Length(); ++i) { if (mChildren[i]->mBounds.Contains(childPoint)) return mChildren[i]->FindWindowForPoint(childPoint); } return this; } void nsWindow::UserActivity() { if (!mIdleService) { mIdleService = do_GetService("@mozilla.org/widget/idleservice;1"); } if (mIdleService) { mIdleService->ResetIdleTimeOut(); } } NS_IMETHODIMP nsWindow::ResetInputState() { //ALOGIME("IME: ResetInputState: s=%d", aState); // Cancel composition on Gecko side if (mIMEComposing) { nsRefPtr kungFuDeathGrip(this); nsTextEvent textEvent(true, NS_TEXT_TEXT, this); InitEvent(textEvent, nsnull); textEvent.theText = mIMEComposingText; DispatchEvent(&textEvent); mIMEComposingText.Truncate(0); nsCompositionEvent event(true, NS_COMPOSITION_END, this); InitEvent(event, nsnull); DispatchEvent(&event); } AndroidBridge::NotifyIME(AndroidBridge::NOTIFY_IME_RESETINPUTSTATE, 0); // Send IME text/selection change notifications OnIMETextChange(0, 0, 0); OnIMESelectionChange(); return NS_OK; } NS_IMETHODIMP_(void) nsWindow::SetInputContext(const InputContext& aContext, const InputContextAction& aAction) { ALOGIME("IME: SetInputContext: s=0x%X, 0x%X, action=0x%X, 0x%X", aContext.mIMEState.mEnabled, aContext.mIMEState.mOpen, aAction.mCause, aAction.mFocusChange); mInputContext = aContext; // Ensure that opening the virtual keyboard is allowed for this specific // InputContext depending on the content.ime.strict.policy pref if (aContext.mIMEState.mEnabled != IMEState::DISABLED && aContext.mIMEState.mEnabled != IMEState::PLUGIN && Preferences::GetBool("content.ime.strict_policy", false) && !aAction.ContentGotFocusByTrustedCause() && !aAction.UserMightRequestOpenVKB()) { return; } AndroidBridge::NotifyIMEEnabled(int(aContext.mIMEState.mEnabled), aContext.mHTMLInputType, aContext.mActionHint); } NS_IMETHODIMP_(InputContext) nsWindow::GetInputContext() { mInputContext.mIMEState.mOpen = IMEState::OPEN_STATE_NOT_SUPPORTED; return mInputContext; } NS_IMETHODIMP nsWindow::CancelIMEComposition() { ALOGIME("IME: CancelIMEComposition"); // Cancel composition on Gecko side if (mIMEComposing) { nsRefPtr kungFuDeathGrip(this); nsTextEvent textEvent(true, NS_TEXT_TEXT, this); InitEvent(textEvent, nsnull); DispatchEvent(&textEvent); mIMEComposingText.Truncate(0); nsCompositionEvent compEvent(true, NS_COMPOSITION_END, this); InitEvent(compEvent, nsnull); DispatchEvent(&compEvent); } AndroidBridge::NotifyIME(AndroidBridge::NOTIFY_IME_CANCELCOMPOSITION, 0); return NS_OK; } NS_IMETHODIMP nsWindow::OnIMEFocusChange(bool aFocus) { ALOGIME("IME: OnIMEFocusChange: f=%d", aFocus); AndroidBridge::NotifyIME(AndroidBridge::NOTIFY_IME_FOCUSCHANGE, int(aFocus)); if (aFocus) { OnIMETextChange(0, 0, 0); OnIMESelectionChange(); } return NS_OK; } NS_IMETHODIMP nsWindow::OnIMETextChange(PRUint32 aStart, PRUint32 aOldEnd, PRUint32 aNewEnd) { ALOGIME("IME: OnIMETextChange: s=%d, oe=%d, ne=%d", aStart, aOldEnd, aNewEnd); // A quirk in Android makes it necessary to pass the whole text. // The more efficient way would have been passing the substring from index // aStart to index aNewEnd nsRefPtr kungFuDeathGrip(this); nsQueryContentEvent event(true, NS_QUERY_TEXT_CONTENT, this); InitEvent(event, nsnull); event.InitForQueryTextContent(0, PR_UINT32_MAX); DispatchEvent(&event); if (!event.mSucceeded) return NS_OK; AndroidBridge::NotifyIMEChange(event.mReply.mString.get(), event.mReply.mString.Length(), aStart, aOldEnd, aNewEnd); return NS_OK; } NS_IMETHODIMP nsWindow::OnIMESelectionChange(void) { ALOGIME("IME: OnIMESelectionChange"); nsRefPtr kungFuDeathGrip(this); nsQueryContentEvent event(true, NS_QUERY_SELECTED_TEXT, this); InitEvent(event, nsnull); DispatchEvent(&event); if (!event.mSucceeded) return NS_OK; AndroidBridge::NotifyIMEChange(nsnull, 0, int(event.mReply.mOffset), int(event.mReply.mOffset + event.mReply.mString.Length()), -1); return NS_OK; } nsIMEUpdatePreference nsWindow::GetIMEUpdatePreference() { return nsIMEUpdatePreference(true, true); } #ifdef MOZ_JAVA_COMPOSITOR void nsWindow::DrawWindowUnderlay(LayerManager* aManager, nsIntRect aRect) { AndroidBridge::AutoLocalJNIFrame jniFrame(GetJNIForThread()); AndroidGeckoLayerClient& client = AndroidBridge::Bridge()->GetLayerClient(); client.CreateFrame(mLayerRendererFrame); client.ActivateProgram(); mLayerRendererFrame.BeginDrawing(); mLayerRendererFrame.DrawBackground(); client.DeactivateProgram(); } void nsWindow::DrawWindowOverlay(LayerManager* aManager, nsIntRect aRect) { AndroidBridge::AutoLocalJNIFrame jniFrame(GetJNIForThread()); NS_ABORT_IF_FALSE(!mLayerRendererFrame.isNull(), "Frame should have been created in DrawWindowUnderlay()!"); AndroidGeckoLayerClient& client = AndroidBridge::Bridge()->GetLayerClient(); client.ActivateProgram(); mLayerRendererFrame.DrawForeground(); mLayerRendererFrame.EndDrawing(); client.DeactivateProgram(); mLayerRendererFrame.Dispose(); } // off-main-thread compositor fields and functions nsRefPtr nsWindow::sCompositorParent = 0; nsRefPtr nsWindow::sCompositorChild = 0; base::Thread * nsWindow::sCompositorThread = 0; bool nsWindow::sCompositorPaused = false; void nsWindow::SetCompositor(mozilla::layers::CompositorParent* aCompositorParent, mozilla::layers::CompositorChild* aCompositorChild, ::base::Thread* aCompositorThread) { sCompositorParent = aCompositorParent; sCompositorChild = aCompositorChild; sCompositorThread = aCompositorThread; } void nsWindow::ScheduleComposite() { if (sCompositorParent) { sCompositorParent->ScheduleRenderOnCompositorThread(); } } void nsWindow::SchedulePauseComposition() { if (sCompositorParent) { sCompositorParent->SchedulePauseOnCompositorThread(); } } void nsWindow::ScheduleResumeComposition() { if (sCompositorParent) { sCompositorParent->ScheduleResumeOnCompositorThread(); } } #endif