/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=2 sw=2 et tw=80: */ /* ***** 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.org code. * * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 1998 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Makoto Kato * Dean Tessman * Mats Palmgren * Masayuki Nakano * Ginn Chen * Simon Bünzli * Ehsan Akhgari * Ningjie Chen * * Alternatively, the contents of this file may be used under the terms of * either of 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 "nsCOMPtr.h" #include "nsEventStateManager.h" #include "nsEventListenerManager.h" #include "nsIMEStateManager.h" #include "nsContentEventHandler.h" #include "nsIContent.h" #include "nsINodeInfo.h" #include "nsIDocument.h" #include "nsIFrame.h" #include "nsIWidget.h" #include "nsPresContext.h" #include "nsIPresShell.h" #include "nsDOMEvent.h" #include "nsGkAtoms.h" #include "nsIEditorDocShell.h" #include "nsIFormControl.h" #include "nsIComboboxControlFrame.h" #include "nsIDOMNSHTMLElement.h" #include "nsIDOMHTMLAnchorElement.h" #include "nsIDOMHTMLInputElement.h" #include "nsIDOMNSHTMLInputElement.h" #include "nsIDOMHTMLSelectElement.h" #include "nsIDOMHTMLTextAreaElement.h" #include "nsIDOMHTMLAreaElement.h" #include "nsIDOMHTMLButtonElement.h" #include "nsIDOMHTMLObjectElement.h" #include "nsIDOMHTMLImageElement.h" #include "nsIDOMHTMLMapElement.h" #include "nsIDOMHTMLBodyElement.h" #include "nsIDOMXULControlElement.h" #include "nsIDOMXULTextboxElement.h" #include "nsImageMapUtils.h" #include "nsIHTMLDocument.h" #include "nsINameSpaceManager.h" #include "nsIBaseWindow.h" #include "nsIScrollableView.h" #include "nsIView.h" #include "nsIViewManager.h" #include "nsISelection.h" #include "nsFrameSelection.h" #include "nsIDeviceContext.h" #include "nsIPrivateDOMEvent.h" #include "nsIDOMWindowInternal.h" #include "nsPIDOMWindow.h" #include "nsIDOMEventTarget.h" #include "nsIEnumerator.h" #include "nsIDocShellTreeItem.h" #include "nsIDocShellTreeNode.h" #include "nsIWebNavigation.h" #include "nsIContentViewer.h" #include "nsIPrefBranch2.h" #include "nsIObjectFrame.h" #ifdef MOZ_XUL #include "nsXULPopupManager.h" #endif #include "nsIServiceManager.h" #include "nsIScriptSecurityManager.h" #include "nsFocusManager.h" #include "nsIDOMXULElement.h" #include "nsIDOMDocument.h" #include "nsIDOMKeyEvent.h" #include "nsIObserverService.h" #include "nsIDocShell.h" #include "nsIMarkupDocumentViewer.h" #include "nsIScrollableViewProvider.h" #include "nsIDOMDocumentRange.h" #include "nsIDOMDocumentEvent.h" #include "nsIDOMMouseScrollEvent.h" #include "nsIDOMDragEvent.h" #include "nsIDOMEventTarget.h" #include "nsIDOMDocumentView.h" #include "nsIDOMNSUIEvent.h" #include "nsDOMDragEvent.h" #include "nsIDOMNSEditableElement.h" #include "nsIDOMRange.h" #include "nsCaret.h" #include "nsILookAndFeel.h" #include "nsWidgetsCID.h" #include "nsIFrameFrame.h" #include "nsIFrameTraversal.h" #include "nsLayoutCID.h" #include "nsLayoutUtils.h" #include "nsIInterfaceRequestorUtils.h" #include "nsUnicharUtils.h" #include "nsContentUtils.h" #include "imgIContainer.h" #include "nsIProperties.h" #include "nsISupportsPrimitives.h" #include "nsEventDispatcher.h" #include "nsPresShellIterator.h" #include "nsServiceManagerUtils.h" #include "nsITimer.h" #include "nsIFontMetrics.h" #include "nsIDOMXULDocument.h" #include "nsIDragService.h" #include "nsIDragSession.h" #include "nsDOMDataTransfer.h" #include "nsContentAreaDragDrop.h" #ifdef MOZ_XUL #include "nsTreeBodyFrame.h" #endif #ifdef XP_MACOSX #include #endif //#define DEBUG_DOCSHELL_FOCUS #define NS_USER_INTERACTION_INTERVAL 5000 // ms static NS_DEFINE_CID(kFrameTraversalCID, NS_FRAMETRAVERSAL_CID); //we will use key binding by default now. this wil lbreak viewer for now #define NON_KEYBINDING 0 static NS_DEFINE_CID(kLookAndFeelCID, NS_LOOKANDFEEL_CID); static PRBool sLeftClickOnly = PR_TRUE; static PRBool sKeyCausesActivation = PR_TRUE; static PRUint32 sESMInstanceCount = 0; static PRInt32 sChromeAccessModifier = 0, sContentAccessModifier = 0; PRInt32 nsEventStateManager::sUserInputEventDepth = 0; static PRUint32 gMouseOrKeyboardEventCounter = 0; static nsITimer* gUserInteractionTimer = nsnull; static nsITimerCallback* gUserInteractionTimerCallback = nsnull; // Pixel scroll accumulation for synthetic line scrolls static nscoord gPixelScrollDeltaX = 0; static nscoord gPixelScrollDeltaY = 0; static PRUint32 gPixelScrollDeltaTimeout = 0; static nscoord GetScrollableViewLineHeight(nsPresContext* aPresContext, nsIFrame* aTargetFrame); #ifdef DEBUG_DOCSHELL_FOCUS static void PrintDocTree(nsIDocShellTreeItem* aParentItem, int aLevel) { for (PRInt32 i=0;iGetChildCount(&childWebshellCount); nsCOMPtr parentAsDocShell(do_QueryInterface(aParentItem)); PRInt32 type; aParentItem->GetItemType(&type); nsCOMPtr presShell; parentAsDocShell->GetPresShell(getter_AddRefs(presShell)); nsCOMPtr presContext; parentAsDocShell->GetPresContext(getter_AddRefs(presContext)); nsCOMPtr cv; parentAsDocShell->GetContentViewer(getter_AddRefs(cv)); nsCOMPtr domDoc; if (cv) cv->GetDOMDocument(getter_AddRefs(domDoc)); nsCOMPtr doc = do_QueryInterface(domDoc); nsCOMPtr domwin = doc ? doc->GetWindow() : nsnull; nsIURI* uri = doc ? doc->GetDocumentURI() : nsnull; nsCOMPtr widget; nsIViewManager* vm = presShell ? presShell->GetViewManager() : nsnull; if (vm) { vm->GetWidget(getter_AddRefs(widget)); } printf("DS %p Type %s Cnt %d Doc %p DW %p EM %p%c", static_cast(parentAsDocShell.get()), type==nsIDocShellTreeItem::typeChrome?"Chrome":"Content", childWebshellCount, static_cast(doc.get()), static_cast(domwin.get()), static_cast(presContext ? presContext->EventStateManager() : nsnull), uri ? ' ' : '\n'); if (uri) { nsCAutoString spec; uri->GetSpec(spec); printf("\"%s\"\n", spec.get()); } if (childWebshellCount > 0) { for (PRInt32 i = 0; i < childWebshellCount; i++) { nsCOMPtr child; aParentItem->GetChildAt(i, getter_AddRefs(child)); PrintDocTree(child, aLevel + 1); } } } static void PrintDocTreeAll(nsIDocShellTreeItem* aItem) { nsCOMPtr item = aItem; for(;;) { nsCOMPtr parent; item->GetParent(getter_AddRefs(parent)); if (!parent) break; item = parent; } PrintDocTree(item, 0); } #endif class nsUITimerCallback : public nsITimerCallback { public: nsUITimerCallback() : mPreviousCount(0) {} NS_DECL_ISUPPORTS NS_DECL_NSITIMERCALLBACK private: PRUint32 mPreviousCount; }; NS_IMPL_ISUPPORTS1(nsUITimerCallback, nsITimerCallback) // If aTimer is nsnull, this method always sends "user-interaction-inactive" // notification. NS_IMETHODIMP nsUITimerCallback::Notify(nsITimer* aTimer) { nsresult rv; nsCOMPtr obs = do_GetService("@mozilla.org/observer-service;1", &rv); NS_ENSURE_SUCCESS(rv, rv); if ((gMouseOrKeyboardEventCounter == mPreviousCount) || !aTimer) { gMouseOrKeyboardEventCounter = 0; obs->NotifyObservers(nsnull, "user-interaction-inactive", nsnull); } else { obs->NotifyObservers(nsnull, "user-interaction-active", nsnull); } mPreviousCount = gMouseOrKeyboardEventCounter; return NS_OK; } enum { MOUSE_SCROLL_N_LINES, MOUSE_SCROLL_PAGE, MOUSE_SCROLL_HISTORY, MOUSE_SCROLL_ZOOM, MOUSE_SCROLL_PIXELS }; // mask values for ui.key.chromeAccess and ui.key.contentAccess #define NS_MODIFIER_SHIFT 1 #define NS_MODIFIER_CONTROL 2 #define NS_MODIFIER_ALT 4 #define NS_MODIFIER_META 8 static nsIDocument * GetDocumentFromWindow(nsIDOMWindow *aWindow) { nsCOMPtr win = do_QueryInterface(aWindow); nsCOMPtr doc; if (win) { doc = do_QueryInterface(win->GetExtantDocument()); } return doc; } static PRInt32 GetAccessModifierMaskFromPref(PRInt32 aItemType) { PRInt32 accessKey = nsContentUtils::GetIntPref("ui.key.generalAccessKey", -1); switch (accessKey) { case -1: break; // use the individual prefs case nsIDOMKeyEvent::DOM_VK_SHIFT: return NS_MODIFIER_SHIFT; case nsIDOMKeyEvent::DOM_VK_CONTROL: return NS_MODIFIER_CONTROL; case nsIDOMKeyEvent::DOM_VK_ALT: return NS_MODIFIER_ALT; case nsIDOMKeyEvent::DOM_VK_META: return NS_MODIFIER_META; default: return 0; } switch (aItemType) { case nsIDocShellTreeItem::typeChrome: return nsContentUtils::GetIntPref("ui.key.chromeAccess", 0); case nsIDocShellTreeItem::typeContent: return nsContentUtils::GetIntPref("ui.key.contentAccess", 0); default: return 0; } } static void GetBasePrefKeyForMouseWheel(nsMouseScrollEvent* aEvent, nsACString& aPref) { NS_NAMED_LITERAL_CSTRING(prefbase, "mousewheel"); NS_NAMED_LITERAL_CSTRING(horizscroll, ".horizscroll"); NS_NAMED_LITERAL_CSTRING(withshift, ".withshiftkey"); NS_NAMED_LITERAL_CSTRING(withalt, ".withaltkey"); NS_NAMED_LITERAL_CSTRING(withcontrol, ".withcontrolkey"); NS_NAMED_LITERAL_CSTRING(withmetakey, ".withmetakey"); NS_NAMED_LITERAL_CSTRING(withno, ".withnokey"); aPref = prefbase; if (aEvent->scrollFlags & nsMouseScrollEvent::kIsHorizontal) { aPref.Append(horizscroll); } if (aEvent->isShift) { aPref.Append(withshift); } else if (aEvent->isControl) { aPref.Append(withcontrol); } else if (aEvent->isAlt) { aPref.Append(withalt); } else if (aEvent->isMeta) { aPref.Append(withmetakey); } else { aPref.Append(withno); } } class nsMouseWheelTransaction { public: static nsIFrame* GetTargetFrame() { return sTargetFrame; } static void BeginTransaction(nsIFrame* aTargetFrame, PRInt32 aNumLines, PRBool aScrollHorizontal); // Be careful, UpdateTransaction may fire a DOM event, therefore, the target // frame might be destroyed in the event handler. static PRBool UpdateTransaction(PRInt32 aNumLines, PRBool aScrollHorizontal); static void EndTransaction(); static void OnEvent(nsEvent* aEvent); static void Shutdown(); static PRUint32 GetTimeoutTime(); protected: static nsIntPoint GetScreenPoint(nsGUIEvent* aEvent); static void OnFailToScrollTarget(); static void OnTimeout(nsITimer *aTimer, void *aClosure); static void SetTimeout(); static PRUint32 GetIgnoreMoveDelayTime(); static nsWeakFrame sTargetFrame; static PRUint32 sTime; // in milliseconds static PRUint32 sMouseMoved; // in milliseconds static nsITimer* sTimer; }; nsWeakFrame nsMouseWheelTransaction::sTargetFrame(nsnull); PRUint32 nsMouseWheelTransaction::sTime = 0; PRUint32 nsMouseWheelTransaction::sMouseMoved = 0; nsITimer* nsMouseWheelTransaction::sTimer = nsnull; static PRBool CanScrollOn(nsIScrollableView* aScrollView, PRInt32 aNumLines, PRBool aScrollHorizontal) { NS_PRECONDITION(aScrollView, "aScrollView is null"); NS_PRECONDITION(aNumLines, "aNumLines must be non-zero"); PRBool canScroll; nsresult rv = aScrollView->CanScroll(aScrollHorizontal, aNumLines > 0, canScroll); return NS_SUCCEEDED(rv) && canScroll; } void nsMouseWheelTransaction::BeginTransaction(nsIFrame* aTargetFrame, PRInt32 aNumLines, PRBool aScrollHorizontal) { NS_ASSERTION(!sTargetFrame, "previous transaction is not finished!"); sTargetFrame = aTargetFrame; if (!UpdateTransaction(aNumLines, aScrollHorizontal)) { NS_ERROR("BeginTransaction is called even cannot scroll the frame"); EndTransaction(); } } PRBool nsMouseWheelTransaction::UpdateTransaction(PRInt32 aNumLines, PRBool aScrollHorizontal) { nsIScrollableViewProvider* svp = do_QueryFrame(GetTargetFrame()); NS_ENSURE_TRUE(svp, PR_FALSE); nsIScrollableView *scrollView = svp->GetScrollableView(); NS_ENSURE_TRUE(scrollView, PR_FALSE); if (!CanScrollOn(scrollView, aNumLines, aScrollHorizontal)) { OnFailToScrollTarget(); // We should not modify the transaction state when the view will not be // scrolled actually. return PR_FALSE; } SetTimeout(); // We should use current time instead of nsEvent.time. // 1. Some events doesn't have the correct creation time. // 2. If the computer runs slowly by other processes eating the CPU resource, // the event creation time doesn't keep real time. sTime = PR_IntervalToMilliseconds(PR_IntervalNow()); sMouseMoved = 0; return PR_TRUE; } void nsMouseWheelTransaction::EndTransaction() { if (sTimer) sTimer->Cancel(); sTargetFrame = nsnull; } static PRBool OutOfTime(PRUint32 aBaseTime, PRUint32 aThreshold) { PRUint32 now = PR_IntervalToMilliseconds(PR_IntervalNow()); return (now - aBaseTime > aThreshold); } void nsMouseWheelTransaction::OnEvent(nsEvent* aEvent) { if (!sTargetFrame) return; if (OutOfTime(sTime, GetTimeoutTime())) { // Even if the scroll event which is handled after timeout, but onTimeout // was not fired by timer, then the scroll event will scroll old frame, // therefore, we should call OnTimeout here and ensure to finish the old // transaction. OnTimeout(nsnull, nsnull); return; } switch (aEvent->message) { case NS_MOUSE_SCROLL: if (sMouseMoved != 0 && OutOfTime(sMouseMoved, GetIgnoreMoveDelayTime())) { // Terminate the current mousewheel transaction if the mouse moved more // than ignoremovedelay milliseconds ago EndTransaction(); } return; case NS_MOUSE_MOVE: case NS_DRAGDROP_OVER: if (((nsMouseEvent*)aEvent)->reason == nsMouseEvent::eReal) { // If the cursor is moving to be outside the frame, // terminate the scrollwheel transaction. nsIntPoint pt = GetScreenPoint((nsGUIEvent*)aEvent); nsIntRect r = sTargetFrame->GetScreenRectExternal(); if (!r.Contains(pt)) { EndTransaction(); return; } // If the cursor is moving inside the frame, and it is less than // ignoremovedelay milliseconds since the last scroll operation, ignore // the mouse move; otherwise, record the current mouse move time to be // checked later if (OutOfTime(sTime, GetIgnoreMoveDelayTime())) { if (sMouseMoved == 0) sMouseMoved = PR_IntervalToMilliseconds(PR_IntervalNow()); } } return; case NS_KEY_PRESS: case NS_KEY_UP: case NS_KEY_DOWN: case NS_MOUSE_BUTTON_UP: case NS_MOUSE_BUTTON_DOWN: case NS_MOUSE_DOUBLECLICK: case NS_MOUSE_CLICK: case NS_CONTEXTMENU: case NS_DRAGDROP_DROP: EndTransaction(); return; } } void nsMouseWheelTransaction::Shutdown() { NS_IF_RELEASE(sTimer); } void nsMouseWheelTransaction::OnFailToScrollTarget() { NS_PRECONDITION(sTargetFrame, "We don't have mouse scrolling transaction"); if (nsContentUtils::GetBoolPref("test.mousescroll", PR_FALSE)) { // This event is used for automated tests, see bug 442774. nsContentUtils::DispatchTrustedEvent( sTargetFrame->GetContent()->GetOwnerDoc(), sTargetFrame->GetContent(), NS_LITERAL_STRING("MozMouseScrollFailed"), PR_TRUE, PR_TRUE); } // The target frame might be destroyed in the event handler, at that time, // we need to finish the current transaction if (!sTargetFrame) EndTransaction(); } void nsMouseWheelTransaction::OnTimeout(nsITimer* aTimer, void* aClosure) { if (!sTargetFrame) { // The transaction target was destroyed already EndTransaction(); return; } // Store the sTargetFrame, the variable becomes null in EndTransaction. nsIFrame* frame = sTargetFrame; // We need to finish current transaction before DOM event firing. Because // the next DOM event might create strange situation for us. EndTransaction(); if (nsContentUtils::GetBoolPref("test.mousescroll", PR_FALSE)) { // This event is used for automated tests, see bug 442774. nsContentUtils::DispatchTrustedEvent( frame->GetContent()->GetOwnerDoc(), frame->GetContent(), NS_LITERAL_STRING("MozMouseScrollTransactionTimeout"), PR_TRUE, PR_TRUE); } } void nsMouseWheelTransaction::SetTimeout() { if (!sTimer) { nsCOMPtr timer = do_CreateInstance(NS_TIMER_CONTRACTID); if (!timer) return; timer.swap(sTimer); } sTimer->Cancel(); nsresult rv = sTimer->InitWithFuncCallback(OnTimeout, nsnull, GetTimeoutTime(), nsITimer::TYPE_ONE_SHOT); NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "nsITimer::InitWithFuncCallback failed"); } nsIntPoint nsMouseWheelTransaction::GetScreenPoint(nsGUIEvent* aEvent) { NS_ASSERTION(aEvent, "aEvent is null"); NS_ASSERTION(aEvent->widget, "aEvent-widget is null"); return aEvent->refPoint + aEvent->widget->WidgetToScreenOffset(); } PRUint32 nsMouseWheelTransaction::GetTimeoutTime() { return (PRUint32) nsContentUtils::GetIntPref("mousewheel.transaction.timeout", 1500); } PRUint32 nsMouseWheelTransaction::GetIgnoreMoveDelayTime() { return (PRUint32) nsContentUtils::GetIntPref("mousewheel.transaction.ignoremovedelay", 100); } /******************************************************************/ /* nsEventStateManager */ /******************************************************************/ nsEventStateManager::nsEventStateManager() : mLockCursor(0), mCurrentTarget(nsnull), mLastMouseOverFrame(nsnull), mLastDragOverFrame(nsnull), // init d&d gesture state machine variables mGestureDownPoint(0,0), mPresContext(nsnull), mLClickCount(0), mMClickCount(0), mRClickCount(0), mNormalLMouseEventInProcess(PR_FALSE), m_haveShutdown(PR_FALSE), mLastLineScrollConsumedX(PR_FALSE), mLastLineScrollConsumedY(PR_FALSE) { if (sESMInstanceCount == 0) { gUserInteractionTimerCallback = new nsUITimerCallback(); if (gUserInteractionTimerCallback) { NS_ADDREF(gUserInteractionTimerCallback); CallCreateInstance("@mozilla.org/timer;1", &gUserInteractionTimer); if (gUserInteractionTimer) { gUserInteractionTimer->InitWithCallback(gUserInteractionTimerCallback, NS_USER_INTERACTION_INTERVAL, nsITimer::TYPE_REPEATING_SLACK); } } } ++sESMInstanceCount; } NS_IMETHODIMP nsEventStateManager::Init() { nsresult rv; nsCOMPtr observerService = do_GetService("@mozilla.org/observer-service;1", &rv); NS_ENSURE_SUCCESS(rv, rv); observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, PR_TRUE); nsCOMPtr prefBranch = do_QueryInterface(nsContentUtils::GetPrefBranch()); if (prefBranch) { if (sESMInstanceCount == 1) { sLeftClickOnly = nsContentUtils::GetBoolPref("nglayout.events.dispatchLeftClickOnly", sLeftClickOnly); sChromeAccessModifier = GetAccessModifierMaskFromPref(nsIDocShellTreeItem::typeChrome); sContentAccessModifier = GetAccessModifierMaskFromPref(nsIDocShellTreeItem::typeContent); } prefBranch->AddObserver("accessibility.accesskeycausesactivation", this, PR_TRUE); prefBranch->AddObserver("nglayout.events.dispatchLeftClickOnly", this, PR_TRUE); prefBranch->AddObserver("ui.key.generalAccessKey", this, PR_TRUE); prefBranch->AddObserver("ui.key.chromeAccess", this, PR_TRUE); prefBranch->AddObserver("ui.key.contentAccess", this, PR_TRUE); #if 0 prefBranch->AddObserver("mousewheel.withaltkey.action", this, PR_TRUE); prefBranch->AddObserver("mousewheel.withaltkey.numlines", this, PR_TRUE); prefBranch->AddObserver("mousewheel.withaltkey.sysnumlines", this, PR_TRUE); prefBranch->AddObserver("mousewheel.withcontrolkey.action", this, PR_TRUE); prefBranch->AddObserver("mousewheel.withcontrolkey.numlines", this, PR_TRUE); prefBranch->AddObserver("mousewheel.withcontrolkey.sysnumlines", this, PR_TRUE); prefBranch->AddObserver("mousewheel.withnokey.action", this, PR_TRUE); prefBranch->AddObserver("mousewheel.withnokey.numlines", this, PR_TRUE); prefBranch->AddObserver("mousewheel.withnokey.sysnumlines", this, PR_TRUE); prefBranch->AddObserver("mousewheel.withshiftkey.action", this, PR_TRUE); prefBranch->AddObserver("mousewheel.withshiftkey.numlines", this, PR_TRUE); prefBranch->AddObserver("mousewheel.withshiftkey.sysnumlines", this, PR_TRUE); #endif prefBranch->AddObserver("dom.popup_allowed_events", this, PR_TRUE); } return rv; } nsEventStateManager::~nsEventStateManager() { #if CLICK_HOLD_CONTEXT_MENUS KillClickHoldTimer(); #endif --sESMInstanceCount; if(sESMInstanceCount == 0) { nsMouseWheelTransaction::Shutdown(); if (gUserInteractionTimerCallback) { gUserInteractionTimerCallback->Notify(nsnull); NS_RELEASE(gUserInteractionTimerCallback); } if (gUserInteractionTimer) { gUserInteractionTimer->Cancel(); NS_RELEASE(gUserInteractionTimer); } } if (!m_haveShutdown) { Shutdown(); // Don't remove from Observer service in Shutdown because Shutdown also // gets called from xpcom shutdown observer. And we don't want to remove // from the service in that case. nsresult rv; nsCOMPtr observerService = do_GetService("@mozilla.org/observer-service;1", &rv); if (NS_SUCCEEDED(rv)) { observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID); } } } nsresult nsEventStateManager::Shutdown() { nsCOMPtr prefBranch = do_QueryInterface(nsContentUtils::GetPrefBranch()); if (prefBranch) { prefBranch->RemoveObserver("accessibility.accesskeycausesactivation", this); prefBranch->RemoveObserver("nglayout.events.dispatchLeftClickOnly", this); prefBranch->RemoveObserver("ui.key.generalAccessKey", this); prefBranch->RemoveObserver("ui.key.chromeAccess", this); prefBranch->RemoveObserver("ui.key.contentAccess", this); #if 0 prefBranch->RemoveObserver("mousewheel.withshiftkey.action", this); prefBranch->RemoveObserver("mousewheel.withshiftkey.numlines", this); prefBranch->RemoveObserver("mousewheel.withshiftkey.sysnumlines", this); prefBranch->RemoveObserver("mousewheel.withcontrolkey.action", this); prefBranch->RemoveObserver("mousewheel.withcontrolkey.numlines", this); prefBranch->RemoveObserver("mousewheel.withcontrolkey.sysnumlines", this); prefBranch->RemoveObserver("mousewheel.withaltkey.action", this); prefBranch->RemoveObserver("mousewheel.withaltkey.numlines", this); prefBranch->RemoveObserver("mousewheel.withaltkey.sysnumlines", this); prefBranch->RemoveObserver("mousewheel.withnokey.action", this); prefBranch->RemoveObserver("mousewheel.withnokey.numlines", this); prefBranch->RemoveObserver("mousewheel.withnokey.sysnumlines", this); #endif prefBranch->RemoveObserver("dom.popup_allowed_events", this); } m_haveShutdown = PR_TRUE; return NS_OK; } NS_IMETHODIMP nsEventStateManager::Observe(nsISupports *aSubject, const char *aTopic, const PRUnichar *someData) { if (!nsCRT::strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) Shutdown(); else if (!nsCRT::strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) { if (!someData) return NS_OK; nsDependentString data(someData); if (data.EqualsLiteral("accessibility.accesskeycausesactivation")) { sKeyCausesActivation = nsContentUtils::GetBoolPref("accessibility.accesskeycausesactivation", sKeyCausesActivation); } else if (data.EqualsLiteral("nglayout.events.dispatchLeftClickOnly")) { sLeftClickOnly = nsContentUtils::GetBoolPref("nglayout.events.dispatchLeftClickOnly", sLeftClickOnly); } else if (data.EqualsLiteral("ui.key.generalAccessKey")) { sChromeAccessModifier = GetAccessModifierMaskFromPref(nsIDocShellTreeItem::typeChrome); sContentAccessModifier = GetAccessModifierMaskFromPref(nsIDocShellTreeItem::typeContent); } else if (data.EqualsLiteral("ui.key.chromeAccess")) { sChromeAccessModifier = GetAccessModifierMaskFromPref(nsIDocShellTreeItem::typeChrome); } else if (data.EqualsLiteral("ui.key.contentAccess")) { sContentAccessModifier = GetAccessModifierMaskFromPref(nsIDocShellTreeItem::typeContent); #if 0 } else if (data.EqualsLiteral("mousewheel.withaltkey.action")) { } else if (data.EqualsLiteral("mousewheel.withaltkey.numlines")) { } else if (data.EqualsLiteral("mousewheel.withaltkey.sysnumlines")) { } else if (data.EqualsLiteral("mousewheel.withcontrolkey.action")) { } else if (data.EqualsLiteral("mousewheel.withcontrolkey.numlines")) { } else if (data.EqualsLiteral("mousewheel.withcontrolkey.sysnumlines")) { } else if (data.EqualsLiteral("mousewheel.withshiftkey.action")) { } else if (data.EqualsLiteral("mousewheel.withshiftkey.numlines")) { } else if (data.EqualsLiteral("mousewheel.withshiftkey.sysnumlines")) { } else if (data.EqualsLiteral("mousewheel.withnokey.action")) { } else if (data.EqualsLiteral("mousewheel.withnokey.numlines")) { } else if (data.EqualsLiteral("mousewheel.withnokey.sysnumlines")) { #endif } else if (data.EqualsLiteral("dom.popup_allowed_events")) { nsDOMEvent::PopupAllowedEventsChanged(); } } return NS_OK; } NS_IMPL_CYCLE_COLLECTION_CLASS(nsEventStateManager) NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsEventStateManager) NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIEventStateManager) NS_INTERFACE_MAP_ENTRY(nsIEventStateManager) NS_INTERFACE_MAP_ENTRY(nsIObserver) NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) NS_INTERFACE_MAP_END NS_IMPL_CYCLE_COLLECTING_ADDREF_AMBIGUOUS(nsEventStateManager, nsIEventStateManager) NS_IMPL_CYCLE_COLLECTING_RELEASE_AMBIGUOUS(nsEventStateManager, nsIEventStateManager) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsEventStateManager) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mCurrentTargetContent); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mLastMouseOverElement); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mGestureDownContent); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mGestureDownFrameOwner); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mLastLeftMouseDownContent); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mLastMiddleMouseDownContent); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mLastRightMouseDownContent); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mActiveContent); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mHoverContent); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mDragOverContent); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mURLTargetContent); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mFirstMouseOverEventElement); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mFirstMouseOutEventElement); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mDocument); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMARRAY(mAccessKeys); NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsEventStateManager) NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mCurrentTargetContent); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mLastMouseOverElement); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mGestureDownContent); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mGestureDownFrameOwner); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mLastLeftMouseDownContent); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mLastMiddleMouseDownContent); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mLastRightMouseDownContent); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mActiveContent); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mHoverContent); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mDragOverContent); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mURLTargetContent); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mFirstMouseOverEventElement); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mFirstMouseOutEventElement); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mDocument); NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMARRAY(mAccessKeys); NS_IMPL_CYCLE_COLLECTION_UNLINK_END NS_IMETHODIMP nsEventStateManager::PreHandleEvent(nsPresContext* aPresContext, nsEvent *aEvent, nsIFrame* aTargetFrame, nsEventStatus* aStatus, nsIView* aView) { NS_ENSURE_ARG_POINTER(aStatus); NS_ENSURE_ARG(aPresContext); if (!aEvent) { NS_ERROR("aEvent is null. This should never happen."); return NS_ERROR_NULL_POINTER; } mCurrentTarget = aTargetFrame; mCurrentTargetContent = nsnull; // Focus events don't necessarily need a frame. if (NS_EVENT_NEEDS_FRAME(aEvent)) { NS_ASSERTION(mCurrentTarget, "mCurrentTarget is null. this should not happen. see bug #13007"); if (!mCurrentTarget) return NS_ERROR_NULL_POINTER; } // Do not take account NS_MOUSE_ENTER/EXIT so that loading a page // when user is not active doesn't change the state to active. if (NS_IS_TRUSTED_EVENT(aEvent) && ((aEvent->eventStructType == NS_MOUSE_EVENT && static_cast(aEvent)->reason == nsMouseEvent::eReal && aEvent->message != NS_MOUSE_ENTER && aEvent->message != NS_MOUSE_EXIT) || aEvent->eventStructType == NS_MOUSE_SCROLL_EVENT || aEvent->eventStructType == NS_KEY_EVENT)) { if (gMouseOrKeyboardEventCounter == 0) { nsCOMPtr obs = do_GetService("@mozilla.org/observer-service;1"); if (obs) { obs->NotifyObservers(nsnull, "user-interaction-active", nsnull); } } ++gMouseOrKeyboardEventCounter; } *aStatus = nsEventStatus_eIgnore; nsMouseWheelTransaction::OnEvent(aEvent); switch (aEvent->message) { case NS_MOUSE_BUTTON_DOWN: switch (static_cast(aEvent)->button) { case nsMouseEvent::eLeftButton: #ifndef XP_OS2 BeginTrackingDragGesture ( aPresContext, (nsMouseEvent*)aEvent, aTargetFrame ); #endif mLClickCount = ((nsMouseEvent*)aEvent)->clickCount; SetClickCount(aPresContext, (nsMouseEvent*)aEvent, aStatus); mNormalLMouseEventInProcess = PR_TRUE; break; case nsMouseEvent::eMiddleButton: mMClickCount = ((nsMouseEvent*)aEvent)->clickCount; SetClickCount(aPresContext, (nsMouseEvent*)aEvent, aStatus); break; case nsMouseEvent::eRightButton: #ifdef XP_OS2 BeginTrackingDragGesture ( aPresContext, (nsMouseEvent*)aEvent, aTargetFrame ); #endif mRClickCount = ((nsMouseEvent*)aEvent)->clickCount; SetClickCount(aPresContext, (nsMouseEvent*)aEvent, aStatus); break; } break; case NS_MOUSE_BUTTON_UP: switch (static_cast(aEvent)->button) { case nsMouseEvent::eLeftButton: #ifdef CLICK_HOLD_CONTEXT_MENUS KillClickHoldTimer(); #endif #ifndef XP_OS2 StopTrackingDragGesture(); #endif mNormalLMouseEventInProcess = PR_FALSE; case nsMouseEvent::eRightButton: #ifdef XP_OS2 StopTrackingDragGesture(); #endif case nsMouseEvent::eMiddleButton: SetClickCount(aPresContext, (nsMouseEvent*)aEvent, aStatus); break; } break; case NS_MOUSE_EXIT: // If the event is not a top-level window exit, then it's not // really an exit --- we may have traversed widget boundaries but // we're still in our toplevel window. { nsMouseEvent* mouseEvent = static_cast(aEvent); if (mouseEvent->exit != nsMouseEvent::eTopLevel) { // Treat it as a synthetic move so we don't generate spurious // "exit" or "move" events. Any necessary "out" or "over" events // will be generated by GenerateMouseEnterExit mouseEvent->message = NS_MOUSE_MOVE; mouseEvent->reason = nsMouseEvent::eSynthesized; // then fall through... } else { GenerateMouseEnterExit((nsGUIEvent*)aEvent); //This is a window level mouse exit event and should stop here aEvent->message = 0; break; } } case NS_MOUSE_MOVE: // on the Mac, GenerateDragGesture() may not return until the drag // has completed and so |aTargetFrame| may have been deleted (moving // a bookmark, for example). If this is the case, however, we know // that ClearFrameRefs() has been called and it cleared out // |mCurrentTarget|. As a result, we should pass |mCurrentTarget| // into UpdateCursor(). GenerateDragGesture(aPresContext, (nsMouseEvent*)aEvent); UpdateCursor(aPresContext, aEvent, mCurrentTarget, aStatus); GenerateMouseEnterExit((nsGUIEvent*)aEvent); break; #ifdef CLICK_HOLD_CONTEXT_MENUS case NS_DRAGDROP_GESTURE: // an external drag gesture event came in, not generated internally // by Gecko. Make sure we get rid of the click-hold timer. KillClickHoldTimer(); break; #endif case NS_DRAGDROP_DROP: case NS_DRAGDROP_OVER: // NS_DRAGDROP_DROP is fired before NS_DRAGDROP_DRAGDROP so send // the enter/exit events before NS_DRAGDROP_DROP. GenerateDragDropEnterExit(aPresContext, (nsGUIEvent*)aEvent); break; case NS_KEY_PRESS: { nsKeyEvent* keyEvent = (nsKeyEvent*)aEvent; PRInt32 modifierMask = 0; if (keyEvent->isShift) modifierMask |= NS_MODIFIER_SHIFT; if (keyEvent->isControl) modifierMask |= NS_MODIFIER_CONTROL; if (keyEvent->isAlt) modifierMask |= NS_MODIFIER_ALT; if (keyEvent->isMeta) modifierMask |= NS_MODIFIER_META; // Prevent keyboard scrolling while an accesskey modifier is in use. if (modifierMask && (modifierMask == sChromeAccessModifier || modifierMask == sContentAccessModifier)) HandleAccessKey(aPresContext, keyEvent, aStatus, nsnull, eAccessKeyProcessingNormal, modifierMask); } case NS_KEY_DOWN: case NS_KEY_UP: { nsIContent* content = GetFocusedContent(); if (content) mCurrentTargetContent = content; } break; case NS_MOUSE_SCROLL: { nsIContent* content = GetFocusedContent(); if (content) mCurrentTargetContent = content; nsMouseScrollEvent* msEvent = static_cast(aEvent); NS_NAMED_LITERAL_CSTRING(actionslot, ".action"); NS_NAMED_LITERAL_CSTRING(numlinesslot, ".numlines"); NS_NAMED_LITERAL_CSTRING(sysnumlinesslot, ".sysnumlines"); nsCAutoString baseKey; GetBasePrefKeyForMouseWheel(msEvent, baseKey); nsCAutoString sysNumLinesKey(baseKey); sysNumLinesKey.Append(sysnumlinesslot); PRBool useSysNumLines = nsContentUtils::GetBoolPref(sysNumLinesKey.get()); nsCAutoString actionKey(baseKey); actionKey.Append(actionslot); PRInt32 action = nsContentUtils::GetIntPref(actionKey.get()); if (!useSysNumLines) { // If the scroll event's delta isn't to our liking, we can // override it with the "numlines" parameter. There are two // things we can do: // // (1) Pick a different number. Instead of scrolling 3 // lines ("delta" in Gtk2), we would scroll 1 line. // (2) Swap directions. Instead of scrolling down, scroll up. // // For the first item, the magnitude of the parameter is // used instead of the magnitude of the delta. For the // second item, if the parameter is negative we swap // directions. nsCAutoString numLinesKey(baseKey); numLinesKey.Append(numlinesslot); PRInt32 numLines = nsContentUtils::GetIntPref(numLinesKey.get()); PRBool swapDirs = (numLines < 0); PRInt32 userSize = swapDirs ? -numLines : numLines; PRBool deltaUp = (msEvent->delta < 0); if (swapDirs) { deltaUp = !deltaUp; } msEvent->delta = deltaUp ? -userSize : userSize; } if ((useSysNumLines && (msEvent->scrollFlags & nsMouseScrollEvent::kIsFullPage)) || action == MOUSE_SCROLL_PAGE) { msEvent->delta = (msEvent->delta > 0) ? PRInt32(nsIDOMNSUIEvent::SCROLL_PAGE_DOWN) : PRInt32(nsIDOMNSUIEvent::SCROLL_PAGE_UP); } } break; case NS_MOUSE_PIXEL_SCROLL: { nsIContent* content = GetFocusedContent(); if (content) mCurrentTargetContent = content; nsMouseScrollEvent *msEvent = static_cast(aEvent); // Clear old deltas after a period of non action if (OutOfTime(gPixelScrollDeltaTimeout, nsMouseWheelTransaction::GetTimeoutTime())) { gPixelScrollDeltaX = gPixelScrollDeltaY = 0; } gPixelScrollDeltaTimeout = PR_IntervalToMilliseconds(PR_IntervalNow()); // If needed send a line scroll event for pixel scrolls with kNoLines if (msEvent->scrollFlags & nsMouseScrollEvent::kNoLines) { nscoord pixelHeight = aPresContext->AppUnitsToIntCSSPixels( GetScrollableViewLineHeight(aPresContext, aTargetFrame)); if (msEvent->scrollFlags & nsMouseScrollEvent::kIsVertical) { gPixelScrollDeltaX += msEvent->delta; if (!gPixelScrollDeltaX || !pixelHeight) break; if (PR_ABS(gPixelScrollDeltaX) >= pixelHeight) { PRInt32 numLines = (PRInt32)ceil((float)gPixelScrollDeltaX/(float)pixelHeight); gPixelScrollDeltaX -= numLines*pixelHeight; nsWeakFrame weakFrame(aTargetFrame); SendLineScrollEvent(aTargetFrame, msEvent, aPresContext, aStatus, numLines); NS_ENSURE_STATE(weakFrame.IsAlive()); } } else if (msEvent->scrollFlags & nsMouseScrollEvent::kIsHorizontal) { gPixelScrollDeltaY += msEvent->delta; if (!gPixelScrollDeltaY || !pixelHeight) break; if (PR_ABS(gPixelScrollDeltaY) >= pixelHeight) { PRInt32 numLines = (PRInt32)ceil((float)gPixelScrollDeltaY/(float)pixelHeight); gPixelScrollDeltaY -= numLines*pixelHeight; nsWeakFrame weakFrame(aTargetFrame); SendLineScrollEvent(aTargetFrame, msEvent, aPresContext, aStatus, numLines); NS_ENSURE_STATE(weakFrame.IsAlive()); } } } // When the last line scroll has been canceled, eat the pixel scroll event if ((msEvent->scrollFlags & nsMouseScrollEvent::kIsHorizontal) ? mLastLineScrollConsumedX : mLastLineScrollConsumedY) { *aStatus = nsEventStatus_eConsumeNoDefault; } } break; case NS_QUERY_SELECTED_TEXT: { nsContentEventHandler handler(mPresContext); handler.OnQuerySelectedText((nsQueryContentEvent*)aEvent); } break; case NS_QUERY_TEXT_CONTENT: { nsContentEventHandler handler(mPresContext); handler.OnQueryTextContent((nsQueryContentEvent*)aEvent); } break; case NS_QUERY_CARET_RECT: { nsContentEventHandler handler(mPresContext); handler.OnQueryCaretRect((nsQueryContentEvent*)aEvent); } break; case NS_QUERY_TEXT_RECT: { nsContentEventHandler handler(mPresContext); handler.OnQueryTextRect((nsQueryContentEvent*)aEvent); } break; case NS_QUERY_EDITOR_RECT: { nsContentEventHandler handler(mPresContext); handler.OnQueryEditorRect((nsQueryContentEvent*)aEvent); } break; case NS_QUERY_CONTENT_STATE: { nsContentEventHandler handler(mPresContext); handler.OnQueryContentState(static_cast(aEvent)); } break; case NS_QUERY_SELECTION_AS_TRANSFERABLE: { nsContentEventHandler handler(mPresContext); handler.OnQuerySelectionAsTransferable(static_cast(aEvent)); } break; case NS_QUERY_CHARACTER_AT_POINT: { nsContentEventHandler handler(mPresContext); handler.OnQueryCharacterAtPoint(static_cast(aEvent)); } break; case NS_SELECTION_SET: { nsContentEventHandler handler(mPresContext); handler.OnSelectionEvent((nsSelectionEvent*)aEvent); } break; } return NS_OK; } static PRInt32 GetAccessModifierMask(nsISupports* aDocShell) { nsCOMPtr treeItem(do_QueryInterface(aDocShell)); if (!treeItem) return -1; // invalid modifier PRInt32 itemType; treeItem->GetItemType(&itemType); switch (itemType) { case nsIDocShellTreeItem::typeChrome: return sChromeAccessModifier; case nsIDocShellTreeItem::typeContent: return sContentAccessModifier; default: return -1; // invalid modifier } } static PRBool IsAccessKeyTarget(nsIContent* aContent, nsIFrame* aFrame, nsAString& aKey) { if (!aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::accesskey, aKey, eIgnoreCase)) return PR_FALSE; nsCOMPtr xulDoc = do_QueryInterface(aContent->GetOwnerDoc()); if (!xulDoc && !aContent->IsNodeOfType(nsINode::eXUL)) return PR_TRUE; // For XUL we do visibility checks. if (!aFrame) return PR_FALSE; if (aFrame->IsFocusable()) return PR_TRUE; if (!aFrame->GetStyleVisibility()->IsVisible()) return PR_FALSE; if (!aFrame->AreAncestorViewsVisible()) return PR_FALSE; // XUL controls can be activated. nsCOMPtr control(do_QueryInterface(aContent)); if (control) return PR_TRUE; if (aContent->IsNodeOfType(nsINode::eHTML)) { nsIAtom* tag = aContent->Tag(); // HTML area, label and legend elements are never focusable, so // we need to check for them explicitly before giving up. if (tag == nsGkAtoms::area || tag == nsGkAtoms::label || tag == nsGkAtoms::legend) return PR_TRUE; } return PR_FALSE; } PRBool nsEventStateManager::ExecuteAccessKey(nsTArray& aAccessCharCodes, PRBool aIsTrustedEvent) { PRInt32 count, start = -1; nsIContent* focusedContent = GetFocusedContent(); if (focusedContent) { start = mAccessKeys.IndexOf(focusedContent); if (start == -1 && focusedContent->GetBindingParent()) start = mAccessKeys.IndexOf(focusedContent->GetBindingParent()); } nsIContent *content; nsIFrame *frame; PRInt32 length = mAccessKeys.Count(); for (PRUint32 i = 0; i < aAccessCharCodes.Length(); ++i) { PRUint32 ch = aAccessCharCodes[i]; nsAutoString accessKey; AppendUCS4ToUTF16(ch, accessKey); for (count = 1; count <= length; ++count) { content = mAccessKeys[(start + count) % length]; frame = mPresContext->PresShell()->GetPrimaryFrameFor(content); if (IsAccessKeyTarget(content, frame, accessKey)) { PRBool shouldActivate = sKeyCausesActivation; while (shouldActivate && ++count <= length) { nsIContent *oc = mAccessKeys[(start + count) % length]; nsIFrame *of = mPresContext->PresShell()->GetPrimaryFrameFor(oc); if (IsAccessKeyTarget(oc, of, accessKey)) shouldActivate = PR_FALSE; } if (shouldActivate) content->PerformAccesskey(shouldActivate, aIsTrustedEvent); else { nsIFocusManager* fm = nsFocusManager::GetFocusManager(); if (fm) { nsCOMPtr element = do_QueryInterface(content); fm->SetFocus(element, nsIFocusManager::FLAG_BYKEY); } } return PR_TRUE; } } } return PR_FALSE; } void nsEventStateManager::HandleAccessKey(nsPresContext* aPresContext, nsKeyEvent *aEvent, nsEventStatus* aStatus, nsIDocShellTreeItem* aBubbledFrom, ProcessingAccessKeyState aAccessKeyState, PRInt32 aModifierMask) { nsCOMPtr pcContainer = aPresContext->GetContainer(); // Alt or other accesskey modifier is down, we may need to do an accesskey if (mAccessKeys.Count() > 0 && aModifierMask == GetAccessModifierMask(pcContainer)) { // Someone registered an accesskey. Find and activate it. PRBool isTrusted = NS_IS_TRUSTED_EVENT(aEvent); nsAutoTArray accessCharCodes; nsContentUtils::GetAccessKeyCandidates(aEvent, accessCharCodes); if (ExecuteAccessKey(accessCharCodes, isTrusted)) { *aStatus = nsEventStatus_eConsumeNoDefault; return; } } // after the local accesskey handling if (nsEventStatus_eConsumeNoDefault != *aStatus) { // checking all sub docshells nsCOMPtr docShell(do_QueryInterface(pcContainer)); if (!docShell) { NS_WARNING("no docShellTreeNode for presContext"); return; } PRInt32 childCount; docShell->GetChildCount(&childCount); for (PRInt32 counter = 0; counter < childCount; counter++) { // Not processing the child which bubbles up the handling nsCOMPtr subShellItem; docShell->GetChildAt(counter, getter_AddRefs(subShellItem)); if (aAccessKeyState == eAccessKeyProcessingUp && subShellItem == aBubbledFrom) continue; nsCOMPtr subDS = do_QueryInterface(subShellItem); if (subDS && IsShellVisible(subDS)) { nsCOMPtr subPS; subDS->GetPresShell(getter_AddRefs(subPS)); // Docshells need not have a presshell (eg. display:none // iframes, docshells in transition between documents, etc). if (!subPS) { // Oh, well. Just move on to the next child continue; } nsPresContext *subPC = subPS->GetPresContext(); nsEventStateManager* esm = static_cast(subPC->EventStateManager()); if (esm) esm->HandleAccessKey(subPC, aEvent, aStatus, nsnull, eAccessKeyProcessingDown, aModifierMask); if (nsEventStatus_eConsumeNoDefault == *aStatus) break; } } }// if end . checking all sub docshell ends here. // bubble up the process to the parent docshell if necessary if (eAccessKeyProcessingDown != aAccessKeyState && nsEventStatus_eConsumeNoDefault != *aStatus) { nsCOMPtr docShell(do_QueryInterface(pcContainer)); if (!docShell) { NS_WARNING("no docShellTreeItem for presContext"); return; } nsCOMPtr parentShellItem; docShell->GetParent(getter_AddRefs(parentShellItem)); nsCOMPtr parentDS = do_QueryInterface(parentShellItem); if (parentDS) { nsCOMPtr parentPS; parentDS->GetPresShell(getter_AddRefs(parentPS)); NS_ASSERTION(parentPS, "Our PresShell exists but the parent's does not?"); nsPresContext *parentPC = parentPS->GetPresContext(); NS_ASSERTION(parentPC, "PresShell without PresContext"); nsEventStateManager* esm = static_cast(parentPC->EventStateManager()); if (esm) esm->HandleAccessKey(parentPC, aEvent, aStatus, docShell, eAccessKeyProcessingUp, aModifierMask); } }// if end. bubble up process }// end of HandleAccessKey #ifdef CLICK_HOLD_CONTEXT_MENUS // // CreateClickHoldTimer // // Fire off a timer for determining if the user wants click-hold. This timer // is a one-shot that will be cancelled when the user moves enough to fire // a drag. // void nsEventStateManager::CreateClickHoldTimer(nsPresContext* inPresContext, nsIFrame* inDownFrame, nsGUIEvent* inMouseDownEvent) { if (!NS_IS_TRUSTED_EVENT(inMouseDownEvent)) return; // just to be anal (er, safe) if (mClickHoldTimer) { mClickHoldTimer->Cancel(); mClickHoldTimer = nsnull; } // if content clicked on has a popup, don't even start the timer // since we'll end up conflicting and both will show. if (mGestureDownContent) { // check for the |popup| attribute if (nsContentUtils::HasNonEmptyAttr(mGestureDownContent, kNameSpaceID_None, nsGkAtoms::popup)) return; // check for a like bookmarks if (mGestureDownContent->Tag() == nsGkAtoms::menubutton) return; } mClickHoldTimer = do_CreateInstance("@mozilla.org/timer;1"); if ( mClickHoldTimer ) mClickHoldTimer->InitWithFuncCallback(sClickHoldCallback, this, kClickHoldDelay, nsITimer::TYPE_ONE_SHOT); } // CreateClickHoldTimer // // KillClickHoldTimer // // Stop the timer that would show the context menu dead in its tracks // void nsEventStateManager::KillClickHoldTimer() { if (mClickHoldTimer) { mClickHoldTimer->Cancel(); mClickHoldTimer = nsnull; } } // // sClickHoldCallback // // This fires after the mouse has been down for a certain length of time. // void nsEventStateManager::sClickHoldCallback(nsITimer *aTimer, void* aESM) { nsEventStateManager* self = static_cast(aESM); if ( self ) self->FireContextClick(); // NOTE: |aTimer| and |self->mAutoHideTimer| are invalid after calling ClosePopup(); } // sAutoHideCallback // // FireContextClick // // If we're this far, our timer has fired, which means the mouse has been down // for a certain period of time and has not moved enough to generate a dragGesture. // We can be certain the user wants a context-click at this stage, so generate // a dom event and fire it in. // // After the event fires, check if PreventDefault() has been set on the event which // means that someone either ate the event or put up a context menu. This is our cue // to stop tracking the drag gesture. If we always did this, draggable items w/out // a context menu wouldn't be draggable after a certain length of time, which is // _not_ what we want. // void nsEventStateManager::FireContextClick() { if ( !mGestureDownContent ) return; #ifdef XP_MACOSX // hacky OS call to ensure that we don't show a context menu when the user // let go of the mouse already, after a long, cpu-hogging operation prevented // us from handling any OS events. See bug 117589. if (!::StillDown()) return; #endif nsEventStatus status = nsEventStatus_eIgnore; // Dispatch to the DOM. We have to fake out the ESM and tell it that the // current target frame is actually where the mouseDown occurred, otherwise it // will use the frame the mouse is currently over which may or may not be // the same. (Note: saari and I have decided that we don't have to reset |mCurrentTarget| // when we're through because no one else is doing anything more with this // event and it will get reset on the very next event to the correct frame). mCurrentTarget = nsnull; nsIPresShell *shell = mPresContext->GetPresShell(); if ( shell ) { mCurrentTarget = shell->GetPrimaryFrameFor(mGestureDownFrameOwner); if ( mCurrentTarget ) { NS_ASSERTION(mPresContext == mCurrentTarget->PresContext(), "a prescontext returned a primary frame that didn't belong to it?"); // before dispatching, check that we're not on something that // doesn't get a context menu nsIAtom *tag = mGestureDownContent->Tag(); PRBool allowedToDispatch = PR_TRUE; if (mGestureDownContent->IsNodeOfType(nsINode::eXUL)) { if (tag == nsGkAtoms::scrollbar || tag == nsGkAtoms::scrollbarbutton || tag == nsGkAtoms::button) allowedToDispatch = PR_FALSE; else if (tag == nsGkAtoms::toolbarbutton) { // a that has the container attribute set // will already have its own dropdown. if (nsContentUtils::HasNonEmptyAttr(mGestureDownContent, kNameSpaceID_None, nsGkAtoms::container)) { allowedToDispatch = PR_FALSE; } else { // If the toolbar button has an open menu, don't attempt to open // a second menu if (mGestureDownContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open, nsGkAtoms::_true, eCaseMatters)) { allowedToDispatch = PR_FALSE; } } } } else if (mGestureDownContent->IsNodeOfType(nsINode::eHTML)) { nsCOMPtr formCtrl(do_QueryInterface(mGestureDownContent)); if (formCtrl) { // of all form controls, only ones dealing with text are // allowed to have context menus PRInt32 type = formCtrl->GetType(); allowedToDispatch = (type == NS_FORM_INPUT_TEXT || type == NS_FORM_INPUT_PASSWORD || type == NS_FORM_INPUT_FILE || type == NS_FORM_TEXTAREA); } else if (tag == nsGkAtoms::applet || tag == nsGkAtoms::embed || tag == nsGkAtoms::object) { allowedToDispatch = PR_FALSE; } } if (allowedToDispatch) { // make sure the widget sticks around nsCOMPtr targetWidget(mCurrentTarget->GetWindow()); // init the event while mCurrentTarget is still good nsMouseEvent event(PR_TRUE, NS_CONTEXTMENU, targetWidget, nsMouseEvent::eReal); event.clickCount = 1; FillInEventFromGestureDown(&event); // stop selection tracking, we're in control now if (mCurrentTarget) { nsCOMPtr frameSel = mCurrentTarget->GetFrameSelection(); if (frameSel && frameSel->GetMouseDownState()) { // note that this can cause selection changed events to fire if we're in // a text field, which will null out mCurrentTarget frameSel->SetMouseDownState(PR_FALSE); } } // dispatch to DOM nsEventDispatcher::Dispatch(mGestureDownContent, mPresContext, &event, nsnull, &status); // We don't need to dispatch to frame handling because no frames // watch NS_CONTEXTMENU except for nsMenuFrame and that's only for // dismissal. That's just as well since we don't really know // which frame to send it to. } } } // now check if the event has been handled. If so, stop tracking a drag if ( status == nsEventStatus_eConsumeNoDefault ) { StopTrackingDragGesture(); } KillClickHoldTimer(); } // FireContextClick #endif // // BeginTrackingDragGesture // // Record that the mouse has gone down and that we should move to TRACKING state // of d&d gesture tracker. // // We also use this to track click-hold context menus on mac. When the mouse goes down, // fire off a short timer. If the timer goes off and we have yet to fire the // drag gesture (ie, the mouse hasn't moved a certain distance), then we can // assume the user wants a click-hold, so fire a context-click event. We only // want to cancel the drag gesture if the context-click event is handled. // void nsEventStateManager::BeginTrackingDragGesture(nsPresContext* aPresContext, nsMouseEvent* inDownEvent, nsIFrame* inDownFrame) { // Note that |inDownEvent| could be either a mouse down event or a // synthesized mouse move event. mGestureDownPoint = inDownEvent->refPoint + inDownEvent->widget->WidgetToScreenOffset(); inDownFrame->GetContentForEvent(aPresContext, inDownEvent, getter_AddRefs(mGestureDownContent)); mGestureDownFrameOwner = inDownFrame->GetContent(); mGestureDownShift = inDownEvent->isShift; mGestureDownControl = inDownEvent->isControl; mGestureDownAlt = inDownEvent->isAlt; mGestureDownMeta = inDownEvent->isMeta; #ifdef CLICK_HOLD_CONTEXT_MENUS // fire off a timer to track click-hold if (nsContentUtils::GetBoolPref("ui.click_hold_context_menus", PR_TRUE)) CreateClickHoldTimer ( aPresContext, inDownFrame, inDownEvent ); #endif } // // StopTrackingDragGesture // // Record that the mouse has gone back up so that we should leave the TRACKING // state of d&d gesture tracker and return to the START state. // void nsEventStateManager::StopTrackingDragGesture() { mGestureDownContent = nsnull; mGestureDownFrameOwner = nsnull; } void nsEventStateManager::FillInEventFromGestureDown(nsMouseEvent* aEvent) { NS_ASSERTION(aEvent->widget == mCurrentTarget->GetWindow(), "Incorrect widget in event"); // Set the coordinates in the new event to the coordinates of // the old event, adjusted for the fact that the widget might be // different nsIntPoint tmpPoint = aEvent->widget->WidgetToScreenOffset(); aEvent->refPoint = mGestureDownPoint - tmpPoint; aEvent->isShift = mGestureDownShift; aEvent->isControl = mGestureDownControl; aEvent->isAlt = mGestureDownAlt; aEvent->isMeta = mGestureDownMeta; } // // GenerateDragGesture // // If we're in the TRACKING state of the d&d gesture tracker, check the current position // of the mouse in relation to the old one. If we've moved a sufficient amount from // the mouse down, then fire off a drag gesture event. // // Note that when the mouse enters a new child window with its own view, the event's // coordinates will be in relation to the origin of the inner child window, which could // either be very different from that of the mouse coords of the mouse down and trigger // a drag too early, or very similar which might not trigger a drag. // // Do we need to do anything about this? Let's wait and see. // void nsEventStateManager::GenerateDragGesture(nsPresContext* aPresContext, nsMouseEvent *aEvent) { NS_ASSERTION(aPresContext, "This shouldn't happen."); if ( IsTrackingDragGesture() ) { mCurrentTarget = aPresContext->GetPresShell()->GetPrimaryFrameFor(mGestureDownFrameOwner); if (!mCurrentTarget) { StopTrackingDragGesture(); return; } // Check if selection is tracking drag gestures, if so // don't interfere! if (mCurrentTarget) { nsCOMPtr frameSel = mCurrentTarget->GetFrameSelection(); if (frameSel && frameSel->GetMouseDownState()) { StopTrackingDragGesture(); return; } } static PRInt32 pixelThresholdX = 0; static PRInt32 pixelThresholdY = 0; if (!pixelThresholdX) { nsILookAndFeel *lf = aPresContext->LookAndFeel(); lf->GetMetric(nsILookAndFeel::eMetric_DragThresholdX, pixelThresholdX); lf->GetMetric(nsILookAndFeel::eMetric_DragThresholdY, pixelThresholdY); if (!pixelThresholdX) pixelThresholdX = 5; if (!pixelThresholdY) pixelThresholdY = 5; } // fire drag gesture if mouse has moved enough nsIntPoint pt = aEvent->refPoint + aEvent->widget->WidgetToScreenOffset(); if (PR_ABS(pt.x - mGestureDownPoint.x) > pixelThresholdX || PR_ABS(pt.y - mGestureDownPoint.y) > pixelThresholdY) { #ifdef CLICK_HOLD_CONTEXT_MENUS // stop the click-hold before we fire off the drag gesture, in case // it takes a long time KillClickHoldTimer(); #endif nsRefPtr dataTransfer = new nsDOMDataTransfer(); if (!dataTransfer) return; PRBool isInEditor = PR_FALSE; PRBool isSelection = PR_FALSE; nsCOMPtr eventContent, targetContent; mCurrentTarget->GetContentForEvent(aPresContext, aEvent, getter_AddRefs(eventContent)); if (eventContent) DetermineDragTarget(aPresContext, eventContent, dataTransfer, &isSelection, &isInEditor, getter_AddRefs(targetContent)); // Stop tracking the drag gesture now. This should stop us from // reentering GenerateDragGesture inside DOM event processing. StopTrackingDragGesture(); if (!targetContent) return; nsCOMPtr widget = mCurrentTarget->GetWindow(); // get the widget from the target frame nsDragEvent startEvent(NS_IS_TRUSTED_EVENT(aEvent), NS_DRAGDROP_START, widget); FillInEventFromGestureDown(&startEvent); nsDragEvent gestureEvent(NS_IS_TRUSTED_EVENT(aEvent), NS_DRAGDROP_GESTURE, widget); FillInEventFromGestureDown(&gestureEvent); startEvent.dataTransfer = gestureEvent.dataTransfer = dataTransfer; // Dispatch to the DOM. By setting mCurrentTarget we are faking // out the ESM and telling it that the current target frame is // actually where the mouseDown occurred, otherwise it will use // the frame the mouse is currently over which may or may not be // the same. (Note: saari and I have decided that we don't have // to reset |mCurrentTarget| when we're through because no one // else is doing anything more with this event and it will get // reset on the very next event to the correct frame). // Hold onto old target content through the event and reset after. nsCOMPtr targetBeforeEvent = mCurrentTargetContent; // Set the current target to the content for the mouse down mCurrentTargetContent = targetContent; // Dispatch both the dragstart and draggesture events to the DOM. For // elements in an editor, only fire the draggesture event so that the // editor code can handle it but content doesn't see a dragstart. nsEventStatus status = nsEventStatus_eIgnore; if (!isInEditor) nsEventDispatcher::Dispatch(targetContent, aPresContext, &startEvent, nsnull, &status); nsDragEvent* event = &startEvent; if (status != nsEventStatus_eConsumeNoDefault) { status = nsEventStatus_eIgnore; nsEventDispatcher::Dispatch(targetContent, aPresContext, &gestureEvent, nsnull, &status); event = &gestureEvent; } // now that the dataTransfer has been updated in the dragstart and // draggesture events, make it read only so that the data doesn't // change during the drag. dataTransfer->SetReadOnly(); if (status != nsEventStatus_eConsumeNoDefault) DoDefaultDragStart(aPresContext, event, dataTransfer, targetContent, isSelection); // Note that frame event handling doesn't care about NS_DRAGDROP_GESTURE, // which is just as well since we don't really know which frame to // send it to // Reset mCurretTargetContent to what it was mCurrentTargetContent = targetBeforeEvent; } // Now flush all pending notifications, for better responsiveness // while dragging. FlushPendingEvents(aPresContext); } } // GenerateDragGesture void nsEventStateManager::DetermineDragTarget(nsPresContext* aPresContext, nsIContent* aSelectionTarget, nsDOMDataTransfer* aDataTransfer, PRBool* aIsSelection, PRBool* aIsInEditor, nsIContent** aTargetNode) { *aTargetNode = nsnull; *aIsInEditor = PR_FALSE; nsCOMPtr container = aPresContext->GetContainer(); nsCOMPtr window = do_GetInterface(container); // GetDragData determines if a selection, link or image in the content // should be dragged, and places the data associated with the drag in the // data transfer. Skip this check for chrome shells. PRBool canDrag; nsCOMPtr dragDataNode; nsCOMPtr dsti = do_QueryInterface(container); if (dsti) { PRInt32 type = -1; if (NS_SUCCEEDED(dsti->GetItemType(&type)) && type != nsIDocShellTreeItem::typeChrome) { // mGestureDownContent is the node where the mousedown event for the drag // occured, and aSelectionTarget is the node to use when a selection is used nsresult rv = nsContentAreaDragDrop::GetDragData(window, mGestureDownContent, aSelectionTarget, mGestureDownAlt, aDataTransfer, &canDrag, aIsSelection, getter_AddRefs(dragDataNode)); if (NS_FAILED(rv) || !canDrag) return; } } // if GetDragData returned a node, use that as the node being dragged. // Otherwise, if a selection is being dragged, use the node within the // selection that was dragged. Otherwise, just use the mousedown target. nsIContent* dragContent = mGestureDownContent; if (dragDataNode) dragContent = dragDataNode; else if (*aIsSelection) dragContent = aSelectionTarget; nsIContent* originalDragContent = dragContent; // If a selection isn't being dragged, look for an ancestor with the // draggable property set. If one is found, use that as the target of the // drag instead of the node that was clicked on. If a draggable node wasn't // found, just use the clicked node. if (!*aIsSelection) { while (dragContent) { nsCOMPtr htmlElement = do_QueryInterface(dragContent); if (htmlElement) { PRBool draggable = PR_FALSE; htmlElement->GetDraggable(&draggable); if (draggable) break; } else { nsCOMPtr xulElement = do_QueryInterface(dragContent); if (xulElement) { // All XUL elements are draggable, so if a XUL element is // encountered, stop looking for draggable nodes and just use the // original clicked node instead. // XXXndeakin // In the future, we will want to improve this so that XUL has a // better way to specify whether something is draggable than just // on/off. dragContent = mGestureDownContent; break; } // otherwise, it's not an HTML or XUL element, so just keep looking } dragContent = dragContent->GetParent(); // if an editable parent is encountered, then we don't look at any // ancestors. This is used because the editor attaches a draggesture // listener to the editable element and we want to call it without // making the editable element draggable. This should be removed once // the editor is switched over to using the proper drag and drop api. nsCOMPtr editableElement = do_QueryInterface(dragContent); if (editableElement) { *aIsInEditor = PR_TRUE; break; } } } // if no node in the hierarchy was found to drag, but the GetDragData method // returned a node, use that returned node. Otherwise, nothing is draggable. if (!dragContent && dragDataNode) dragContent = dragDataNode; if (dragContent) { // if an ancestor node was used instead, clear the drag data // XXXndeakin rework this a bit. Find a way to just not call GetDragData if we don't need to. if (dragContent != originalDragContent) aDataTransfer->ClearAll(); *aTargetNode = dragContent; NS_ADDREF(*aTargetNode); } } void nsEventStateManager::DoDefaultDragStart(nsPresContext* aPresContext, nsDragEvent* aDragEvent, nsDOMDataTransfer* aDataTransfer, nsIContent* aDragTarget, PRBool aIsSelection) { nsCOMPtr dragService = do_GetService("@mozilla.org/widget/dragservice;1"); if (!dragService) return; // Default handling for the draggesture/dragstart event. // // First, check if a drag session already exists. This means that the drag // service was called directly within a draggesture handler. In this case, // don't do anything more, as it is assumed that the handler is managing // drag and drop manually. nsCOMPtr dragSession; dragService->GetCurrentSession(getter_AddRefs(dragSession)); if (dragSession) return; // already a drag in progress // No drag session is currently active, so check if a handler added // any items to be dragged. If not, there isn't anything to drag. PRUint32 count = 0; if (aDataTransfer) aDataTransfer->GetMozItemCount(&count); if (!count) return; // Get the target being dragged, which may not be the same as the // target of the mouse event. If one wasn't set in the // aDataTransfer during the event handler, just use the original // target instead. nsCOMPtr dragTarget; nsCOMPtr dragTargetElement; aDataTransfer->GetDragTarget(getter_AddRefs(dragTargetElement)); dragTarget = do_QueryInterface(dragTargetElement); if (!dragTarget) { dragTarget = do_QueryInterface(aDragTarget); if (!dragTarget) return; } // check which drag effect should initially be used. If the effect was not // set, just use all actions, otherwise Windows won't allow a drop. PRUint32 action; aDataTransfer->GetEffectAllowedInt(&action); if (action == nsIDragService::DRAGDROP_ACTION_UNINITIALIZED) action = nsIDragService::DRAGDROP_ACTION_COPY | nsIDragService::DRAGDROP_ACTION_MOVE | nsIDragService::DRAGDROP_ACTION_LINK; // get any custom drag image that was set PRInt32 imageX, imageY; nsIDOMElement* dragImage = aDataTransfer->GetDragImage(&imageX, &imageY); // If a selection is being dragged, and no custom drag image was // set, get the selection so that the drag region can be created // from the selection area. If a custom image was set, it doesn't // matter what the selection is since the image will be used instead. nsISelection* selection = nsnull; if (aIsSelection && !dragImage) { nsIDocument* doc = aDragTarget->GetCurrentDoc(); if (doc) { nsIPresShell* presShell = doc->GetPrimaryShell(); if (presShell) { selection = presShell->GetCurrentSelection( nsISelectionController::SELECTION_NORMAL); } } } nsCOMPtr transArray; aDataTransfer->GetTransferables(getter_AddRefs(transArray)); if (!transArray) return; // XXXndeakin don't really want to create a new drag DOM event // here, but we need something to pass to the InvokeDragSession // methods. nsCOMPtr domEvent; NS_NewDOMDragEvent(getter_AddRefs(domEvent), aPresContext, aDragEvent); nsCOMPtr domDragEvent = do_QueryInterface(domEvent); // if creating a drag event failed, starting a drag session will // just fail. if (selection) { dragService->InvokeDragSessionWithSelection(selection, transArray, action, domDragEvent, aDataTransfer); } else { // if dragging within a XUL tree and no custom drag image was // set, the region argument to InvokeDragSessionWithImage needs // to be set to the area encompassing the selected rows of the // tree to ensure that the drag feedback gets clipped to those // rows. For other content, region should be null. nsCOMPtr region; #ifdef MOZ_XUL if (dragTarget && !dragImage) { nsCOMPtr content = do_QueryInterface(dragTarget); if (content->NodeInfo()->Equals(nsGkAtoms::treechildren, kNameSpaceID_XUL)) { nsIDocument* doc = content->GetCurrentDoc(); if (doc) { nsIPresShell* presShell = doc->GetPrimaryShell(); if (presShell) { nsIFrame* frame = presShell->GetPrimaryFrameFor(content); if (frame) { nsTreeBodyFrame* treeBody = do_QueryFrame(frame); treeBody->GetSelectionRegion(getter_AddRefs(region)); } } } } } #endif dragService->InvokeDragSessionWithImage(dragTarget, transArray, region, action, dragImage, imageX, imageY, domDragEvent, aDataTransfer); } } nsresult nsEventStateManager::GetMarkupDocumentViewer(nsIMarkupDocumentViewer** aMv) { *aMv = nsnull; nsIFocusManager* fm = nsFocusManager::GetFocusManager(); if(!fm) return NS_ERROR_FAILURE; nsCOMPtr focusedWindow; fm->GetFocusedWindow(getter_AddRefs(focusedWindow)); nsCOMPtr ourWindow = do_QueryInterface(focusedWindow); if(!ourWindow) return NS_ERROR_FAILURE; nsIDOMWindowInternal *rootWindow = ourWindow->GetPrivateRoot(); if(!rootWindow) return NS_ERROR_FAILURE; nsCOMPtr contentWindow; rootWindow->GetContent(getter_AddRefs(contentWindow)); if(!contentWindow) return NS_ERROR_FAILURE; nsIDocument *doc = GetDocumentFromWindow(contentWindow); if(!doc) return NS_ERROR_FAILURE; nsIPresShell *presShell = doc->GetPrimaryShell(); if(!presShell) return NS_ERROR_FAILURE; nsPresContext *presContext = presShell->GetPresContext(); if(!presContext) return NS_ERROR_FAILURE; nsCOMPtr pcContainer = presContext->GetContainer(); if(!pcContainer) return NS_ERROR_FAILURE; nsCOMPtr docshell(do_QueryInterface(pcContainer)); if(!docshell) return NS_ERROR_FAILURE; nsCOMPtr cv; docshell->GetContentViewer(getter_AddRefs(cv)); if(!cv) return NS_ERROR_FAILURE; nsCOMPtr mv(do_QueryInterface(cv)); if(!mv) return NS_ERROR_FAILURE; *aMv = mv; NS_IF_ADDREF(*aMv); return NS_OK; } nsresult nsEventStateManager::ChangeTextSize(PRInt32 change) { nsCOMPtr mv; nsresult rv = GetMarkupDocumentViewer(getter_AddRefs(mv)); NS_ENSURE_SUCCESS(rv, rv); float textzoom; float zoomMin = ((float)nsContentUtils::GetIntPref("zoom.minPercent", 50)) / 100; float zoomMax = ((float)nsContentUtils::GetIntPref("zoom.maxPercent", 300)) / 100; mv->GetTextZoom(&textzoom); textzoom += ((float)change) / 10; if (textzoom < zoomMin) textzoom = zoomMin; else if (textzoom > zoomMax) textzoom = zoomMax; mv->SetTextZoom(textzoom); return NS_OK; } nsresult nsEventStateManager::ChangeFullZoom(PRInt32 change) { nsCOMPtr mv; nsresult rv = GetMarkupDocumentViewer(getter_AddRefs(mv)); NS_ENSURE_SUCCESS(rv, rv); float fullzoom; float zoomMin = ((float)nsContentUtils::GetIntPref("zoom.minPercent", 50)) / 100; float zoomMax = ((float)nsContentUtils::GetIntPref("zoom.maxPercent", 300)) / 100; mv->GetFullZoom(&fullzoom); fullzoom += ((float)change) / 10; if (fullzoom < zoomMin) fullzoom = zoomMin; else if (fullzoom > zoomMax) fullzoom = zoomMax; mv->SetFullZoom(fullzoom); return NS_OK; } void nsEventStateManager::DoScrollHistory(PRInt32 direction) { nsCOMPtr pcContainer(mPresContext->GetContainer()); if (pcContainer) { nsCOMPtr webNav(do_QueryInterface(pcContainer)); if (webNav) { // positive direction to go back one step, nonpositive to go forward if (direction > 0) webNav->GoBack(); else webNav->GoForward(); } } } void nsEventStateManager::DoScrollZoom(nsIFrame *aTargetFrame, PRInt32 adjustment) { // Exclude form controls and XUL content. nsIContent *content = aTargetFrame->GetContent(); if (content && !content->IsNodeOfType(nsINode::eHTML_FORM_CONTROL) && !content->IsNodeOfType(nsINode::eXUL)) { // positive adjustment to decrease zoom, negative to increase PRInt32 change = (adjustment > 0) ? -1 : 1; if (nsContentUtils::GetBoolPref("browser.zoom.full")) ChangeFullZoom(change); else ChangeTextSize(change); } } static nsIFrame* GetParentFrameToScroll(nsPresContext* aPresContext, nsIFrame* aFrame) { if (!aPresContext || !aFrame) return nsnull; if (aFrame->GetStyleDisplay()->mPosition == NS_STYLE_POSITION_FIXED && nsLayoutUtils::IsReallyFixedPos(aFrame)) return aPresContext->GetPresShell()->GetRootScrollFrame(); return aFrame->GetParent(); } static nsIScrollableView* GetScrollableViewForFrame(nsPresContext* aPresContext, nsIFrame* aFrame) { for (; aFrame; aFrame = GetParentFrameToScroll(aPresContext, aFrame)) { nsIScrollableViewProvider* svp = do_QueryFrame(aFrame); if (svp) { nsIScrollableView* scrollView = svp->GetScrollableView(); if (scrollView) return scrollView; } } return nsnull; } static nscoord GetScrollableViewLineHeight(nsPresContext* aPresContext, nsIFrame* aTargetFrame) { nsIScrollableView* scrollView = GetScrollableViewForFrame(aPresContext, aTargetFrame); nscoord lineHeight = 0; if (scrollView) { scrollView->GetLineHeight(&lineHeight); } else { // Fall back to the font height of the target frame. const nsStyleFont* font = aTargetFrame->GetStyleFont(); const nsFont& f = font->mFont; nsCOMPtr fm = aPresContext->GetMetricsFor(f); NS_ASSERTION(fm, "FontMetrics is null!"); if (fm) fm->GetHeight(lineHeight); } return lineHeight; } void nsEventStateManager::SendLineScrollEvent(nsIFrame* aTargetFrame, nsMouseScrollEvent* aEvent, nsPresContext* aPresContext, nsEventStatus* aStatus, PRInt32 aNumLines) { nsCOMPtr targetContent = aTargetFrame->GetContent(); if (!targetContent) targetContent = GetFocusedContent(); if (!targetContent) return; while (targetContent->IsNodeOfType(nsINode::eTEXT)) { targetContent = targetContent->GetParent(); } PRBool isTrusted = (aEvent->flags & NS_EVENT_FLAG_TRUSTED) != 0; nsMouseScrollEvent event(isTrusted, NS_MOUSE_SCROLL, nsnull); event.refPoint = aEvent->refPoint; event.widget = aEvent->widget; event.time = aEvent->time; event.isShift = aEvent->isShift; event.isControl = aEvent->isControl; event.isAlt = aEvent->isAlt; event.isMeta = aEvent->isMeta; event.scrollFlags = aEvent->scrollFlags; event.delta = aNumLines; nsEventDispatcher::Dispatch(targetContent, aPresContext, &event, nsnull, aStatus); } void nsEventStateManager::SendPixelScrollEvent(nsIFrame* aTargetFrame, nsMouseScrollEvent* aEvent, nsPresContext* aPresContext, nsEventStatus* aStatus) { nsCOMPtr targetContent = aTargetFrame->GetContent(); if (!targetContent) { targetContent = GetFocusedContent(); if (!targetContent) return; } while (targetContent->IsNodeOfType(nsINode::eTEXT)) { targetContent = targetContent->GetParent(); } nscoord lineHeight = GetScrollableViewLineHeight(aPresContext, aTargetFrame); PRBool isTrusted = (aEvent->flags & NS_EVENT_FLAG_TRUSTED) != 0; nsMouseScrollEvent event(isTrusted, NS_MOUSE_PIXEL_SCROLL, nsnull); event.refPoint = aEvent->refPoint; event.widget = aEvent->widget; event.time = aEvent->time; event.isShift = aEvent->isShift; event.isControl = aEvent->isControl; event.isAlt = aEvent->isAlt; event.isMeta = aEvent->isMeta; event.scrollFlags = aEvent->scrollFlags; event.delta = aPresContext->AppUnitsToIntCSSPixels(aEvent->delta * lineHeight); nsEventDispatcher::Dispatch(targetContent, aPresContext, &event, nsnull, aStatus); } nsresult nsEventStateManager::DoScrollText(nsPresContext* aPresContext, nsIFrame* aTargetFrame, nsMouseScrollEvent* aMouseEvent, ScrollQuantity aScrollQuantity) { nsIScrollableView* scrollView = nsnull; nsIFrame* scrollFrame = aTargetFrame; PRInt32 numLines = aMouseEvent->delta; PRBool isHorizontal = aMouseEvent->scrollFlags & nsMouseScrollEvent::kIsHorizontal; aMouseEvent->scrollOverflow = 0; // If the user recently scrolled with the mousewheel, then they probably want // to scroll the same view as before instead of the view under the cursor. // nsMouseWheelTransaction tracks the frame currently being scrolled with the // mousewheel. We consider the transaction ended when the mouse moves more than // "mousewheel.transaction.ignoremovedelay" milliseconds after the last scroll // operation, or any time the mouse moves out of the frame, or when more than // "mousewheel.transaction.timeout" milliseconds have passed after the last // operation, even if the mouse hasn't moved. nsIFrame* lastScrollFrame = nsMouseWheelTransaction::GetTargetFrame(); if (lastScrollFrame) { nsIScrollableViewProvider* svp = do_QueryFrame(lastScrollFrame); if (svp && (scrollView = svp->GetScrollableView())) { nsMouseWheelTransaction::UpdateTransaction(numLines, isHorizontal); // When the scroll event will not scroll any views, UpdateTransaction // fired MozMouseScrollFailed event which is for automated testing. // In the event handler, the target frame might be destroyed. Then, // we should not keep handling this scroll event. if (!nsMouseWheelTransaction::GetTargetFrame()) return NS_OK; } else { nsMouseWheelTransaction::EndTransaction(); lastScrollFrame = nsnull; } } PRBool passToParent = lastScrollFrame ? PR_FALSE : PR_TRUE; for (; scrollFrame && passToParent; scrollFrame = GetParentFrameToScroll(aPresContext, scrollFrame)) { // Check whether the frame wants to provide us with a scrollable view. scrollView = nsnull; nsIScrollableViewProvider* svp = do_QueryFrame(scrollFrame); if (svp) { scrollView = svp->GetScrollableView(); } if (!scrollView) { continue; } nsPresContext::ScrollbarStyles ss = nsLayoutUtils::ScrollbarStylesOfView(scrollView); if (NS_STYLE_OVERFLOW_HIDDEN == (isHorizontal ? ss.mHorizontal : ss.mVertical)) { continue; } // Check if the scrollable view can be scrolled any further. nscoord lineHeight; scrollView->GetLineHeight(&lineHeight); if (lineHeight != 0) { if (CanScrollOn(scrollView, numLines, isHorizontal)) { passToParent = PR_FALSE; nsMouseWheelTransaction::BeginTransaction(scrollFrame, numLines, isHorizontal); } // Comboboxes need special care. nsIComboboxControlFrame* comboBox = do_QueryFrame(scrollFrame); if (comboBox) { if (comboBox->IsDroppedDown()) { // Don't propagate to parent when drop down menu is active. if (passToParent) { passToParent = PR_FALSE; scrollView = nsnull; nsMouseWheelTransaction::EndTransaction(); } } else { // Always propagate when not dropped down (even if focused). if (!passToParent) { passToParent = PR_TRUE; nsMouseWheelTransaction::EndTransaction(); } } } } } if (!passToParent && scrollView) { if (aScrollQuantity == eScrollByLine) { // Limit scrolling to be at most one page, but if possible, try to // just adjust the number of scrolled lines. nscoord lineHeight = 0; scrollView->GetLineHeight(&lineHeight); if (lineHeight) { nsSize pageScrollDistances(0, 0); scrollView->GetPageScrollDistances(&pageScrollDistances); nscoord pageScroll = isHorizontal ? pageScrollDistances.width : pageScrollDistances.height; if (PR_ABS(numLines) * lineHeight > pageScroll) { nscoord maxLines = (pageScroll / lineHeight); if (maxLines >= 1) { numLines = ((numLines < 0) ? -1 : 1) * maxLines; } else { aScrollQuantity = eScrollByPage; } } } } PRInt32 scrollX = 0; PRInt32 scrollY = numLines; if (aScrollQuantity == eScrollByPage) scrollY = (scrollY > 0) ? 1 : -1; if (isHorizontal) { scrollX = scrollY; scrollY = 0; } PRBool noDefer = aMouseEvent->scrollFlags & nsMouseScrollEvent::kNoDefer; PRInt32 overflowX = 0, overflowY = 0; if (aScrollQuantity == eScrollByPage) { scrollView->ScrollByPages(scrollX, scrollY, (noDefer ? NS_VMREFRESH_IMMEDIATE : NS_VMREFRESH_SMOOTHSCROLL)); } else if (aScrollQuantity == eScrollByPixel) { scrollView->ScrollByPixels(scrollX, scrollY, overflowX, overflowY, (noDefer ? NS_VMREFRESH_IMMEDIATE : NS_VMREFRESH_DEFERRED)); } else { scrollView->ScrollByLinesWithOverflow(scrollX, scrollY, overflowX, overflowY, (noDefer ? NS_VMREFRESH_IMMEDIATE : NS_VMREFRESH_SMOOTHSCROLL)); } if (isHorizontal) aMouseEvent->scrollOverflow = overflowX; else aMouseEvent->scrollOverflow = overflowY; return NS_OK; } if (passToParent) { nsresult rv; nsIFrame* newFrame = nsnull; nsCOMPtr newPresContext; rv = GetParentScrollingView(aMouseEvent, aPresContext, newFrame, *getter_AddRefs(newPresContext)); if (NS_SUCCEEDED(rv) && newFrame) return DoScrollText(newPresContext, newFrame, aMouseEvent, aScrollQuantity); } aMouseEvent->scrollOverflow = numLines; return NS_OK; } nsresult nsEventStateManager::GetParentScrollingView(nsInputEvent *aEvent, nsPresContext* aPresContext, nsIFrame* &targetOuterFrame, nsPresContext* &presCtxOuter) { targetOuterFrame = nsnull; if (!aEvent) return NS_ERROR_FAILURE; if (!aPresContext) return NS_ERROR_FAILURE; nsIDocument *doc = aPresContext->PresShell()->GetDocument(); NS_ASSERTION(doc, "No document in prescontext!"); nsIDocument *parentDoc = doc->GetParentDocument(); if (!parentDoc) { return NS_OK; } nsIPresShell *pPresShell = nsnull; nsPresShellIterator iter(parentDoc); nsCOMPtr tmpPresShell; while ((tmpPresShell = iter.GetNextShell())) { NS_ENSURE_TRUE(tmpPresShell->GetPresContext(), NS_ERROR_FAILURE); if (tmpPresShell->GetPresContext()->Type() == aPresContext->Type()) { pPresShell = tmpPresShell; break; } } if (!pPresShell) return NS_ERROR_FAILURE; /* now find the content node in our parent docshell's document that corresponds to our docshell */ nsIContent *frameContent = parentDoc->FindContentForSubDocument(doc); NS_ENSURE_TRUE(frameContent, NS_ERROR_FAILURE); /* get this content node's frame, and use it as the new event target, so the event can be processed in the parent docshell. Note that we don't actually need to translate the event coordinates because they are not used by DoScrollText(). */ nsIFrame* frameFrame = pPresShell->GetPrimaryFrameFor(frameContent); if (!frameFrame) return NS_ERROR_FAILURE; NS_IF_ADDREF(presCtxOuter = pPresShell->GetPresContext()); targetOuterFrame = frameFrame; return NS_OK; } NS_IMETHODIMP nsEventStateManager::PostHandleEvent(nsPresContext* aPresContext, nsEvent *aEvent, nsIFrame* aTargetFrame, nsEventStatus* aStatus, nsIView* aView) { NS_ENSURE_ARG(aPresContext); NS_ENSURE_ARG_POINTER(aStatus); mCurrentTarget = aTargetFrame; mCurrentTargetContent = nsnull; // Most of the events we handle below require a frame. // Add special cases here. if (!mCurrentTarget && aEvent->message != NS_MOUSE_BUTTON_UP) { return NS_OK; } //Keep the prescontext alive, we might need it after event dispatch nsRefPtr presContext = aPresContext; nsresult ret = NS_OK; switch (aEvent->message) { case NS_MOUSE_BUTTON_DOWN: { if (static_cast(aEvent)->button == nsMouseEvent::eLeftButton && !mNormalLMouseEventInProcess) { //Our state is out of whack. We got a mouseup while still processing //the mousedown. Kill View-level mouse capture or it'll stay stuck if (aView) { nsIViewManager* viewMan = aView->GetViewManager(); if (viewMan) { nsIView* grabbingView; viewMan->GetMouseEventGrabber(grabbingView); if (grabbingView == aView) { PRBool result; viewMan->GrabMouseEvents(nsnull, result); } } } break; } if (nsEventStatus_eConsumeNoDefault != *aStatus) { nsCOMPtr newFocus; nsIContent* activeContent = nsnull; PRBool suppressBlur = PR_FALSE; if (mCurrentTarget) { mCurrentTarget->GetContentForEvent(mPresContext, aEvent, getter_AddRefs(newFocus)); const nsStyleUserInterface* ui = mCurrentTarget->GetStyleUserInterface(); suppressBlur = (ui->mUserFocus == NS_STYLE_USER_FOCUS_IGNORE); activeContent = mCurrentTarget->GetContent(); } // When the mouse is pressed, the default action is to focus the // target. Look for the nearest enclosing focusable frame. nsIFrame* currFrame = mCurrentTarget; while (currFrame) { // If the mousedown happened inside a popup, don't // try to set focus on one of its containing elements const nsStyleDisplay* display = currFrame->GetStyleDisplay(); if (display->mDisplay == NS_STYLE_DISPLAY_POPUP) { newFocus = nsnull; break; } PRInt32 tabIndexUnused; if (currFrame->IsFocusable(&tabIndexUnused, PR_TRUE)) { newFocus = currFrame->GetContent(); nsCOMPtr domElement(do_QueryInterface(newFocus)); if (domElement) break; } currFrame = currFrame->GetParent(); } nsIFocusManager* fm = nsFocusManager::GetFocusManager(); if (fm) { // if something was found to focus, focus it. Otherwise, if the // element that was clicked doesn't have -moz-user-focus: ignore, // clear the existing focus. For -moz-user-focus: ignore, the focus // is just left as is. // Another effect of mouse clicking, handled in nsSelection, is that // it should update the caret position to where the mouse was // clicked. Because the focus is cleared when clicking on a // non-focusable node, the next press of the tab key will cause // focus to be shifted from the caret position instead of the root. if (newFocus && currFrame) { // use the mouse flag and the noscroll flag so that the content // doesn't unexpectedly scroll when clicking an element that is // only hald visible nsCOMPtr newFocusElement = do_QueryInterface(newFocus); fm->SetFocus(newFocusElement, nsIFocusManager::FLAG_BYMOUSE | nsIFocusManager::FLAG_NOSCROLL); } else if (!suppressBlur) { // clear the focus within the frame and then set it as the // focused frame EnsureDocument(mPresContext); if (mDocument) { fm->ClearFocus(mDocument->GetWindow()); fm->SetFocusedWindow(mDocument->GetWindow()); } } } // The rest is left button-specific. if (static_cast(aEvent)->button != nsMouseEvent::eLeftButton) break; if (activeContent) { // The nearest enclosing element goes into the // :active state. If we fail the QI to DOMElement, // then we know we're only a node, and that we need // to obtain our parent element and put it into :active // instead. nsCOMPtr elt(do_QueryInterface(activeContent)); if (!elt) { nsIContent* par = activeContent->GetParent(); if (par) activeContent = par; } SetContentState(activeContent, NS_EVENT_STATE_ACTIVE); } } else { // if we're here, the event handler returned false, so stop // any of our own processing of a drag. Workaround for bug 43258. StopTrackingDragGesture(); } } break; case NS_MOUSE_BUTTON_UP: { SetContentState(nsnull, NS_EVENT_STATE_ACTIVE); if (!mCurrentTarget) { nsIFrame* targ; GetEventTarget(&targ); } if (mCurrentTarget) { ret = CheckForAndDispatchClick(presContext, (nsMouseEvent*)aEvent, aStatus); } nsIPresShell *shell = presContext->GetPresShell(); if (shell) { nsIViewManager* viewMan = shell->GetViewManager(); if (viewMan) { nsIView* grabbingView = nsnull; viewMan->GetMouseEventGrabber(grabbingView); if (grabbingView == aView) { PRBool result; viewMan->GrabMouseEvents(nsnull, result); } } nsCOMPtr frameSelection = shell->FrameSelection(); frameSelection->SetMouseDownState(PR_FALSE); } } break; case NS_MOUSE_SCROLL: case NS_MOUSE_PIXEL_SCROLL: { nsMouseScrollEvent *msEvent = static_cast(aEvent); if (aEvent->message == NS_MOUSE_SCROLL) { // Mark the subsequent pixel scrolls as valid / invalid, based on the // observation if the previous line scroll has been canceled if (msEvent->scrollFlags & nsMouseScrollEvent::kIsHorizontal) { mLastLineScrollConsumedX = (nsEventStatus_eConsumeNoDefault == *aStatus); } else if (msEvent->scrollFlags & nsMouseScrollEvent::kIsVertical) { mLastLineScrollConsumedY = (nsEventStatus_eConsumeNoDefault == *aStatus); } if (!(msEvent->scrollFlags & nsMouseScrollEvent::kHasPixels)) { // No generated pixel scroll event will follow. // Create and send a pixel scroll DOM event now. nsWeakFrame weakFrame(aTargetFrame); SendPixelScrollEvent(aTargetFrame, msEvent, presContext, aStatus); NS_ENSURE_STATE(weakFrame.IsAlive()); } } if (*aStatus != nsEventStatus_eConsumeNoDefault) { // Build the preference keys, based on the event properties. NS_NAMED_LITERAL_CSTRING(actionslot, ".action"); NS_NAMED_LITERAL_CSTRING(sysnumlinesslot, ".sysnumlines"); nsCAutoString baseKey; GetBasePrefKeyForMouseWheel(msEvent, baseKey); // Extract the preferences nsCAutoString actionKey(baseKey); actionKey.Append(actionslot); nsCAutoString sysNumLinesKey(baseKey); sysNumLinesKey.Append(sysnumlinesslot); PRInt32 action = nsContentUtils::GetIntPref(actionKey.get()); PRBool useSysNumLines = nsContentUtils::GetBoolPref(sysNumLinesKey.get()); if (useSysNumLines) { if (msEvent->scrollFlags & nsMouseScrollEvent::kIsFullPage) action = MOUSE_SCROLL_PAGE; } if (aEvent->message == NS_MOUSE_PIXEL_SCROLL) { if (action == MOUSE_SCROLL_N_LINES) { action = MOUSE_SCROLL_PIXELS; } else { // Do not scroll pixels when zooming action = -1; } } else if (msEvent->scrollFlags & nsMouseScrollEvent::kHasPixels) { if (action == MOUSE_SCROLL_N_LINES) { // We shouldn't scroll lines when a pixel scroll event will follow. action = -1; } } switch (action) { case MOUSE_SCROLL_N_LINES: DoScrollText(presContext, aTargetFrame, msEvent, eScrollByLine); break; case MOUSE_SCROLL_PAGE: DoScrollText(presContext, aTargetFrame, msEvent, eScrollByPage); break; case MOUSE_SCROLL_PIXELS: DoScrollText(presContext, aTargetFrame, msEvent, eScrollByPixel); break; case MOUSE_SCROLL_HISTORY: DoScrollHistory(msEvent->delta); break; case MOUSE_SCROLL_ZOOM: DoScrollZoom(aTargetFrame, msEvent->delta); break; default: // Including -1 (do nothing) break; } *aStatus = nsEventStatus_eConsumeNoDefault; } } break; case NS_DRAGDROP_ENTER: case NS_DRAGDROP_OVER: { NS_ASSERTION(aEvent->eventStructType == NS_DRAG_EVENT, "Expected a drag event"); nsCOMPtr dragSession = nsContentUtils::GetDragSession(); if (!dragSession) break; // the initial dataTransfer is the one from the dragstart event that // was set on the dragSession when the drag began. nsCOMPtr dataTransfer; nsCOMPtr initialDataTransfer; dragSession->GetDataTransfer(getter_AddRefs(initialDataTransfer)); nsCOMPtr initialDataTransferNS = do_QueryInterface(initialDataTransfer); // cancelling a dragenter or dragover event means that a drop should be // allowed, so update the dropEffect and the canDrop state to indicate // that a drag is allowed. If the event isn't cancelled, a drop won't be // allowed. Essentially, to allow a drop somewhere, specify the effects // using the effectAllowed and dropEffect properties in a dragenter or // dragover event and cancel the event. To not allow a drop somewhere, // don't cancel the event or set the effectAllowed or dropEffect to // "none". This way, if the event is just ignored, no drop will be // allowed. PRUint32 dropEffect = nsIDragService::DRAGDROP_ACTION_NONE; if (nsEventStatus_eConsumeNoDefault == *aStatus) { // if the event has a dataTransfer set, use it. nsDragEvent *dragEvent = (nsDragEvent*)aEvent; if (dragEvent->dataTransfer) { // get the dataTransfer and the dropEffect that was set on it dataTransfer = do_QueryInterface(dragEvent->dataTransfer); dataTransfer->GetDropEffectInt(&dropEffect); } else { // if dragEvent->dataTransfer is null, it means that no attempt was // made to access the dataTransfer during the event, yet the event // was cancelled. Instead, use the initial data transfer available // from the drag session. The drop effect would not have been // initialized (which is done in nsDOMDragEvent::GetDataTransfer), // so set it from the drag action. We'll still want to filter it // based on the effectAllowed below. dataTransfer = initialDataTransferNS; PRUint32 action; dragSession->GetDragAction(&action); // filter the drop effect based on the action. Use UNINITIALIZED as // any effect is allowed. dropEffect = nsDOMDragEvent::FilterDropEffect(action, nsIDragService::DRAGDROP_ACTION_UNINITIALIZED); } // At this point, if the dataTransfer is null, it means that the // drag was originally started by directly calling the drag service. // Just assume that all effects are allowed. PRUint32 effectAllowed = nsIDragService::DRAGDROP_ACTION_UNINITIALIZED; if (dataTransfer) dataTransfer->GetEffectAllowedInt(&effectAllowed); // set the drag action based on the drop effect and effect allowed. // The drop effect field on the drag transfer object specifies the // desired current drop effect. However, it cannot be used if the // effectAllowed state doesn't include that type of action. If the // dropEffect is "none", then the action will be 'none' so a drop will // not be allowed. PRUint32 action = nsIDragService::DRAGDROP_ACTION_NONE; if (effectAllowed == nsIDragService::DRAGDROP_ACTION_UNINITIALIZED || dropEffect & effectAllowed) action = dropEffect; if (action == nsIDragService::DRAGDROP_ACTION_NONE) dropEffect = nsIDragService::DRAGDROP_ACTION_NONE; // inform the drag session that a drop is allowed on this node. dragSession->SetDragAction(action); dragSession->SetCanDrop(action != nsIDragService::DRAGDROP_ACTION_NONE); } // now set the drop effect in the initial dataTransfer. This ensures // that we can get the desired drop effect in the drop event. if (initialDataTransferNS) initialDataTransferNS->SetDropEffectInt(dropEffect); } break; case NS_DRAGDROP_DROP: { // now fire the dragdrop event, for compatibility with XUL if (mCurrentTarget && nsEventStatus_eConsumeNoDefault != *aStatus) { nsCOMPtr targetContent; mCurrentTarget->GetContentForEvent(presContext, aEvent, getter_AddRefs(targetContent)); nsCOMPtr widget = mCurrentTarget->GetWindow(); nsDragEvent event(NS_IS_TRUSTED_EVENT(aEvent), NS_DRAGDROP_DRAGDROP, widget); nsMouseEvent* mouseEvent = static_cast(aEvent); event.refPoint = mouseEvent->refPoint; event.isShift = mouseEvent->isShift; event.isControl = mouseEvent->isControl; event.isAlt = mouseEvent->isAlt; event.isMeta = mouseEvent->isMeta; nsEventStatus status = nsEventStatus_eIgnore; nsCOMPtr presShell = mPresContext->GetPresShell(); if (presShell) { presShell->HandleEventWithTarget(&event, mCurrentTarget, targetContent, &status); } } break; } case NS_DRAGDROP_EXIT: // make sure to fire the enter and exit_synth events after the // NS_DRAGDROP_EXIT event, otherwise we'll clean up too early GenerateDragDropEnterExit(presContext, (nsGUIEvent*)aEvent); break; case NS_KEY_UP: break; case NS_KEY_PRESS: if (nsEventStatus_eConsumeNoDefault != *aStatus) { nsKeyEvent* keyEvent = (nsKeyEvent*)aEvent; //This is to prevent keyboard scrolling while alt modifier in use. if (!keyEvent->isAlt) { switch(keyEvent->keyCode) { case NS_VK_TAB: case NS_VK_F6: EnsureDocument(mPresContext); nsIFocusManager* fm = nsFocusManager::GetFocusManager(); if (fm && mDocument) { // Shift focus forward or back depending on shift key PRBool isDocMove = ((nsInputEvent*)aEvent)->isControl || (keyEvent->keyCode == NS_VK_F6); PRUint32 dir = ((nsInputEvent*)aEvent)->isShift ? (isDocMove ? nsIFocusManager::MOVEFOCUS_BACKWARDDOC : nsIFocusManager::MOVEFOCUS_BACKWARD) : (isDocMove ? nsIFocusManager::MOVEFOCUS_FORWARDDOC : nsIFocusManager::MOVEFOCUS_FORWARD); nsCOMPtr result; fm->MoveFocus(mDocument->GetWindow(), nsnull, dir, nsIFocusManager::FLAG_BYKEY, getter_AddRefs(result)); } *aStatus = nsEventStatus_eConsumeNoDefault; break; //the problem is that viewer does not have xul so we cannot completely eliminate these #if NON_KEYBINDING case NS_VK_PAGE_DOWN: case NS_VK_PAGE_UP: if (!focusedContent) { nsIScrollableView* sv = nsLayoutUtils::GetNearestScrollingView(aView, nsLayoutUtils::eVertical); if (sv) { nsKeyEvent * keyEvent = (nsKeyEvent *)aEvent; sv->ScrollByPages(0, (keyEvent->keyCode != NS_VK_PAGE_UP) ? 1 : -1, NS_VMREFRESH_SMOOTHSCROLL); } } break; case NS_VK_HOME: case NS_VK_END: if (!focusedContent) { nsIScrollableView* sv = nsLayoutUtils::GetNearestScrollingView(aView, nsLayoutUtils::eVertical); if (sv) { nsKeyEvent * keyEvent = (nsKeyEvent *)aEvent; sv->ScrollByWhole((keyEvent->keyCode != NS_VK_HOME) ? PR_FALSE : PR_TRUE); } } break; case NS_VK_DOWN: case NS_VK_UP: if (!focusedContent) { nsIScrollableView* sv = nsLayoutUtils::GetNearestScrollingView(aView, nsLayoutUtils::eVertical); if (sv) { nsKeyEvent * keyEvent = (nsKeyEvent *)aEvent; sv->ScrollByLines(0, (keyEvent->keyCode == NS_VK_DOWN) ? 1 : -1, NS_VMREFRESH_SMOOTHSCROLL); // force the update to happen now, otherwise multiple scrolls can // occur before the update is processed. (bug #7354) nsIViewManager* vm = aView->GetViewManager(); if (vm) { // I'd use Composite here, but it doesn't always work. // vm->Composite(); vm->ForceUpdate(); } } } break; case NS_VK_LEFT: case NS_VK_RIGHT: if (!focusedContent) { nsIScrollableView* sv = nsLayoutUtils::GetNearestScrollingView(aView, nsLayoutUtils::eHorizontal); if (sv) { nsKeyEvent * keyEvent = (nsKeyEvent *)aEvent; sv->ScrollByLines((keyEvent->keyCode == NS_VK_RIGHT) ? 1 : -1, 0, NS_VMREFRESH_SMOOTHSCROLL); // force the update to happen now, otherwise multiple scrolls can // occur before the update is processed. (bug #7354) nsIViewManager* vm = aView->GetViewManager(); if (vm) { // I'd use Composite here, but it doesn't always work. // vm->Composite(); vm->ForceUpdate(); } } } break; case 0: /* check charcode since keycode is 0 */ { //Spacebar nsKeyEvent * keyEvent = (nsKeyEvent *)aEvent; if (keyEvent->charCode == 0x20) { if (!focusedContent) { nsIScrollableView* sv = nsLayoutUtils::GetNearestScrollingView(aView, nsLayoutUtils::eVertical); if (sv) { sv->ScrollByPages(0, 1, NS_VMREFRESH_SMOOTHSCROLL); } } } } break; #endif //NON_KEYBINDING } } } break; case NS_MOUSE_ENTER: if (mCurrentTarget) { nsCOMPtr targetContent; mCurrentTarget->GetContentForEvent(presContext, aEvent, getter_AddRefs(targetContent)); SetContentState(targetContent, NS_EVENT_STATE_HOVER); } break; } //Reset target frame to null to avoid mistargeting after reentrant event mCurrentTarget = nsnull; return ret; } NS_IMETHODIMP nsEventStateManager::NotifyDestroyPresContext(nsPresContext* aPresContext) { nsIMEStateManager::OnDestroyPresContext(aPresContext); return NS_OK; } NS_IMETHODIMP nsEventStateManager::SetPresContext(nsPresContext* aPresContext) { mPresContext = aPresContext; return NS_OK; } NS_IMETHODIMP nsEventStateManager::ClearFrameRefs(nsIFrame* aFrame) { if (aFrame && aFrame == mCurrentTarget) { mCurrentTargetContent = aFrame->GetContent(); } return NS_OK; } void nsEventStateManager::UpdateCursor(nsPresContext* aPresContext, nsEvent* aEvent, nsIFrame* aTargetFrame, nsEventStatus* aStatus) { PRInt32 cursor = NS_STYLE_CURSOR_DEFAULT; imgIContainer* container = nsnull; PRBool haveHotspot = PR_FALSE; float hotspotX = 0.0f, hotspotY = 0.0f; //If cursor is locked just use the locked one if (mLockCursor) { cursor = mLockCursor; } //If not locked, look for correct cursor else if (aTargetFrame) { nsIFrame::Cursor framecursor; nsPoint pt = nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, aTargetFrame); if (NS_FAILED(aTargetFrame->GetCursor(pt, framecursor))) return; // don't update the cursor if we failed to get it from the frame see bug 118877 cursor = framecursor.mCursor; container = framecursor.mContainer; haveHotspot = framecursor.mHaveHotspot; hotspotX = framecursor.mHotspotX; hotspotY = framecursor.mHotspotY; } if (aTargetFrame) { SetCursor(cursor, container, haveHotspot, hotspotX, hotspotY, aTargetFrame->GetWindow(), PR_FALSE); } if (mLockCursor || NS_STYLE_CURSOR_AUTO != cursor) { *aStatus = nsEventStatus_eConsumeDoDefault; } } NS_IMETHODIMP nsEventStateManager::SetCursor(PRInt32 aCursor, imgIContainer* aContainer, PRBool aHaveHotspot, float aHotspotX, float aHotspotY, nsIWidget* aWidget, PRBool aLockCursor) { nsCursor c; NS_ENSURE_TRUE(aWidget, NS_ERROR_FAILURE); if (aLockCursor) { if (NS_STYLE_CURSOR_AUTO != aCursor) { mLockCursor = aCursor; } else { //If cursor style is set to auto we unlock the cursor again. mLockCursor = 0; } } switch (aCursor) { default: case NS_STYLE_CURSOR_AUTO: case NS_STYLE_CURSOR_DEFAULT: c = eCursor_standard; break; case NS_STYLE_CURSOR_POINTER: c = eCursor_hyperlink; break; case NS_STYLE_CURSOR_CROSSHAIR: c = eCursor_crosshair; break; case NS_STYLE_CURSOR_MOVE: c = eCursor_move; break; case NS_STYLE_CURSOR_TEXT: c = eCursor_select; break; case NS_STYLE_CURSOR_WAIT: c = eCursor_wait; break; case NS_STYLE_CURSOR_HELP: c = eCursor_help; break; case NS_STYLE_CURSOR_N_RESIZE: c = eCursor_n_resize; break; case NS_STYLE_CURSOR_S_RESIZE: c = eCursor_s_resize; break; case NS_STYLE_CURSOR_W_RESIZE: c = eCursor_w_resize; break; case NS_STYLE_CURSOR_E_RESIZE: c = eCursor_e_resize; break; case NS_STYLE_CURSOR_NW_RESIZE: c = eCursor_nw_resize; break; case NS_STYLE_CURSOR_SE_RESIZE: c = eCursor_se_resize; break; case NS_STYLE_CURSOR_NE_RESIZE: c = eCursor_ne_resize; break; case NS_STYLE_CURSOR_SW_RESIZE: c = eCursor_sw_resize; break; case NS_STYLE_CURSOR_COPY: // CSS3 c = eCursor_copy; break; case NS_STYLE_CURSOR_ALIAS: c = eCursor_alias; break; case NS_STYLE_CURSOR_CONTEXT_MENU: c = eCursor_context_menu; break; case NS_STYLE_CURSOR_CELL: c = eCursor_cell; break; case NS_STYLE_CURSOR_GRAB: c = eCursor_grab; break; case NS_STYLE_CURSOR_GRABBING: c = eCursor_grabbing; break; case NS_STYLE_CURSOR_SPINNING: c = eCursor_spinning; break; case NS_STYLE_CURSOR_MOZ_ZOOM_IN: c = eCursor_zoom_in; break; case NS_STYLE_CURSOR_MOZ_ZOOM_OUT: c = eCursor_zoom_out; break; case NS_STYLE_CURSOR_NOT_ALLOWED: c = eCursor_not_allowed; break; case NS_STYLE_CURSOR_COL_RESIZE: c = eCursor_col_resize; break; case NS_STYLE_CURSOR_ROW_RESIZE: c = eCursor_row_resize; break; case NS_STYLE_CURSOR_NO_DROP: c = eCursor_no_drop; break; case NS_STYLE_CURSOR_VERTICAL_TEXT: c = eCursor_vertical_text; break; case NS_STYLE_CURSOR_ALL_SCROLL: c = eCursor_all_scroll; break; case NS_STYLE_CURSOR_NESW_RESIZE: c = eCursor_nesw_resize; break; case NS_STYLE_CURSOR_NWSE_RESIZE: c = eCursor_nwse_resize; break; case NS_STYLE_CURSOR_NS_RESIZE: c = eCursor_ns_resize; break; case NS_STYLE_CURSOR_EW_RESIZE: c = eCursor_ew_resize; break; case NS_STYLE_CURSOR_NONE: c = eCursor_none; break; } // First, try the imgIContainer, if non-null nsresult rv = NS_ERROR_FAILURE; if (aContainer) { PRUint32 hotspotX, hotspotY; // css3-ui says to use the CSS-specified hotspot if present, // otherwise use the intrinsic hotspot, otherwise use the top left // corner. if (aHaveHotspot) { PRInt32 imgWidth, imgHeight; aContainer->GetWidth(&imgWidth); aContainer->GetHeight(&imgHeight); // XXX PR_MAX(NS_lround(x), 0)? hotspotX = aHotspotX > 0.0f ? PRUint32(aHotspotX + 0.5f) : PRUint32(0); if (hotspotX >= PRUint32(imgWidth)) hotspotX = imgWidth - 1; hotspotY = aHotspotY > 0.0f ? PRUint32(aHotspotY + 0.5f) : PRUint32(0); if (hotspotY >= PRUint32(imgHeight)) hotspotY = imgHeight - 1; } else { hotspotX = 0; hotspotY = 0; nsCOMPtr props(do_QueryInterface(aContainer)); if (props) { nsCOMPtr hotspotXWrap, hotspotYWrap; props->Get("hotspotX", NS_GET_IID(nsISupportsPRUint32), getter_AddRefs(hotspotXWrap)); props->Get("hotspotY", NS_GET_IID(nsISupportsPRUint32), getter_AddRefs(hotspotYWrap)); if (hotspotXWrap) hotspotXWrap->GetData(&hotspotX); if (hotspotYWrap) hotspotYWrap->GetData(&hotspotY); } } rv = aWidget->SetCursor(aContainer, hotspotX, hotspotY); } if (NS_FAILED(rv)) aWidget->SetCursor(c); return NS_OK; } class NS_STACK_CLASS nsESMEventCB : public nsDispatchingCallback { public: nsESMEventCB(nsIContent* aTarget) : mTarget(aTarget) {} virtual void HandleEvent(nsEventChainPostVisitor& aVisitor) { if (aVisitor.mPresContext) { nsIPresShell* shell = aVisitor.mPresContext->GetPresShell(); if (shell) { nsIFrame* frame = shell->GetPrimaryFrameFor(mTarget); if (frame) { frame->HandleEvent(aVisitor.mPresContext, (nsGUIEvent*) aVisitor.mEvent, &aVisitor.mEventStatus); } } } } nsCOMPtr mTarget; }; nsIFrame* nsEventStateManager::DispatchMouseEvent(nsGUIEvent* aEvent, PRUint32 aMessage, nsIContent* aTargetContent, nsIContent* aRelatedContent) { nsEventStatus status = nsEventStatus_eIgnore; nsMouseEvent event(NS_IS_TRUSTED_EVENT(aEvent), aMessage, aEvent->widget, nsMouseEvent::eReal); event.refPoint = aEvent->refPoint; event.isShift = ((nsMouseEvent*)aEvent)->isShift; event.isControl = ((nsMouseEvent*)aEvent)->isControl; event.isAlt = ((nsMouseEvent*)aEvent)->isAlt; event.isMeta = ((nsMouseEvent*)aEvent)->isMeta; event.nativeMsg = ((nsMouseEvent*)aEvent)->nativeMsg; event.relatedTarget = aRelatedContent; mCurrentTargetContent = aTargetContent; nsIFrame* targetFrame = nsnull; if (aTargetContent) { nsESMEventCB callback(aTargetContent); nsEventDispatcher::Dispatch(aTargetContent, mPresContext, &event, nsnull, &status, &callback); nsIPresShell *shell = mPresContext ? mPresContext->GetPresShell() : nsnull; if (shell) { // Although the primary frame was checked in event callback, // it may not be the same object after event dispatching and handling. // So we need to refetch it. targetFrame = shell->GetPrimaryFrameFor(aTargetContent); } } mCurrentTargetContent = nsnull; return targetFrame; } void nsEventStateManager::NotifyMouseOut(nsGUIEvent* aEvent, nsIContent* aMovingInto) { if (!mLastMouseOverElement) return; // Before firing mouseout, check for recursion if (mLastMouseOverElement == mFirstMouseOutEventElement) return; if (mLastMouseOverFrame) { // if the frame is associated with a subdocument, // tell the subdocument that we're moving out of it nsIFrameFrame* subdocFrame = do_QueryFrame(mLastMouseOverFrame.GetFrame()); if (subdocFrame) { nsCOMPtr docshell; subdocFrame->GetDocShell(getter_AddRefs(docshell)); if (docshell) { nsCOMPtr presContext; docshell->GetPresContext(getter_AddRefs(presContext)); if (presContext) { nsEventStateManager* kidESM = static_cast(presContext->EventStateManager()); // Not moving into any element in this subdocument kidESM->NotifyMouseOut(aEvent, nsnull); } } } } // That could have caused DOM events which could wreak havoc. Reverify // things and be careful. if (!mLastMouseOverElement) return; // Store the first mouseOut event we fire and don't refire mouseOut // to that element while the first mouseOut is still ongoing. mFirstMouseOutEventElement = mLastMouseOverElement; // Don't touch hover state if aMovingInto is non-null. Caller will update // hover state itself, and we have optimizations for hover switching between // two nearby elements both deep in the DOM tree that would be defeated by // switching the hover state to null here. if (!aMovingInto) { // Unset :hover SetContentState(nsnull, NS_EVENT_STATE_HOVER); } // Fire mouseout DispatchMouseEvent(aEvent, NS_MOUSE_EXIT_SYNTH, mLastMouseOverElement, aMovingInto); mLastMouseOverFrame = nsnull; mLastMouseOverElement = nsnull; // Turn recursion protection back off mFirstMouseOutEventElement = nsnull; } void nsEventStateManager::NotifyMouseOver(nsGUIEvent* aEvent, nsIContent* aContent) { NS_ASSERTION(aContent, "Mouse must be over something"); if (mLastMouseOverElement == aContent) return; // Before firing mouseover, check for recursion if (aContent == mFirstMouseOverEventElement) return; // Check to see if we're a subdocument and if so update the parent // document's ESM state to indicate that the mouse is over the // content associated with our subdocument. EnsureDocument(mPresContext); nsIDocument *parentDoc = mDocument->GetParentDocument(); if (parentDoc) { nsIContent *docContent = parentDoc->FindContentForSubDocument(mDocument); if (docContent) { nsIPresShell *parentShell = parentDoc->GetPrimaryShell(); if (parentShell) { nsEventStateManager* parentESM = static_cast (parentShell->GetPresContext()->EventStateManager()); parentESM->NotifyMouseOver(aEvent, docContent); } } } // Firing the DOM event in the parent document could cause all kinds // of havoc. Reverify and take care. if (mLastMouseOverElement == aContent) return; // Remember mLastMouseOverElement as the related content for the // DispatchMouseEvent() call below, since NotifyMouseOut() resets it, bug 298477. nsCOMPtr lastMouseOverElement = mLastMouseOverElement; NotifyMouseOut(aEvent, aContent); // Store the first mouseOver event we fire and don't refire mouseOver // to that element while the first mouseOver is still ongoing. mFirstMouseOverEventElement = aContent; SetContentState(aContent, NS_EVENT_STATE_HOVER); // Fire mouseover mLastMouseOverFrame = DispatchMouseEvent(aEvent, NS_MOUSE_ENTER_SYNTH, aContent, lastMouseOverElement); mLastMouseOverElement = aContent; // Turn recursion protection back off mFirstMouseOverEventElement = nsnull; } void nsEventStateManager::GenerateMouseEnterExit(nsGUIEvent* aEvent) { EnsureDocument(mPresContext); if (!mDocument) return; // Hold onto old target content through the event and reset after. nsCOMPtr targetBeforeEvent = mCurrentTargetContent; switch(aEvent->message) { case NS_MOUSE_MOVE: { // Get the target content target (mousemove target == mouseover target) nsCOMPtr targetElement; GetEventTargetContent(aEvent, getter_AddRefs(targetElement)); if (!targetElement) { // We're always over the document root, even if we're only // over dead space in a page (whose frame is not associated with // any content) or in print preview dead space targetElement = mDocument->GetRootContent(); } NS_ASSERTION(targetElement, "Mouse move must have some target content"); if (targetElement) { NotifyMouseOver(aEvent, targetElement); } } break; case NS_MOUSE_EXIT: { // This is actually the window mouse exit event. We're not moving // into any new element. if (mLastMouseOverFrame && nsContentUtils::GetTopLevelWidget(aEvent->widget) != nsContentUtils::GetTopLevelWidget(mLastMouseOverFrame->GetWindow())) { // the MouseOut event widget doesn't have same top widget with // mLastMouseOverFrame, it's a spurious event for mLastMouseOverFrame break; } NotifyMouseOut(aEvent, nsnull); } break; } // reset mCurretTargetContent to what it was mCurrentTargetContent = targetBeforeEvent; } void nsEventStateManager::GenerateDragDropEnterExit(nsPresContext* aPresContext, nsGUIEvent* aEvent) { //Hold onto old target content through the event and reset after. nsCOMPtr targetBeforeEvent = mCurrentTargetContent; switch(aEvent->message) { case NS_DRAGDROP_OVER: { if (mLastDragOverFrame != mCurrentTarget) { //We'll need the content, too, to check if it changed separately from the frames. nsCOMPtr lastContent; nsCOMPtr targetContent; mCurrentTarget->GetContentForEvent(aPresContext, aEvent, getter_AddRefs(targetContent)); if ( mLastDragOverFrame ) { //The frame has changed but the content may not have. Check before dispatching to content mLastDragOverFrame->GetContentForEvent(aPresContext, aEvent, getter_AddRefs(lastContent)); FireDragEnterOrExit(aPresContext, aEvent, NS_DRAGDROP_LEAVE_SYNTH, targetContent, lastContent, mLastDragOverFrame); FireDragEnterOrExit(aPresContext, aEvent, NS_DRAGDROP_EXIT_SYNTH, targetContent, lastContent, mLastDragOverFrame); } FireDragEnterOrExit(aPresContext, aEvent, NS_DRAGDROP_ENTER, lastContent, targetContent, mCurrentTarget); mLastDragOverFrame = mCurrentTarget; } } break; case NS_DRAGDROP_DROP: case NS_DRAGDROP_EXIT: { //This is actually the window mouse exit event. if ( mLastDragOverFrame ) { nsCOMPtr lastContent; mLastDragOverFrame->GetContentForEvent(aPresContext, aEvent, getter_AddRefs(lastContent)); FireDragEnterOrExit(aPresContext, aEvent, NS_DRAGDROP_LEAVE_SYNTH, nsnull, lastContent, mLastDragOverFrame); FireDragEnterOrExit(aPresContext, aEvent, NS_DRAGDROP_EXIT_SYNTH, nsnull, lastContent, mLastDragOverFrame); mLastDragOverFrame = nsnull; } } break; } //reset mCurretTargetContent to what it was mCurrentTargetContent = targetBeforeEvent; // Now flush all pending notifications, for better responsiveness. FlushPendingEvents(aPresContext); } void nsEventStateManager::FireDragEnterOrExit(nsPresContext* aPresContext, nsGUIEvent* aEvent, PRUint32 aMsg, nsIContent* aRelatedTarget, nsIContent* aTargetContent, nsWeakFrame& aTargetFrame) { nsEventStatus status = nsEventStatus_eIgnore; nsDragEvent event(NS_IS_TRUSTED_EVENT(aEvent), aMsg, aEvent->widget); event.refPoint = aEvent->refPoint; event.isShift = ((nsMouseEvent*)aEvent)->isShift; event.isControl = ((nsMouseEvent*)aEvent)->isControl; event.isAlt = ((nsMouseEvent*)aEvent)->isAlt; event.isMeta = ((nsMouseEvent*)aEvent)->isMeta; event.relatedTarget = aRelatedTarget; mCurrentTargetContent = aTargetContent; if (aTargetContent != aRelatedTarget) { //XXX This event should still go somewhere!! if (aTargetContent) nsEventDispatcher::Dispatch(aTargetContent, aPresContext, &event, nsnull, &status); // adjust the drag hover if the dragenter event was cancelled or this is a drag exit if (status == nsEventStatus_eConsumeNoDefault || aMsg == NS_DRAGDROP_EXIT) SetContentState((aMsg == NS_DRAGDROP_ENTER) ? aTargetContent : nsnull, NS_EVENT_STATE_DRAGOVER); } // Finally dispatch the event to the frame if (aTargetFrame) aTargetFrame->HandleEvent(aPresContext, &event, &status); } nsresult nsEventStateManager::SetClickCount(nsPresContext* aPresContext, nsMouseEvent *aEvent, nsEventStatus* aStatus) { nsCOMPtr mouseContent; mCurrentTarget->GetContentForEvent(aPresContext, aEvent, getter_AddRefs(mouseContent)); switch (aEvent->button) { case nsMouseEvent::eLeftButton: if (aEvent->message == NS_MOUSE_BUTTON_DOWN) { mLastLeftMouseDownContent = mouseContent; } else if (aEvent->message == NS_MOUSE_BUTTON_UP) { if (mLastLeftMouseDownContent == mouseContent) { aEvent->clickCount = mLClickCount; mLClickCount = 0; } else { aEvent->clickCount = 0; } mLastLeftMouseDownContent = nsnull; } break; case nsMouseEvent::eMiddleButton: if (aEvent->message == NS_MOUSE_BUTTON_DOWN) { mLastMiddleMouseDownContent = mouseContent; } else if (aEvent->message == NS_MOUSE_BUTTON_UP) { if (mLastMiddleMouseDownContent == mouseContent) { aEvent->clickCount = mMClickCount; mMClickCount = 0; } else { aEvent->clickCount = 0; } // XXX Why we don't clear mLastMiddleMouseDownContent here? } break; case nsMouseEvent::eRightButton: if (aEvent->message == NS_MOUSE_BUTTON_DOWN) { mLastRightMouseDownContent = mouseContent; } else if (aEvent->message == NS_MOUSE_BUTTON_UP) { if (mLastRightMouseDownContent == mouseContent) { aEvent->clickCount = mRClickCount; mRClickCount = 0; } else { aEvent->clickCount = 0; } // XXX Why we don't clear mLastRightMouseDownContent here? } break; } return NS_OK; } nsresult nsEventStateManager::CheckForAndDispatchClick(nsPresContext* aPresContext, nsMouseEvent *aEvent, nsEventStatus* aStatus) { nsresult ret = NS_OK; PRInt32 flags = NS_EVENT_FLAG_NONE; //If mouse is still over same element, clickcount will be > 1. //If it has moved it will be zero, so no click. if (0 != aEvent->clickCount) { //Check that the window isn't disabled before firing a click //(see bug 366544). if (aEvent->widget) { PRBool enabled; aEvent->widget->IsEnabled(&enabled); if (!enabled) { return ret; } } //fire click if (aEvent->button == nsMouseEvent::eMiddleButton || aEvent->button == nsMouseEvent::eRightButton) { flags |= sLeftClickOnly ? NS_EVENT_FLAG_NO_CONTENT_DISPATCH : NS_EVENT_FLAG_NONE; } nsMouseEvent event(NS_IS_TRUSTED_EVENT(aEvent), NS_MOUSE_CLICK, aEvent->widget, nsMouseEvent::eReal); event.refPoint = aEvent->refPoint; event.clickCount = aEvent->clickCount; event.isShift = aEvent->isShift; event.isControl = aEvent->isControl; event.isAlt = aEvent->isAlt; event.isMeta = aEvent->isMeta; event.time = aEvent->time; event.flags |= flags; event.button = aEvent->button; nsCOMPtr presShell = mPresContext->GetPresShell(); if (presShell) { nsCOMPtr mouseContent; GetEventTargetContent(aEvent, getter_AddRefs(mouseContent)); ret = presShell->HandleEventWithTarget(&event, mCurrentTarget, mouseContent, aStatus); if (NS_SUCCEEDED(ret) && aEvent->clickCount == 2) { //fire double click nsMouseEvent event2(NS_IS_TRUSTED_EVENT(aEvent), NS_MOUSE_DOUBLECLICK, aEvent->widget, nsMouseEvent::eReal); event2.refPoint = aEvent->refPoint; event2.clickCount = aEvent->clickCount; event2.isShift = aEvent->isShift; event2.isControl = aEvent->isControl; event2.isAlt = aEvent->isAlt; event2.isMeta = aEvent->isMeta; event2.flags |= flags; event2.button = aEvent->button; ret = presShell->HandleEventWithTarget(&event2, mCurrentTarget, mouseContent, aStatus); } } } return ret; } NS_IMETHODIMP nsEventStateManager::GetEventTarget(nsIFrame **aFrame) { if (!mCurrentTarget && mCurrentTargetContent) { if (mPresContext) { nsIPresShell *shell = mPresContext->GetPresShell(); if (shell) { mCurrentTarget = shell->GetPrimaryFrameFor(mCurrentTargetContent); } } } if (!mCurrentTarget) { nsIPresShell *presShell = mPresContext->GetPresShell(); if (presShell) { nsIFrame* frame = nsnull; presShell->GetEventTargetFrame(&frame); mCurrentTarget = frame; } } *aFrame = mCurrentTarget; return NS_OK; } NS_IMETHODIMP nsEventStateManager::GetEventTargetContent(nsEvent* aEvent, nsIContent** aContent) { if (aEvent && (aEvent->message == NS_FOCUS_CONTENT || aEvent->message == NS_BLUR_CONTENT)) { NS_IF_ADDREF(*aContent = GetFocusedContent()); return NS_OK; } if (mCurrentTargetContent) { *aContent = mCurrentTargetContent; NS_IF_ADDREF(*aContent); return NS_OK; } *aContent = nsnull; nsIPresShell *presShell = mPresContext->GetPresShell(); if (presShell) { presShell->GetEventTargetContent(aEvent, aContent); } // Some events here may set mCurrentTarget but not set the corresponding // event target in the PresShell. if (!*aContent && mCurrentTarget) { mCurrentTarget->GetContentForEvent(mPresContext, aEvent, aContent); } return NS_OK; } NS_IMETHODIMP nsEventStateManager::GetContentState(nsIContent *aContent, PRInt32& aState) { aState = aContent->IntrinsicState(); // Hierchical active: Check the ancestor chain of mActiveContent to see // if we are on it. for (nsIContent* activeContent = mActiveContent; activeContent; activeContent = activeContent->GetParent()) { if (aContent == activeContent) { aState |= NS_EVENT_STATE_ACTIVE; break; } } // Hierchical hover: Check the ancestor chain of mHoverContent to see // if we are on it. for (nsIContent* hoverContent = mHoverContent; hoverContent; hoverContent = hoverContent->GetParent()) { if (aContent == hoverContent) { aState |= NS_EVENT_STATE_HOVER; break; } } nsIFocusManager* fm = nsFocusManager::GetFocusManager(); if (fm) { nsCOMPtr focusedElement; fm->GetFocusedElement(getter_AddRefs(focusedElement)); nsCOMPtr focusedContent = do_QueryInterface(focusedElement); if (aContent == focusedContent) { aState |= NS_EVENT_STATE_FOCUS; } } if (aContent == mDragOverContent) { aState |= NS_EVENT_STATE_DRAGOVER; } if (aContent == mURLTargetContent) { aState |= NS_EVENT_STATE_URLTARGET; } return NS_OK; } static nsIContent* FindCommonAncestor(nsIContent *aNode1, nsIContent *aNode2) { // Find closest common ancestor if (aNode1 && aNode2) { // Find the nearest common ancestor by counting the distance to the // root and then walking up again, in pairs. PRInt32 offset = 0; nsIContent *anc1 = aNode1; for (;;) { ++offset; nsIContent* parent = anc1->GetParent(); if (!parent) break; anc1 = parent; } nsIContent *anc2 = aNode2; for (;;) { --offset; nsIContent* parent = anc2->GetParent(); if (!parent) break; anc2 = parent; } if (anc1 == anc2) { anc1 = aNode1; anc2 = aNode2; while (offset > 0) { anc1 = anc1->GetParent(); --offset; } while (offset < 0) { anc2 = anc2->GetParent(); ++offset; } while (anc1 != anc2) { anc1 = anc1->GetParent(); anc2 = anc2->GetParent(); } return anc1; } } return nsnull; } PRBool nsEventStateManager::SetContentState(nsIContent *aContent, PRInt32 aState) { const PRInt32 maxNotify = 5; // We must initialize this array with memset for the sake of the boneheaded // OS X compiler. See bug 134934. nsIContent *notifyContent[maxNotify]; memset(notifyContent, 0, sizeof(notifyContent)); // check to see that this state is allowed by style. Check dragover too? // XXX This doesn't consider that |aState| is a bitfield. // XXX Is this even what we want? if (mCurrentTarget && (aState == NS_EVENT_STATE_ACTIVE || aState == NS_EVENT_STATE_HOVER)) { const nsStyleUserInterface* ui = mCurrentTarget->GetStyleUserInterface(); if (ui->mUserInput == NS_STYLE_USER_INPUT_NONE) return PR_FALSE; } if ((aState & NS_EVENT_STATE_DRAGOVER) && (aContent != mDragOverContent)) { notifyContent[3] = mDragOverContent; // notify dragover first, since more common case NS_IF_ADDREF(notifyContent[3]); mDragOverContent = aContent; } if ((aState & NS_EVENT_STATE_URLTARGET) && (aContent != mURLTargetContent)) { notifyContent[4] = mURLTargetContent; NS_IF_ADDREF(notifyContent[4]); mURLTargetContent = aContent; } nsCOMPtr commonActiveAncestor, oldActive, newActive; if ((aState & NS_EVENT_STATE_ACTIVE) && (aContent != mActiveContent)) { oldActive = mActiveContent; newActive = aContent; commonActiveAncestor = FindCommonAncestor(mActiveContent, aContent); mActiveContent = aContent; } nsCOMPtr commonHoverAncestor, oldHover, newHover; if ((aState & NS_EVENT_STATE_HOVER) && (aContent != mHoverContent)) { oldHover = mHoverContent; if (!mPresContext || mPresContext->IsDynamic()) { newHover = aContent; } else { nsIFrame *frame = aContent ? mPresContext->PresShell()->GetPrimaryFrameFor(aContent) : nsnull; if (frame && nsLayoutUtils::IsViewportScrollbarFrame(frame)) { // The scrollbars of viewport should not ignore the hover state. // Because they are *not* the content of the web page. newHover = aContent; } else { // All contents of the web page should ignore the hover state. newHover = nsnull; } } commonHoverAncestor = FindCommonAncestor(mHoverContent, aContent); mHoverContent = aContent; } if ((aState & NS_EVENT_STATE_FOCUS)) { notifyContent[2] = aContent; NS_IF_ADDREF(notifyContent[2]); } PRInt32 simpleStates = aState & ~(NS_EVENT_STATE_ACTIVE|NS_EVENT_STATE_HOVER); if (aContent && simpleStates != 0) { // notify about new content too notifyContent[0] = aContent; NS_ADDREF(aContent); // everything in notify array has a ref } // remove duplicates if ((notifyContent[4] == notifyContent[3]) || (notifyContent[4] == notifyContent[2]) || (notifyContent[4] == notifyContent[1])) { NS_IF_RELEASE(notifyContent[4]); } // remove duplicates if ((notifyContent[3] == notifyContent[2]) || (notifyContent[3] == notifyContent[1])) { NS_IF_RELEASE(notifyContent[3]); } if (notifyContent[2] == notifyContent[1]) { NS_IF_RELEASE(notifyContent[2]); } // remove notifications for content not in document. // we may decide this is possible later but right now it has problems. for (int i = 0; i < maxNotify; i++) { if (notifyContent[i] && !notifyContent[i]->GetDocument()) { NS_RELEASE(notifyContent[i]); } } // compress the notify array to group notifications tighter nsIContent** from = &(notifyContent[0]); nsIContent** to = &(notifyContent[0]); nsIContent** end = &(notifyContent[maxNotify]); while (from < end) { if (! *from) { while (++from < end) { if (*from) { *to++ = *from; *from = nsnull; break; } } } else { if (from == to) { to++; from++; } else { *to++ = *from; *from++ = nsnull; } } } if (notifyContent[0] || newHover || oldHover || newActive || oldActive) { // have at least one to notify about nsCOMPtr doc1, doc2; // this presumes content can't get/lose state if not connected to doc if (notifyContent[0]) { doc1 = notifyContent[0]->GetDocument(); if (notifyContent[1]) { //For :focus this might be a different doc so check doc2 = notifyContent[1]->GetDocument(); if (doc1 == doc2) { doc2 = nsnull; } } } else { EnsureDocument(mPresContext); doc1 = mDocument; } if (doc1) { doc1->BeginUpdate(UPDATE_CONTENT_STATE); // Notify all content from newActive to the commonActiveAncestor while (newActive && newActive != commonActiveAncestor) { doc1->ContentStatesChanged(newActive, nsnull, NS_EVENT_STATE_ACTIVE); newActive = newActive->GetParent(); } // Notify all content from oldActive to the commonActiveAncestor while (oldActive && oldActive != commonActiveAncestor) { doc1->ContentStatesChanged(oldActive, nsnull, NS_EVENT_STATE_ACTIVE); oldActive = oldActive->GetParent(); } // Notify all content from newHover to the commonHoverAncestor while (newHover && newHover != commonHoverAncestor) { doc1->ContentStatesChanged(newHover, nsnull, NS_EVENT_STATE_HOVER); newHover = newHover->GetParent(); } // Notify all content from oldHover to the commonHoverAncestor while (oldHover && oldHover != commonHoverAncestor) { doc1->ContentStatesChanged(oldHover, nsnull, NS_EVENT_STATE_HOVER); oldHover = oldHover->GetParent(); } if (notifyContent[0]) { doc1->ContentStatesChanged(notifyContent[0], notifyContent[1], simpleStates); if (notifyContent[2]) { // more that two notifications are needed (should be rare) // XXX a further optimization here would be to group the // notification pairs together by parent/child, only needed if // more than two content changed (ie: if [0] and [2] are // parent/child, then notify (0,2) (1,3)) doc1->ContentStatesChanged(notifyContent[2], notifyContent[3], simpleStates); if (notifyContent[4]) { // more that four notifications are needed (should be rare) doc1->ContentStatesChanged(notifyContent[4], nsnull, simpleStates); } } } doc1->EndUpdate(UPDATE_CONTENT_STATE); if (doc2) { doc2->BeginUpdate(UPDATE_CONTENT_STATE); doc2->ContentStatesChanged(notifyContent[1], notifyContent[2], simpleStates); if (notifyContent[3]) { doc1->ContentStatesChanged(notifyContent[3], notifyContent[4], simpleStates); } doc2->EndUpdate(UPDATE_CONTENT_STATE); } } from = &(notifyContent[0]); while (from < to) { // release old refs now that we are through nsIContent* notify = *from++; NS_RELEASE(notify); } } return PR_TRUE; } NS_IMETHODIMP nsEventStateManager::ContentRemoved(nsIDocument* aDocument, nsIContent* aContent) { // inform the focus manager that the content is being removed. If this // content is focused, the focus will be removed without firing events. nsIFocusManager* fm = nsFocusManager::GetFocusManager(); if (fm) fm->ContentRemoved(aDocument, aContent); if (mHoverContent && nsContentUtils::ContentIsDescendantOf(mHoverContent, aContent)) { // Since hover is hierarchical, set the current hover to the // content's parent node. mHoverContent = aContent->GetParent(); } if (mActiveContent && nsContentUtils::ContentIsDescendantOf(mActiveContent, aContent)) { // Active is hierarchical, so set the current active to the // content's parent node. mActiveContent = aContent->GetParent(); } if (mDragOverContent && nsContentUtils::ContentIsDescendantOf(mDragOverContent, aContent)) { mDragOverContent = nsnull; } if (mLastMouseOverElement && nsContentUtils::ContentIsDescendantOf(mLastMouseOverElement, aContent)) { // See bug 292146 for why we want to null this out mLastMouseOverElement = nsnull; } return NS_OK; } NS_IMETHODIMP nsEventStateManager::EventStatusOK(nsGUIEvent* aEvent, PRBool *aOK) { *aOK = PR_TRUE; if (aEvent->message == NS_MOUSE_BUTTON_DOWN && static_cast(aEvent)->button == nsMouseEvent::eLeftButton) { if (!mNormalLMouseEventInProcess) { *aOK = PR_FALSE; } } return NS_OK; } //------------------------------------------- // Access Key Registration //------------------------------------------- NS_IMETHODIMP nsEventStateManager::RegisterAccessKey(nsIContent* aContent, PRUint32 aKey) { if (aContent && mAccessKeys.IndexOf(aContent) == -1) mAccessKeys.AppendObject(aContent); return NS_OK; } NS_IMETHODIMP nsEventStateManager::UnregisterAccessKey(nsIContent* aContent, PRUint32 aKey) { if (aContent) mAccessKeys.RemoveObject(aContent); return NS_OK; } NS_IMETHODIMP nsEventStateManager::GetRegisteredAccessKey(nsIContent* aContent, PRUint32* aKey) { NS_ENSURE_ARG(aContent); NS_ENSURE_ARG_POINTER(aKey); *aKey = 0; if (mAccessKeys.IndexOf(aContent) == -1) return NS_OK; nsAutoString accessKey; aContent->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, accessKey); *aKey = accessKey.First(); return NS_OK; } void nsEventStateManager::EnsureDocument(nsPresContext* aPresContext) { if (!mDocument) mDocument = aPresContext->Document(); } void nsEventStateManager::FlushPendingEvents(nsPresContext* aPresContext) { NS_PRECONDITION(nsnull != aPresContext, "nsnull ptr"); nsIPresShell *shell = aPresContext->GetPresShell(); if (shell) { shell->FlushPendingNotifications(Flush_InterruptibleLayout); } } nsIContent* nsEventStateManager::GetFocusedContent() { nsIFocusManager* fm = nsFocusManager::GetFocusManager(); if (!fm || !mDocument) return nsnull; nsCOMPtr focusedWindow; return nsFocusManager::GetFocusedDescendant(mDocument->GetWindow(), PR_FALSE, getter_AddRefs(focusedWindow)); } //------------------------------------------------------- // Return PR_TRUE if the docshell is visible PRBool nsEventStateManager::IsShellVisible(nsIDocShell* aShell) { NS_ASSERTION(aShell, "docshell is null"); nsCOMPtr basewin = do_QueryInterface(aShell); if (!basewin) return PR_TRUE; PRBool isVisible = PR_TRUE; basewin->GetVisibility(&isVisible); // We should be doing some additional checks here so that // we don't tab into hidden tabs of tabbrowser. -bryner return isVisible; }