Back to index

lightning-sunbird  0.9+nobinonly
Public Types | Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Static Protected Attributes
nsEventStateManager Class Reference

#include <nsEventStateManager.h>

Inheritance diagram for nsEventStateManager:
Inheritance graph
[legend]
Collaboration diagram for nsEventStateManager:
Collaboration graph
[legend]

List of all members.

Public Types

enum  EFocusedWithType {
  eEventFocusedByUnknown, eEventFocusedByMouse, eEventFocusedByKey, eEventFocusedByContextMenu,
  eEventFocusedByApplication
}

Public Member Functions

 nsEventStateManager ()
virtual ~nsEventStateManager ()
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER NS_IMETHOD 
Init ()
nsresult Shutdown ()
NS_IMETHOD PreHandleEvent (nsPresContext *aPresContext, nsEvent *aEvent, nsIFrame *aTargetFrame, nsEventStatus *aStatus, nsIView *aView)
NS_IMETHOD PostHandleEvent (nsPresContext *aPresContext, nsEvent *aEvent, nsIFrame *aTargetFrame, nsEventStatus *aStatus, nsIView *aView)
NS_IMETHOD SetPresContext (nsPresContext *aPresContext)
NS_IMETHOD ClearFrameRefs (nsIFrame *aFrame)
NS_IMETHOD GetEventTarget (nsIFrame **aFrame)
NS_IMETHOD GetEventTargetContent (nsEvent *aEvent, nsIContent **aContent)
NS_IMETHOD GetEventRelatedContent (nsIContent **aContent)
NS_IMETHOD GetContentState (nsIContent *aContent, PRInt32 &aState)
NS_IMETHOD SetContentState (nsIContent *aContent, PRInt32 aState)
NS_IMETHOD GetFocusedContent (nsIContent **aContent)
NS_IMETHOD SetFocusedContent (nsIContent *aContent)
NS_IMETHOD GetLastFocusedContent (nsIContent **aContent)
NS_IMETHOD GetFocusedFrame (nsIFrame **aFrame)
NS_IMETHOD ContentRemoved (nsIContent *aContent)
NS_IMETHOD EventStatusOK (nsGUIEvent *aEvent, PRBool *aOK)
NS_IMETHOD ConsumeFocusEvents (PRBool aDoConsume)
NS_IMETHOD RegisterAccessKey (nsIContent *aContent, PRUint32 aKey)
NS_IMETHOD UnregisterAccessKey (nsIContent *aContent, PRUint32 aKey)
NS_IMETHOD SetCursor (PRInt32 aCursor, imgIContainer *aContainer, PRBool aHaveHotspot, float aHotspotX, float aHotspotY, nsIWidget *aWidget, PRBool aLockCursor)
NS_IMETHOD DispatchNewEvent (nsISupports *aTarget, nsIDOMEvent *aEvent, PRBool *aDefaultActionEnabled)
NS_IMETHOD ShiftFocus (PRBool aForward, nsIContent *aStart=nsnull)
virtual PRBool GetBrowseWithCaret ()
void ResetBrowseWithCaret ()
NS_IMETHOD MoveFocusToCaret (PRBool aCanFocusDoc, PRBool *aIsSelectionWithFocus)
NS_IMETHOD MoveCaretToFocus ()
NS_IMETHOD ChangeFocusWith (nsIContent *aFocus, EFocusedWithType aFocusedWith)
void observe (in nsISupports aSubject, in string aTopic, in wstring aData)
 Observe will be called when there is a notification for the topic |aTopic|.

Static Public Member Functions

static void StartHandlingUserInput ()
static void StopHandlingUserInput ()
static PRBool IsHandlingUserInput ()

Protected Types

enum  ProcessingAccessKeyState { eAccessKeyProcessingNormal = 0, eAccessKeyProcessingUp, eAccessKeyProcessingDown }
enum  ScrollQuantity { eScrollByPixel, eScrollByLine, eScrollByPage }

Protected Member Functions

void EnsureFocusSynchronization ()
 In certain situations the focus controller's concept of focus gets out of whack with mCurrentFocus.
void UpdateCursor (nsPresContext *aPresContext, nsEvent *aEvent, nsIFrame *aTargetFrame, nsEventStatus *aStatus)
nsIFrameDispatchMouseEvent (nsGUIEvent *aEvent, PRUint32 aMessage, nsIContent *aTargetContent, nsIContent *aRelatedContent)
 Turn a GUI mouse event into a mouse event targeted at the specified content.
void GenerateMouseEnterExit (nsGUIEvent *aEvent)
 Synthesize DOM and frame mouseover and mouseout events from this MOUSE_MOVE or MOUSE_EXIT event.
void NotifyMouseOver (nsGUIEvent *aEvent, nsIContent *aContent)
 Tell this ESM and ESMs in parent documents that the mouse is over some content in this document.
void NotifyMouseOut (nsGUIEvent *aEvent, nsIContent *aMovingInto)
 Tell this ESM and ESMs in affected child documents that the mouse has exited this document's currently hovered content.
void GenerateDragDropEnterExit (nsPresContext *aPresContext, nsGUIEvent *aEvent)
nsresult SetClickCount (nsPresContext *aPresContext, nsMouseEvent *aEvent, nsEventStatus *aStatus)
nsresult CheckForAndDispatchClick (nsPresContext *aPresContext, nsMouseEvent *aEvent, nsEventStatus *aStatus)
nsresult GetNextTabbableContent (nsIContent *aRootContent, nsIContent *aStartContent, nsIFrame *aStartFrame, PRBool forward, PRBool ignoreTabIndex, nsIContent **aResultNode, nsIFrame **aResultFrame)
nsIContentGetNextTabbableMapArea (PRBool aForward, nsIContent *imageContent)
PRInt32 GetNextTabIndex (nsIContent *aParent, PRBool foward)
nsresult SendFocusBlur (nsPresContext *aPresContext, nsIContent *aContent, PRBool aEnsureWindowHasFocus)
void EnsureDocument (nsIPresShell *aPresShell)
void EnsureDocument (nsPresContext *aPresContext)
void FlushPendingEvents (nsPresContext *aPresContext)
nsIFocusControllerGetFocusControllerForDocument (nsIDocument *aDocument)
void HandleAccessKey (nsPresContext *aPresContext, nsKeyEvent *aEvent, nsEventStatus *aStatus, PRInt32 aChildOffset, ProcessingAccessKeyState aAccessKeyState, PRInt32 aModifierMask)
nsresult ShiftFocusInternal (PRBool aForward, nsIContent *aStart=nsnull)
void TabIntoDocument (nsIDocShell *aDocShell, PRBool aForward)
void ShiftFocusByDoc (PRBool forward)
PRBool IsFrameSetDoc (nsIDocShell *aDocShell)
PRBool IsIFrameDoc (nsIDocShell *aDocShell)
PRBool IsShellVisible (nsIDocShell *aShell)
void GetLastChildDocShell (nsIDocShellTreeItem *aItem, nsIDocShellTreeItem **aResult)
void GetNextDocShell (nsIDocShellTreeNode *aNode, nsIDocShellTreeItem **aResult)
void GetPrevDocShell (nsIDocShellTreeNode *aNode, nsIDocShellTreeItem **aResult)
nsresult GetParentScrollingView (nsInputEvent *aEvent, nsPresContext *aPresContext, nsIFrame *&targetOuterFrame, nsPresContext *&presCtxOuter)
nsresult DoScrollText (nsPresContext *aPresContext, nsIFrame *aTargetFrame, nsInputEvent *aEvent, PRInt32 aNumLines, PRBool aScrollHorizontal, ScrollQuantity aScrollQuantity)
void ForceViewUpdate (nsIView *aView)
void DoScrollHistory (PRInt32 direction)
void DoScrollTextsize (nsIFrame *aTargetFrame, PRInt32 adjustment)
nsresult ChangeTextSize (PRInt32 change)
void BeginTrackingDragGesture (nsPresContext *aPresContext, nsMouseEvent *inDownEvent, nsIFrame *inDownFrame)
void StopTrackingDragGesture ()
void GenerateDragGesture (nsPresContext *aPresContext, nsMouseEvent *aEvent)
PRBool IsTrackingDragGesture () const
void FillInEventFromGestureDown (nsMouseEvent *aEvent)
 Set the fields of aEvent to reflect the mouse position and modifier keys that were set when the user first pressed the mouse button (stored by BeginTrackingDragGesture).
nsresult SetCaretEnabled (nsIPresShell *aPresShell, PRBool aVisibility)
nsresult SetContentCaretVisible (nsIPresShell *aPresShell, nsIContent *aContent, PRBool aVisible)
void FocusElementButNotDocument (nsIContent *aElement)
nsresult GetDocSelectionLocation (nsIContent **start, nsIContent **end, nsIFrame **startFrame, PRUint32 *startOffset)
void GetSelection (nsIFrame *inFrame, nsPresContext *inPresContext, nsIFrameSelection **outSelection)
void BeforeDispatchEvent ()
void AfterDispatchEvent ()

Protected Attributes

PRBool mSuppressFocusChange
PRInt32 mLockCursor
nsIFramemCurrentTarget
nsCOMPtr< nsIContentmCurrentTargetContent
nsCOMPtr< nsIContentmCurrentRelatedContent
nsIFramemLastMouseOverFrame
nsCOMPtr< nsIContentmLastMouseOverElement
nsIFramemLastDragOverFrame
nsPoint mGestureDownPoint
nsCOMPtr< nsIContentmGestureDownContent
nsCOMPtr< nsIContentmGestureDownFrameOwner
PRPackedBool mGestureDownShift
PRPackedBool mGestureDownControl
PRPackedBool mGestureDownAlt
PRPackedBool mGestureDownMeta
nsCOMPtr< nsIContentmLastLeftMouseDownContent
nsCOMPtr< nsIContentmLastMiddleMouseDownContent
nsCOMPtr< nsIContentmLastRightMouseDownContent
nsCOMPtr< nsIContentmActiveContent
nsCOMPtr< nsIContentmHoverContent
nsCOMPtr< nsIContentmDragOverContent
nsCOMPtr< nsIContentmURLTargetContent
nsCOMPtr< nsIContentmCurrentFocus
nsCOMPtr< nsIContentmLastFocus
nsIFramemCurrentFocusFrame
PRInt32 mCurrentTabIndex
EFocusedWithType mLastFocusedWith
nsCOMPtr< nsIContentmLastContentFocus
nsCOMPtr< nsIContentmFirstBlurEvent
nsCOMPtr< nsIContentmFirstFocusEvent
nsCOMPtr< nsIContentmFirstMouseOverEventElement
nsCOMPtr< nsIContentmFirstMouseOutEventElement
nsPresContextmPresContext
nsCOMPtr< nsIDocumentmDocument
PRUint32 mLClickCount
PRUint32 mMClickCount
PRUint32 mRClickCount
PRPackedBool mConsumeFocusEvents
PRPackedBool mNormalLMouseEventInProcess
PRPackedBool m_haveShutdown
PRPackedBool mClearedFrameRefsDuringEvent
PRPackedBool mBrowseWithCaret
PRPackedBool mTabbedThroughDocument
PRInt32 mDOMEventLevel
nsSupportsHashtable * mAccessKeys
nsCOMArray< nsIDocShellmTabbingFromDocShells

Static Protected Attributes

static PRInt32 sUserInputEventDepth = 0

Detailed Description

Definition at line 72 of file nsEventStateManager.h.


Member Enumeration Documentation

Enumerator:
eEventFocusedByUnknown 
eEventFocusedByMouse 
eEventFocusedByKey 
eEventFocusedByContextMenu 
eEventFocusedByApplication 

Definition at line 67 of file nsIEventStateManager.h.

                        {
    eEventFocusedByUnknown,     // focus gained via unknown method
    eEventFocusedByMouse,       // focus gained via mouse
    eEventFocusedByKey,         // focus gained via key press (like tab)
    eEventFocusedByContextMenu, // focus gained via context menu
    eEventFocusedByApplication  // focus gained via Application (like script)
  };
Enumerator:
eAccessKeyProcessingNormal 
eAccessKeyProcessingUp 
eAccessKeyProcessingDown 

Definition at line 220 of file nsEventStateManager.h.

Enumerator:
eScrollByPixel 
eScrollByLine 
eScrollByPage 

Definition at line 255 of file nsEventStateManager.h.


Constructor & Destructor Documentation

Definition at line 331 of file nsEventStateManager.cpp.

{
#if CLICK_HOLD_CONTEXT_MENUS
  KillClickHoldTimer();
#endif

  --sESMInstanceCount;
  if(sESMInstanceCount == 0) {
    NS_IF_RELEASE(gLastFocusedContent);
    NS_IF_RELEASE(gLastFocusedDocument);
  }

  delete mAccessKeys;

  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<nsIObserverService> observerService =
             do_GetService("@mozilla.org/observer-service;1", &rv);
    if (NS_SUCCEEDED(rv)) {
      observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
    }
  }

}

Here is the call graph for this function:


Member Function Documentation

Definition at line 2764 of file nsEventStateManager.cpp.

Here is the caller graph for this function:

Definition at line 300 of file nsEventStateManager.h.

Here is the caller graph for this function:

void nsEventStateManager::BeginTrackingDragGesture ( nsPresContext aPresContext,
nsMouseEvent inDownEvent,
nsIFrame inDownFrame 
) [protected]

Definition at line 1478 of file nsEventStateManager.cpp.

{
  // Note that |inDownEvent| could be either a mouse down event or a
  // synthesized mouse move event.
  nsRect screenPt;
  inDownEvent->widget->WidgetToScreen(nsRect(inDownEvent->refPoint, nsSize(1, 1)),
                                      screenPt);
  mGestureDownPoint = screenPt.TopLeft();

  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
}

Here is the call graph for this function:

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 3241 of file nsEventStateManager.cpp.

{
  mLastFocusedWith = aFocusedWith;
  if (!aFocusContent) {
    SetContentState(nsnull, NS_EVENT_STATE_FOCUS);
    return NS_OK;
  }

  // Get focus controller.
  EnsureDocument(mPresContext);
  nsCOMPtr<nsIFocusController> focusController = nsnull;
  nsCOMPtr<nsPIDOMWindow> window =
    do_QueryInterface(GetDocumentOuterWindow(mDocument));
  if (window)
    focusController = window->GetRootFocusController();

  // If this is called from mouse event, we lock to scroll.
  // Because the part of element is always in view. See bug 105894.
  PRBool suppressFocusScroll =
    focusController && (aFocusedWith == eEventFocusedByMouse);
  if (suppressFocusScroll) {
    PRBool currentState = PR_FALSE;
    focusController->GetSuppressFocusScroll(&currentState);
    NS_ASSERTION(!currentState, "locked scroll already!");
    focusController->SetSuppressFocusScroll(PR_TRUE);
  }

  aFocusContent->SetFocus(mPresContext);
  if (aFocusedWith != eEventFocusedByMouse) {
    MoveCaretToFocus();
    // Select text fields when focused via keyboard (tab or accesskey)
    if (sTextfieldSelectModel == eTextfieldSelect_auto &&
        mCurrentFocus &&
        mCurrentFocus->IsContentOfType(nsIContent::eHTML_FORM_CONTROL)) {
      nsCOMPtr<nsIFormControl> formControl(do_QueryInterface(mCurrentFocus));
      PRInt32 controlType = formControl->GetType();
      if (controlType == NS_FORM_INPUT_TEXT ||
          controlType == NS_FORM_INPUT_PASSWORD) {
        nsCOMPtr<nsIDOMHTMLInputElement> inputElement =
          do_QueryInterface(mCurrentFocus);
        if (inputElement) {
          inputElement->Select();
        }
      }
    }
  }

  // Unlock scroll
  if (suppressFocusScroll)
    focusController->SetSuppressFocusScroll(PR_FALSE);

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1706 of file nsEventStateManager.cpp.

{
  if(!gLastFocusedDocument) return NS_ERROR_FAILURE;

  nsCOMPtr<nsPIDOMWindow> ourWindow =
    do_QueryInterface(GetDocumentOuterWindow(gLastFocusedDocument));
  if(!ourWindow) return NS_ERROR_FAILURE;

  nsIDOMWindowInternal *rootWindow = ourWindow->GetPrivateRoot();
  if(!rootWindow) return NS_ERROR_FAILURE;

  nsCOMPtr<nsIDOMWindow> 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->GetShellAt(0);
  if(!presShell) return NS_ERROR_FAILURE;
  nsPresContext *presContext = presShell->GetPresContext();
  if(!presContext) return NS_ERROR_FAILURE;

  nsCOMPtr<nsISupports> pcContainer = presContext->GetContainer();
  if(!pcContainer) return NS_ERROR_FAILURE;

  nsCOMPtr<nsIDocShell> docshell(do_QueryInterface(pcContainer));
  if(!docshell) return NS_ERROR_FAILURE;

  nsCOMPtr<nsIContentViewer> cv;
  docshell->GetContentViewer(getter_AddRefs(cv));
  if(!cv) return NS_ERROR_FAILURE;

  nsCOMPtr<nsIMarkupDocumentViewer> mv(do_QueryInterface(cv));
  if(!mv) return NS_ERROR_FAILURE;

  float textzoom;
  mv->GetTextZoom(&textzoom);
  textzoom += ((float)change) / 10;
  if (textzoom > 0 && textzoom <= 20)
    mv->SetTextZoom(textzoom);

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsEventStateManager::CheckForAndDispatchClick ( nsPresContext aPresContext,
nsMouseEvent aEvent,
nsEventStatus aStatus 
) [protected]

Definition at line 3164 of file nsEventStateManager.cpp.

{
  nsresult ret = NS_OK;
  PRUint32 eventMsg = 0;
  PRInt32 flags = NS_EVENT_FLAG_INIT;

  //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) {
    //fire click
    switch (aEvent->message) {
    case NS_MOUSE_LEFT_BUTTON_UP:
      eventMsg = NS_MOUSE_LEFT_CLICK;
      break;
    case NS_MOUSE_MIDDLE_BUTTON_UP:
      eventMsg = NS_MOUSE_MIDDLE_CLICK;
      flags |= sLeftClickOnly ? NS_EVENT_FLAG_NO_CONTENT_DISPATCH : NS_EVENT_FLAG_NONE;
      break;
    case NS_MOUSE_RIGHT_BUTTON_UP:
      eventMsg = NS_MOUSE_RIGHT_CLICK;
      flags |= sLeftClickOnly ? NS_EVENT_FLAG_NO_CONTENT_DISPATCH : NS_EVENT_FLAG_NONE;
      break;
    }

    nsMouseEvent event(NS_IS_TRUSTED_EVENT(aEvent), eventMsg, aEvent->widget,
                       nsMouseEvent::eReal);
    event.point = aEvent->point;
    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;

    nsCOMPtr<nsIPresShell> presShell = mPresContext->GetPresShell();
    if (presShell) {
      nsCOMPtr<nsIContent> mouseContent;
      GetEventTargetContent(aEvent, getter_AddRefs(mouseContent));

      ret = presShell->HandleEventWithTarget(&event, mCurrentTarget, mouseContent, flags, aStatus);
      if (NS_SUCCEEDED(ret) && aEvent->clickCount == 2) {
        eventMsg = 0;
        //fire double click
        switch (aEvent->message) {
        case NS_MOUSE_LEFT_BUTTON_UP:
          eventMsg = NS_MOUSE_LEFT_DOUBLECLICK;
          break;
        case NS_MOUSE_MIDDLE_BUTTON_UP:
          eventMsg = NS_MOUSE_MIDDLE_DOUBLECLICK;
          break;
        case NS_MOUSE_RIGHT_BUTTON_UP:
          eventMsg = NS_MOUSE_RIGHT_DOUBLECLICK;
          break;
        }

        nsMouseEvent event2(NS_IS_TRUSTED_EVENT(aEvent), eventMsg,
                            aEvent->widget, nsMouseEvent::eReal);
        event2.point = aEvent->point;
        event2.refPoint = aEvent->refPoint;
        event2.clickCount = aEvent->clickCount;
        event2.isShift = aEvent->isShift;
        event2.isControl = aEvent->isControl;
        event2.isAlt = aEvent->isAlt;
        event2.isMeta = aEvent->isMeta;

        ret = presShell->HandleEventWithTarget(&event2, mCurrentTarget,
                                               mouseContent, flags, aStatus);
      }
    }
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 2516 of file nsEventStateManager.cpp.

Here is the call graph for this function:

NS_IMETHOD nsEventStateManager::ConsumeFocusEvents ( PRBool  aDoConsume) [inline, virtual]

Implements nsIEventStateManager.

Definition at line 127 of file nsEventStateManager.h.

{ mConsumeFocusEvents = aDoConsume; return NS_OK; }

Implements nsIEventStateManager.

Definition at line 4592 of file nsEventStateManager.cpp.

{
  if (mCurrentFocus &&
      nsContentUtils::ContentIsDescendantOf(mCurrentFocus, aContent)) {
    // Note that we don't use SetContentState() here because
    // we don't want to fire a blur.  Blurs should only be fired
    // in response to clicks or tabbing.

    SetFocusedContent(nsnull);
  }

  if (mLastFocus &&
      nsContentUtils::ContentIsDescendantOf(mLastFocus, aContent)) {
    mLastFocus = nsnull;
  }

  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;
}

Here is the call graph for this function:

nsIFrame * nsEventStateManager::DispatchMouseEvent ( nsGUIEvent aEvent,
PRUint32  aMessage,
nsIContent aTargetContent,
nsIContent aRelatedContent 
) [protected]

Turn a GUI mouse event into a mouse event targeted at the specified content.

This returns the primary frame for the content (or null if it goes away during the event).

Definition at line 2773 of file nsEventStateManager.cpp.

{
  nsEventStatus status = nsEventStatus_eIgnore;
  nsMouseEvent event(NS_IS_TRUSTED_EVENT(aEvent), aMessage, aEvent->widget,
                     nsMouseEvent::eReal);
  event.point = aEvent->point;
  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;

  mCurrentTargetContent = aTargetContent;
  mCurrentRelatedContent = aRelatedContent;

  BeforeDispatchEvent();
  nsIFrame* targetFrame = nsnull;
  if (aTargetContent) {
    aTargetContent->HandleDOMEvent(mPresContext, &event, nsnull,
                                   NS_EVENT_FLAG_INIT, &status);

    nsIPresShell *shell = mPresContext->GetPresShell();
    if (shell) {
      shell->GetPrimaryFrameFor(aTargetContent, &targetFrame);
    }
  }
  if (targetFrame) {
    targetFrame->HandleEvent(mPresContext, &event, &status);
    SetFrameExternalReference(targetFrame);
  }
  AfterDispatchEvent();

  mCurrentTargetContent = nsnull;
  mCurrentRelatedContent = nsnull;

  return targetFrame;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NS_IMETHODIMP nsEventStateManager::DispatchNewEvent ( nsISupports *  aTarget,
nsIDOMEvent aEvent,
PRBool aDefaultActionEnabled 
) [virtual]

Implements nsIEventStateManager.

Definition at line 4715 of file nsEventStateManager.cpp.

{
  nsresult ret = NS_OK;

  nsCOMPtr<nsIPrivateDOMEvent> privEvt(do_QueryInterface(aEvent));
  if (privEvt) {
    nsEvent * innerEvent;
    privEvt->GetInternalNSEvent(&innerEvent);

    NS_ENSURE_TRUE(innerEvent, NS_ERROR_ILLEGAL_VALUE);

    // Make sure this event isn't currently in dispatch.
    NS_ENSURE_TRUE(!NS_IS_EVENT_IN_DISPATCH(innerEvent),
                   NS_ERROR_ILLEGAL_VALUE);

    // And make sure this event wasn't already dispatched w/o being
    // re-initialized in between.
    NS_ENSURE_TRUE(!(innerEvent->flags & NS_EVENT_FLAG_STOP_DISPATCH_IMMEDIATELY),
                   NS_ERROR_ILLEGAL_VALUE);

    // Mark this event as dispatched now that we're this far along.
    NS_MARK_EVENT_DISPATCH_STARTED(innerEvent);

    nsCOMPtr<nsIDOMEventTarget> eventTarget(do_QueryInterface(aTarget));
    privEvt->SetTarget(eventTarget);

    PRBool trusted;
    nsCOMPtr<nsIDOMNSEvent> nsevent(do_QueryInterface(privEvt));

    nsevent->GetIsTrusted(&trusted);

    if (!trusted) {
      //Check security state to determine if dispatcher is trusted
      nsIScriptSecurityManager *securityManager =
        nsContentUtils::GetSecurityManager();

      PRBool enabled;
      nsresult res =
        securityManager->IsCapabilityEnabled("UniversalBrowserWrite",
                                             &enabled);
      privEvt->SetTrusted(NS_SUCCEEDED(res) && enabled);
    }

    nsEventStatus status = nsEventStatus_eIgnore;
    nsCOMPtr<nsIScriptGlobalObject> target(do_QueryInterface(aTarget));
    if (target) {
      ret = target->HandleDOMEvent(mPresContext, innerEvent, &aEvent,
                                   NS_EVENT_FLAG_INIT, &status);
    }
    else {
      nsCOMPtr<nsIDocument> target(do_QueryInterface(aTarget));
      if (target) {
        ret = target->HandleDOMEvent(mPresContext, innerEvent, &aEvent,
                                     NS_EVENT_FLAG_INIT, &status);
      }
      else {
        nsCOMPtr<nsIContent> target(do_QueryInterface(aTarget));
        if (target) {
          ret = target->HandleDOMEvent(mPresContext, innerEvent, &aEvent,
                                       NS_EVENT_FLAG_INIT, &status);

          // Dispatch to the system event group.  Make sure to clear
          // the STOP_DISPATCH flag since this resets for each event
          // group per DOM3 Events.

          innerEvent->flags &= ~NS_EVENT_FLAG_STOP_DISPATCH;
          ret = target->HandleDOMEvent(mPresContext, innerEvent, &aEvent,
                                       NS_EVENT_FLAG_INIT |
                                       NS_EVENT_FLAG_SYSTEM_EVENT,
                                       &status);
        }
        else {
          nsCOMPtr<nsIChromeEventHandler> target(do_QueryInterface(aTarget));
          if (target) {
            ret = target->HandleChromeEvent(mPresContext, innerEvent, &aEvent,
                                            NS_EVENT_FLAG_INIT, &status);
          }
        }
      }
    }

    *aDefaultActionEnabled = status != nsEventStatus_eConsumeNoDefault;
  }

  return ret;
}

Here is the call graph for this function:

Definition at line 1752 of file nsEventStateManager.cpp.

{
  nsCOMPtr<nsISupports> pcContainer(mPresContext->GetContainer());
  if (pcContainer) {
    nsCOMPtr<nsIWebNavigation> 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();
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsEventStateManager::DoScrollText ( nsPresContext aPresContext,
nsIFrame aTargetFrame,
nsInputEvent aEvent,
PRInt32  aNumLines,
PRBool  aScrollHorizontal,
ScrollQuantity  aScrollQuantity 
) [protected]

Definition at line 1789 of file nsEventStateManager.cpp.

{
  nsIScrollableView* scrollView = nsnull;
  PRBool scrollRootView = ShouldScrollRootView(aPresContext);

  if (scrollRootView) {
    // Get root scroll view
    nsIViewManager* vm = aPresContext->GetViewManager();
    NS_ENSURE_TRUE(vm, NS_ERROR_FAILURE);
    vm->GetRootScrollableView(&scrollView);
    if (!scrollView) {
      // We don't have root scrollable view in current document.
      // Maybe, this is sub frame on Print Preview.
      // Let's pass to parent document.
      nsIFrame* newFrame = nsnull;
      nsCOMPtr<nsPresContext> newPresContext = nsnull;
      nsresult rv = GetParentScrollingView(aEvent, aPresContext, newFrame,
                                           *getter_AddRefs(newPresContext));
      NS_ENSURE_SUCCESS(rv, rv);
      NS_ENSURE_TRUE(newFrame && newPresContext, NS_ERROR_FAILURE);
      return DoScrollText(newPresContext, newFrame, aEvent, aNumLines,
                          aScrollHorizontal, aScrollQuantity);
    }
    // find target frame that is root scrollable content
    nsIFrame* targetFrame = aTargetFrame;
    for ( ;targetFrame; targetFrame = targetFrame->GetParent()) {
      nsCOMPtr<nsIScrollableViewProvider> svp = do_QueryInterface(targetFrame);
      if (svp && scrollView == svp->GetScrollableView())
        break;
    }
    NS_ENSURE_TRUE(targetFrame, NS_ERROR_FAILURE);
    aTargetFrame = targetFrame;
  }

  nsCOMPtr<nsIContent> targetContent = aTargetFrame->GetContent();
  if (!targetContent)
    GetFocusedContent(getter_AddRefs(targetContent));
  if (!targetContent) return NS_OK;
  nsCOMPtr<nsIDOMDocumentEvent> targetDOMDoc(
                    do_QueryInterface(targetContent->GetDocument()));
  if (!targetDOMDoc) return NS_OK;

  nsCOMPtr<nsIDOMEvent> event;
  targetDOMDoc->CreateEvent(NS_LITERAL_STRING("MouseScrollEvents"), getter_AddRefs(event));
  if (event) {
    nsCOMPtr<nsIDOMMouseEvent> mouseEvent(do_QueryInterface(event));
    nsCOMPtr<nsIDOMDocumentView> docView = do_QueryInterface(targetDOMDoc);
    if (!docView) return NS_ERROR_FAILURE;
    nsCOMPtr<nsIDOMAbstractView> view;
    docView->GetDefaultView(getter_AddRefs(view));

    if (aScrollQuantity == eScrollByPage) {
      if (aNumLines > 0) {
        aNumLines = nsIDOMNSUIEvent::SCROLL_PAGE_DOWN;
      } else {
        aNumLines = nsIDOMNSUIEvent::SCROLL_PAGE_UP;
      }
    }

    mouseEvent->InitMouseEvent(NS_LITERAL_STRING("DOMMouseScroll"),
                               PR_TRUE, PR_TRUE,
                               view, aNumLines,
                               aEvent->refPoint.x, aEvent->refPoint.y,
                               aEvent->point.x,    aEvent->point.y,
                               aEvent->isControl,  aEvent->isAlt,
                               aEvent->isShift,    aEvent->isMeta,
                               0, nsnull);

    nsCOMPtr<nsIPrivateDOMEvent> privateEvent(do_QueryInterface(mouseEvent));

    if (privateEvent && NS_IS_TRUSTED_EVENT(aEvent)) {
      privateEvent->SetTrusted(PR_TRUE);
    }

    nsCOMPtr<nsIDOMEventTarget> target(do_QueryInterface(targetContent));
    if (target) {
      PRBool defaultActionEnabled;
      target->DispatchEvent(event, &defaultActionEnabled);
      if (!defaultActionEnabled)
        return NS_OK;
      if (!scrollRootView) {
        // Re-resolve |aTargetFrame| in case it was destroyed by the
        // DOM event handler above, bug 257998.
        // But only if PresShell is still alive, bug 336587.
        nsIPresShell* shell = aPresContext->GetPresShell();
        aTargetFrame = nsnull;
        if (shell) {
          shell->GetPrimaryFrameFor(targetContent, &aTargetFrame);
        }
        if (!aTargetFrame) {
          // Without a frame we can't do the normal ancestor search for a view
          // to scroll. Don't fall through to the "passToParent" code at the end
          // because that will likely scroll the wrong view (in an enclosing
          // document).
          return NS_OK;
        }
      }
    }
  }

  nsIFrame* scrollFrame = aTargetFrame;
  PRBool passToParent = !scrollRootView;

  for( ; scrollFrame && passToParent; scrollFrame = scrollFrame->GetParent()) {
    // Check whether the frame wants to provide us with a scrollable view.
    scrollView = nsnull;
    nsCOMPtr<nsIScrollableViewProvider> svp = do_QueryInterface(scrollFrame);
    if (svp) {
      scrollView = svp->GetScrollableView();
    }
    if (!scrollView) {
      continue;
    }

    nsPresContext::ScrollbarStyles ss =
      nsLayoutUtils::ScrollbarStylesOfView(scrollView);
    if (NS_STYLE_OVERFLOW_HIDDEN ==
        (aScrollHorizontal ? ss.mHorizontal : ss.mVertical)) {
      continue;
    }
    
    // Check if the scrollable view can be scrolled any further.
    nscoord lineHeight;
    scrollView->GetLineHeight(&lineHeight);

    if (lineHeight != 0) {
      PRBool canScroll;
      nsresult rv = scrollView->CanScroll(aScrollHorizontal,
                                          (aNumLines > 0), canScroll);
      if (NS_SUCCEEDED(rv))
        passToParent = !canScroll;

      // Comboboxes need special care.
      nsIComboboxControlFrame* comboBox = nsnull;
      CallQueryInterface(scrollFrame, &comboBox);
      if (comboBox) {
        PRBool isDroppedDown = PR_FALSE;
        comboBox->IsDroppedDown(&isDroppedDown);
        if (isDroppedDown) {
          // Don't propagate to parent when drop down menu is active.
          if (passToParent) {
            passToParent = PR_FALSE;
            scrollView = nsnull;
          }
        } else {
          // Always propagate when not dropped down (even if focused).
          passToParent = PR_TRUE;
        }
      }
    }
  }

  if (!passToParent && scrollView) {
    PRInt32 scrollX = 0;
    PRInt32 scrollY = aNumLines;

    if (aScrollQuantity == eScrollByPage)
      scrollY = (scrollY > 0) ? 1 : -1;
      
    if (aScrollHorizontal) {
      scrollX = scrollY;
      scrollY = 0;
    }
    
    if (aScrollQuantity == eScrollByPage)
      scrollView->ScrollByPages(scrollX, scrollY);
    else if (aScrollQuantity == eScrollByPixel) {
      // CallQueryInterface doesn't work beacuse nsIScrollableView does not
      // contain QueryInterface.  Casting is fine, because nsScrollPortView
      // is the only class that implements the interface, and it's been
      // updated to implement nsIScrollableView_MOZILLA_1_8_BRANCH.
      nsIScrollableView_MOZILLA_1_8_BRANCH* scrollView_MOZILLA_1_8_BRANCH =
       NS_STATIC_CAST(nsIScrollableView_MOZILLA_1_8_BRANCH*, scrollView);
      scrollView_MOZILLA_1_8_BRANCH->ScrollByPixels(scrollX, scrollY);
    }
    else
      scrollView->ScrollByLines(scrollX, scrollY);

    ForceViewUpdate(scrollView->View());
  }
  if (passToParent) {
    nsresult rv;
    nsIFrame* newFrame = nsnull;
    nsCOMPtr<nsPresContext> newPresContext;

    rv = GetParentScrollingView(aEvent, aPresContext, newFrame,
                                *getter_AddRefs(newPresContext));
    if (NS_SUCCEEDED(rv) && newFrame)
      return DoScrollText(newPresContext, newFrame, aEvent, aNumLines,
                          aScrollHorizontal, aScrollQuantity);
    else
      return NS_ERROR_FAILURE;
  }

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsEventStateManager::DoScrollTextsize ( nsIFrame aTargetFrame,
PRInt32  adjustment 
) [protected]

Definition at line 1768 of file nsEventStateManager.cpp.

{
  // Exclude form controls and XUL content.
  nsIContent *content = aTargetFrame->GetContent();
  if (content &&
      !content->IsContentOfType(nsIContent::eHTML_FORM_CONTROL) &&
      !content->IsContentOfType(nsIContent::eXUL))
    {
      // positive adjustment to increase text size, non-positive to decrease
      ChangeTextSize((adjustment > 0) ? 1 : -1);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsEventStateManager::EnsureDocument ( nsIPresShell aPresShell) [protected]

Definition at line 4812 of file nsEventStateManager.cpp.

{
  if (!mDocument && aPresShell)
    mDocument = aPresShell->GetDocument();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsEventStateManager::EnsureDocument ( nsPresContext aPresContext) [protected]

Definition at line 4805 of file nsEventStateManager.cpp.

{
  if (!mDocument)
    EnsureDocument(aPresContext->PresShell());
}

Here is the call graph for this function:

In certain situations the focus controller's concept of focus gets out of whack with mCurrentFocus.

This is used in known cases to reset the focus controller's focus. At some point we should probably move to a single focus storage mechanism because tracking it in several places is error-prone.

Definition at line 4527 of file nsEventStateManager.cpp.

{
  // Sometimes the focus can get out of whack due to a blur handler
  // resetting focus. In addition, we fire onchange from the blur handler
  // for some controls, which is another place where focus can be changed.
  // XXX Ideally we will eventually store focus in one place instead of
  // the focus controller, esm, tabbrowser and some frames, so that it
  // cannot get out of sync.
  // See Bug 304751, calling FireOnChange() inside
  //                 nsComboboxControlFrame::SetFocus() is bad
  nsCOMPtr<nsPIDOMWindow> currentWindow =
    do_QueryInterface(GetDocumentOuterWindow(mDocument));
  if (currentWindow) {
    nsIFocusController *fc = currentWindow->GetRootFocusController();
    if (fc) {
      nsCOMPtr<nsIDOMElement> focusedElement = do_QueryInterface(mCurrentFocus);
      fc->SetFocusedElement(focusedElement);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 4637 of file nsEventStateManager.cpp.

{
  *aOK = PR_TRUE;
  if (aEvent->message == NS_MOUSE_LEFT_BUTTON_DOWN) {
    if (!mNormalLMouseEventInProcess) {
      *aOK = PR_FALSE;
    }
  }
  return NS_OK;
}

Set the fields of aEvent to reflect the mouse position and modifier keys that were set when the user first pressed the mouse button (stored by BeginTrackingDragGesture).

aEvent->widget must be mCurrentTarget->GetWindow().

Definition at line 1555 of file nsEventStateManager.cpp.

{
  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
  nsRect tmpRect(0, 0, 1, 1);
  aEvent->widget->WidgetToScreen(tmpRect, tmpRect);
  aEvent->refPoint = mGestureDownPoint - tmpRect.TopLeft();
  
  float pixelsToTwips;
  pixelsToTwips = mPresContext->DeviceContext()->DevUnitsToTwips();
  nsPoint refPointTwips(NSIntPixelsToTwips(aEvent->refPoint.x, pixelsToTwips),
                        NSIntPixelsToTwips(aEvent->refPoint.y, pixelsToTwips));

  nsIView* widgetView = mCurrentTarget->GetClosestView();
  nsPoint widgetToView;
#ifdef DEBUG
  nsIWidget* theWidget =
#endif
  widgetView->GetNearestWidget(&widgetToView);
  NS_ASSERTION(theWidget == aEvent->widget, "Widget confusion!");
  nsPoint widgetViewPoint = refPointTwips + widgetToView;

  nsPoint targetToView;
  nsIView* view;
  mCurrentTarget->GetOffsetFromView(targetToView, &view);

  aEvent->point = widgetViewPoint + widgetView->GetOffsetTo(view);

  aEvent->isShift = mGestureDownShift;
  aEvent->isControl = mGestureDownControl;
  aEvent->isAlt = mGestureDownAlt;
  aEvent->isMeta = mGestureDownMeta;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 4819 of file nsEventStateManager.cpp.

{
  NS_PRECONDITION(nsnull != aPresContext, "nsnull ptr");
  nsIPresShell *shell = aPresContext->GetPresShell();
  if (shell) {
    shell->FlushPendingNotifications(Flush_Display);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

The last focus wasn't in this document, so we may be getting our position from the selection while the window focus is currently somewhere else such as the find dialog

Definition at line 4989 of file nsEventStateManager.cpp.

{
  // Focus an element in the current document, but don't switch document/window focus!

  if (gLastFocusedDocument == mDocument) {
    // If we're already focused in this document,
    // use normal focus method
    if (mCurrentFocus != aContent) {
      if (aContent)
        aContent->SetFocus(mPresContext);
      else
        SetContentState(nsnull, NS_EVENT_STATE_FOCUS);
    }
    return;
  }

  nsIFocusController *focusController =
    GetFocusControllerForDocument(mDocument);
  if (!focusController)
      return;

  // Get previous focus
  nsCOMPtr<nsIDOMElement> oldFocusedElement;
  focusController->GetFocusedElement(getter_AddRefs(oldFocusedElement));
  nsCOMPtr<nsIContent> oldFocusedContent(do_QueryInterface(oldFocusedElement));

  // Temporarily set mCurrentFocus so that esm::GetContentState() tells
  // layout system to show focus on this element.
  SetFocusedContent(aContent);  // Reset back to null at the end of this method.
  mDocument->BeginUpdate(UPDATE_CONTENT_STATE);
  mDocument->ContentStatesChanged(oldFocusedContent, aContent,
                                  NS_EVENT_STATE_FOCUS);
  mDocument->EndUpdate(UPDATE_CONTENT_STATE);

  // Reset mCurrentFocus = nsnull for this doc, so when this document
  // does get focus next time via preHandleEvent() NS_GOTFOCUS,
  // the old document gets blurred
  SetFocusedContent(nsnull);

}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 4701 of file nsEventStateManager.cpp.

{
  // 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();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsEventStateManager::GenerateDragDropEnterExit ( nsPresContext aPresContext,
nsGUIEvent aEvent 
) [protected]

Definition at line 2970 of file nsEventStateManager.cpp.

{
  //Hold onto old target content through the event and reset after.
  nsCOMPtr<nsIContent> 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<nsIContent> lastContent;
        nsCOMPtr<nsIContent> targetContent;
        mCurrentTarget->GetContentForEvent(aPresContext, aEvent, getter_AddRefs(targetContent));

        if ( mLastDragOverFrame ) {
          //fire drag exit
          nsEventStatus status = nsEventStatus_eIgnore;
          nsMouseEvent event(NS_IS_TRUSTED_EVENT(aEvent),
                             NS_DRAGDROP_EXIT_SYNTH, aEvent->widget,
                             nsMouseEvent::eReal);
          event.point = aEvent->point;
          event.refPoint = aEvent->refPoint;
          event.isShift = ((nsMouseEvent*)aEvent)->isShift;
          event.isControl = ((nsMouseEvent*)aEvent)->isControl;
          event.isAlt = ((nsMouseEvent*)aEvent)->isAlt;
          event.isMeta = ((nsMouseEvent*)aEvent)->isMeta;

          //The frame has change but the content may not have.  Check before dispatching to content
          mLastDragOverFrame->GetContentForEvent(aPresContext, aEvent, getter_AddRefs(lastContent));

          mCurrentTargetContent = lastContent;
          mCurrentRelatedContent = targetContent;

          if ( lastContent != targetContent ) {
            //XXX This event should still go somewhere!!
            if (lastContent)
              lastContent->HandleDOMEvent(aPresContext, &event, nsnull, NS_EVENT_FLAG_INIT, &status);

            // clear the drag hover
            if (status != nsEventStatus_eConsumeNoDefault )
              SetContentState(nsnull, NS_EVENT_STATE_DRAGOVER);
          }

          // Finally dispatch exit to the frame
          if ( mLastDragOverFrame ) {
            mLastDragOverFrame->HandleEvent(aPresContext, &event, &status);

          }
        }

        //fire drag enter
        nsEventStatus status = nsEventStatus_eIgnore;
        nsMouseEvent event(NS_IS_TRUSTED_EVENT(aEvent), NS_DRAGDROP_ENTER,
                           aEvent->widget, nsMouseEvent::eReal);
        event.point = aEvent->point;
        event.refPoint = aEvent->refPoint;
        event.isShift = ((nsMouseEvent*)aEvent)->isShift;
        event.isControl = ((nsMouseEvent*)aEvent)->isControl;
        event.isAlt = ((nsMouseEvent*)aEvent)->isAlt;
        event.isMeta = ((nsMouseEvent*)aEvent)->isMeta;

        mCurrentTargetContent = targetContent;
        mCurrentRelatedContent = lastContent;

        //The frame has change but the content may not have.  Check before dispatching to content
        if ( lastContent != targetContent ) {
          //XXX This event should still go somewhere!!
          if ( targetContent )
            targetContent->HandleDOMEvent(aPresContext, &event, nsnull, NS_EVENT_FLAG_INIT, &status);

          // set drag hover on this frame
          if ( status != nsEventStatus_eConsumeNoDefault )
            SetContentState(targetContent, NS_EVENT_STATE_DRAGOVER);
        }

        // Finally dispatch to the frame
        if (mCurrentTarget) {
          //XXX Get the new frame
          mCurrentTarget->HandleEvent(aPresContext, &event, &status);
        }

        mLastDragOverFrame = mCurrentTarget;
      }
    }
    break;

  case NS_DRAGDROP_DROP:
  case NS_DRAGDROP_EXIT:
    {
      //This is actually the window mouse exit event.
      if ( mLastDragOverFrame ) {

        // fire mouseout
        nsEventStatus status = nsEventStatus_eIgnore;
        nsMouseEvent event(NS_IS_TRUSTED_EVENT(aEvent), NS_DRAGDROP_EXIT_SYNTH,
                           aEvent->widget, nsMouseEvent::eReal);
        event.point = aEvent->point;
        event.refPoint = aEvent->refPoint;
        event.isShift = ((nsMouseEvent*)aEvent)->isShift;
        event.isControl = ((nsMouseEvent*)aEvent)->isControl;
        event.isAlt = ((nsMouseEvent*)aEvent)->isAlt;
        event.isMeta = ((nsMouseEvent*)aEvent)->isMeta;

        // dispatch to content via DOM
        nsCOMPtr<nsIContent> lastContent;
        mLastDragOverFrame->GetContentForEvent(aPresContext, aEvent, getter_AddRefs(lastContent));

        mCurrentTargetContent = lastContent;
        mCurrentRelatedContent = nsnull;

        if ( lastContent ) {
          lastContent->HandleDOMEvent(aPresContext, &event, nsnull, NS_EVENT_FLAG_INIT, &status);
          if ( status != nsEventStatus_eConsumeNoDefault )
            SetContentState(nsnull, NS_EVENT_STATE_DRAGOVER);
        }

        // Finally dispatch to the frame
        if ( mLastDragOverFrame ) {
          //XXX Get the new frame
          mLastDragOverFrame->HandleEvent(aPresContext, &event, &status);
          mLastDragOverFrame = nsnull;
        }
     }
    }
    break;
  }

  //reset mCurretTargetContent to what it was
  mCurrentTargetContent = targetBeforeEvent;

  // Now flush all pending notifications, for better responsiveness.
  FlushPendingEvents(aPresContext);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsEventStateManager::GenerateDragGesture ( nsPresContext aPresContext,
nsMouseEvent aEvent 
) [protected]

Definition at line 1608 of file nsEventStateManager.cpp.

{
  NS_WARN_IF_FALSE(aPresContext, "This shouldn't happen.");
  if ( IsTrackingDragGesture() ) {
    aPresContext->GetPresShell()->GetPrimaryFrameFor(mGestureDownFrameOwner,
                                                     &mCurrentTarget);
    if (!mCurrentTarget) {
      StopTrackingDragGesture();
      return;
    }

    SetFrameExternalReference(mCurrentTarget);

    // Check if selection is tracking drag gestures, if so
    // don't interfere!
    nsCOMPtr<nsIFrameSelection> frameSel;
    GetSelection ( mCurrentTarget, aPresContext, getter_AddRefs(frameSel) );
    if ( frameSel ) {
      PRBool mouseDownState = PR_TRUE;
      frameSel->GetMouseDownState(&mouseDownState);
      if (mouseDownState) {
        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
    nsRect tmpRect;
    aEvent->widget->WidgetToScreen(nsRect(aEvent->refPoint, nsSize(1, 1)),
                                   tmpRect);
    nsPoint pt = tmpRect.TopLeft();
    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

      nsCOMPtr<nsIContent> targetContent = mGestureDownContent;
      // Stop tracking the drag gesture now. This should stop us from
      // reentering GenerateDragGesture inside DOM event processing.
      StopTrackingDragGesture();

      // get the widget from the target frame
      nsEventStatus status = nsEventStatus_eIgnore;
      nsMouseEvent event(NS_IS_TRUSTED_EVENT(aEvent), NS_DRAGDROP_GESTURE,
                         mCurrentTarget->GetWindow(), nsMouseEvent::eReal);
      FillInEventFromGestureDown(&event);

      // 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<nsIContent> targetBeforeEvent = mCurrentTargetContent;

      // Set the current target to the content for the mouse down
      mCurrentTargetContent = targetContent;

      // Dispatch to DOM
      targetContent->HandleDOMEvent(aPresContext, &event, nsnull,
                                    NS_EVENT_FLAG_INIT, &status);

      // 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

Here is the call graph for this function:

Here is the caller graph for this function:

Synthesize DOM and frame mouseover and mouseout events from this MOUSE_MOVE or MOUSE_EXIT event.

Definition at line 2929 of file nsEventStateManager.cpp.

{
  EnsureDocument(mPresContext);
  if (!mDocument)
    return;

  // Hold onto old target content through the event and reset after.
  nsCOMPtr<nsIContent> targetBeforeEvent = mCurrentTargetContent;

  switch(aEvent->message) {
  case NS_MOUSE_MOVE:
    {
      // Get the target content target (mousemove target == mouseover target)
      nsCOMPtr<nsIContent> 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.
      NotifyMouseOut(aEvent, nsnull);
    }
    break;
  }

  // reset mCurretTargetContent to what it was
  mCurrentTargetContent = targetBeforeEvent;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 5297 of file nsEventStateManager.cpp.

{
  return mBrowseWithCaret;
}
NS_IMETHODIMP nsEventStateManager::GetContentState ( nsIContent aContent,
PRInt32 aState 
) [virtual]

Implements nsIEventStateManager.

Definition at line 3921 of file nsEventStateManager.cpp.

{
  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;
    }
  }

  if (aContent == mCurrentFocus) {
    aState |= NS_EVENT_STATE_FOCUS;
  }
  if (aContent == mDragOverContent) {
    aState |= NS_EVENT_STATE_DRAGOVER;
  }
  if (aContent == mURLTargetContent) {
    aState |= NS_EVENT_STATE_URLTARGET;
  }
  return NS_OK;
}

Here is the call graph for this function:

nsresult nsEventStateManager::GetDocSelectionLocation ( nsIContent **  start,
nsIContent **  end,
nsIFrame **  startFrame,
PRUint32 startOffset 
) [protected]

Definition at line 4829 of file nsEventStateManager.cpp.

{
  // In order to return the nsIContent and nsIFrame of the caret's position,
  // we need to get a pres shell, and then get the selection from it

  *aStartOffset = 0;
  *aStartFrame = nsnull;
  *aStartContent = *aEndContent = nsnull;
  nsresult rv = NS_ERROR_FAILURE;

  NS_ASSERTION(mPresContext, "mPresContent is null!!");
  EnsureDocument(mPresContext);
  if (!mDocument)
    return rv;
  nsIPresShell *shell;
  shell = mPresContext->GetPresShell();

  nsIFrameSelection *frameSelection = nsnull;
  if (shell)
    frameSelection = shell->FrameSelection();

  nsCOMPtr<nsISelection> domSelection;
  if (frameSelection)
    rv = frameSelection->GetSelection(nsISelectionController::SELECTION_NORMAL,
                                      getter_AddRefs(domSelection));

  nsCOMPtr<nsIDOMNode> startNode, endNode;
  PRBool isCollapsed = PR_FALSE;
  nsCOMPtr<nsIContent> startContent, endContent;
  if (domSelection) {
    domSelection->GetIsCollapsed(&isCollapsed);
    nsCOMPtr<nsIDOMRange> domRange;
    rv = domSelection->GetRangeAt(0, getter_AddRefs(domRange));
    if (domRange) {
      domRange->GetStartContainer(getter_AddRefs(startNode));
      domRange->GetEndContainer(getter_AddRefs(endNode));
      domRange->GetStartOffset(NS_REINTERPRET_CAST(PRInt32 *, aStartOffset));

      nsIContent *childContent = nsnull;

      startContent = do_QueryInterface(startNode);
      if (startContent && startContent->IsContentOfType(nsIContent::eELEMENT)) {
        NS_ASSERTION(*aStartOffset >= 0, "Start offset cannot be negative");  
        childContent = startContent->GetChildAt(*aStartOffset);
        if (childContent) {
          startContent = childContent;
        }
      }

      endContent = do_QueryInterface(endNode);
      if (endContent && endContent->IsContentOfType(nsIContent::eELEMENT)) {
        PRInt32 endOffset = 0;
        domRange->GetEndOffset(&endOffset);
        NS_ASSERTION(endOffset >= 0, "End offset cannot be negative");
        childContent = endContent->GetChildAt(endOffset);
        if (childContent) {
          endContent = childContent;
        }
      }
    }
  }

  nsIFrame *startFrame = nsnull;
  if (startContent) {
    rv = shell->GetPrimaryFrameFor(startContent, &startFrame);
    if (isCollapsed && NS_SUCCEEDED(rv)) {
      // First check to see if we're in a <label>
      // We don't want to return the selection in a label, because
      // we we should be tabbing relative to what the label 
      // points to (the current focus), not relative to the label itself.
      nsIContent *parentContent = startContent;
      while ((parentContent = parentContent->GetParent()) != nsnull) {
        if (parentContent->Tag() == nsHTMLAtoms::label) {
          return NS_OK; // Don't return selection location, we're on a label
        }
      }
      // Next check to see if our caret is at the very end of a node
      // If so, the caret is actually sitting in front of the next
      // logical frame's primary node - so for this case we need to
      // change caretContent to that node.

      nsCOMPtr<nsIDOMNode> domNode(do_QueryInterface(startContent));
      PRUint16 nodeType;
      domNode->GetNodeType(&nodeType);

      if (nodeType == nsIDOMNode::TEXT_NODE) {
        nsAutoString nodeValue;
        domNode->GetNodeValue(nodeValue);

        PRBool isFormControl =
          startContent->IsContentOfType(nsIContent::eHTML_FORM_CONTROL);

        if (nodeValue.Length() == *aStartOffset && !isFormControl &&
            startContent != mDocument->GetRootContent()) {
          // Yes, indeed we were at the end of the last node
          nsCOMPtr<nsIBidirectionalEnumerator> frameTraversal;

          nsCOMPtr<nsIFrameTraversal> trav(do_CreateInstance(kFrameTraversalCID,
                                                             &rv));
          NS_ENSURE_SUCCESS(rv, rv);

          rv = trav->NewFrameTraversal(getter_AddRefs(frameTraversal), LEAF,
                                       mPresContext, startFrame);
          NS_ENSURE_SUCCESS(rv, rv);

          nsIFrame *newCaretFrame = nsnull;
          nsCOMPtr<nsIContent> newCaretContent = startContent;
          PRBool endOfSelectionInStartNode(startContent == endContent);
          do {
            // Continue getting the next frame until the primary content for the frame
            // we are on changes - we don't want to be stuck in the same place
            frameTraversal->Next();
            nsISupports* currentItem;
            frameTraversal->CurrentItem(&currentItem);
            if (nsnull == (newCaretFrame = NS_STATIC_CAST(nsIFrame*, currentItem))) {
              break;
            }
            newCaretContent = newCaretFrame->GetContent();            
          } while (!newCaretContent || newCaretContent == startContent);

          if (newCaretFrame && newCaretContent) {
            // If the caret is exactly at the same position of the new frame,
            // then we can use the newCaretFrame and newCaretContent for our position
            nsCOMPtr<nsICaret> caret;
            shell->GetCaret(getter_AddRefs(caret));
            nsRect caretRect;
            nsIView *caretView;
            caret->GetCaretCoordinates(nsICaret::eClosestViewCoordinates, 
                                       domSelection, &caretRect,
                                       &isCollapsed, &caretView);
            nsPoint framePt;
            nsIView *frameClosestView = newCaretFrame->GetClosestView(&framePt);
            if (caretView == frameClosestView && caretRect.y == framePt.y &&
                caretRect.x == framePt.x) {
              // The caret is at the start of the new element.
              startFrame = newCaretFrame;
              startContent = newCaretContent;
              if (endOfSelectionInStartNode) {
                endContent = newCaretContent; // Ensure end of selection is not before start
              }
            }
          }
        }
      }
    }
  }

  *aStartFrame = startFrame;
  *aStartContent = startContent;
  *aEndContent = endContent;
  NS_IF_ADDREF(*aStartContent);
  NS_IF_ADDREF(*aEndContent);

  return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 3913 of file nsEventStateManager.cpp.

{
  *aContent = mCurrentRelatedContent;
  NS_IF_ADDREF(*aContent);
  return NS_OK;
}

Implements nsIEventStateManager.

Definition at line 3846 of file nsEventStateManager.cpp.

{
  if (!mCurrentTarget && mCurrentTargetContent) {
    if (mPresContext) {
      nsIPresShell *shell = mPresContext->GetPresShell();
      if (shell) {
        shell->GetPrimaryFrameFor(mCurrentTargetContent, &mCurrentTarget);

        //This may be new frame that hasn't been through the ESM so we
        //must set its NS_FRAME_EXTERNAL_REFERENCE bit.
        if (mCurrentTarget)
          SetFrameExternalReference(mCurrentTarget);
      }
    }
  }

  if (!mCurrentTarget) {
    nsIPresShell *presShell = mPresContext->GetPresShell();
    if (presShell) {
      presShell->GetEventTargetFrame(&mCurrentTarget);

      //This may be new frame that hasn't been through the ESM so we
      //must set its NS_FRAME_EXTERNAL_REFERENCE bit.
      if (mCurrentTarget)
        SetFrameExternalReference(mCurrentTarget);
    }
  }

  *aFrame = mCurrentTarget;
  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 3879 of file nsEventStateManager.cpp.

{
  if (aEvent &&
      (aEvent->message == NS_FOCUS_CONTENT ||
       aEvent->message == NS_BLUR_CONTENT)) {
    *aContent = mCurrentFocus;
    NS_IF_ADDREF(*aContent);
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 5659 of file nsEventStateManager.cpp.

{
  nsCOMPtr<nsISupports> container = aDocument->GetContainer();
  nsCOMPtr<nsPIDOMWindow> windowPrivate = do_GetInterface(container);

  return windowPrivate ? windowPrivate->GetRootFocusController() : nsnull;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 4520 of file nsEventStateManager.cpp.

{
  *aContent = mCurrentFocus;
  NS_IF_ADDREF(*aContent);
  return NS_OK;
}

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 4573 of file nsEventStateManager.cpp.

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 5495 of file nsEventStateManager.cpp.

{
  NS_ASSERTION(aItem, "null docshell");
  NS_ASSERTION(aResult, "null out pointer");

  nsCOMPtr<nsIDocShellTreeItem> curItem = do_QueryInterface(aItem);
  while (1) {
    nsCOMPtr<nsIDocShellTreeNode> curNode = do_QueryInterface(curItem);
    PRInt32 childCount = 0;
    curNode->GetChildCount(&childCount);
    if (!childCount) {
      *aResult = curItem;
      NS_ADDREF(*aResult);
      return;
    }

    curNode->GetChildAt(childCount - 1, getter_AddRefs(curItem));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 4565 of file nsEventStateManager.cpp.

{
  *aContent = mLastFocus;
  NS_IF_ADDREF(*aContent);
  return NS_OK;
}

Definition at line 5517 of file nsEventStateManager.cpp.

{
  NS_ASSERTION(aNode, "null docshell");
  NS_ASSERTION(aResult, "null out pointer");
  PRInt32 numChildren = 0;

  *aResult = nsnull;

  aNode->GetChildCount(&numChildren);
  if (numChildren) {
    aNode->GetChildAt(0, aResult);
    if (*aResult)
      return;
  }

  nsCOMPtr<nsIDocShellTreeNode> curNode = aNode;
  while (curNode) {
    nsCOMPtr<nsIDocShellTreeItem> curItem = do_QueryInterface(curNode);
    nsCOMPtr<nsIDocShellTreeItem> parentItem;
    curItem->GetParent(getter_AddRefs(parentItem));
    if (!parentItem) {
      *aResult = nsnull;
      return;
    }

    PRInt32 childOffset = 0;
    curItem->GetChildOffset(&childOffset);
    nsCOMPtr<nsIDocShellTreeNode> parentNode = do_QueryInterface(parentItem);
    numChildren = 0;
    parentNode->GetChildCount(&numChildren);
    if (childOffset+1 < numChildren) {
      parentNode->GetChildAt(childOffset+1, aResult);
      if (*aResult)
        return;
    }

    curNode = do_QueryInterface(parentItem);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsEventStateManager::GetNextTabbableContent ( nsIContent aRootContent,
nsIContent aStartContent,
nsIFrame aStartFrame,
PRBool  forward,
PRBool  ignoreTabIndex,
nsIContent **  aResultNode,
nsIFrame **  aResultFrame 
) [protected]

Definition at line 3664 of file nsEventStateManager.cpp.

{
  *aResultNode = nsnull;
  *aResultFrame = nsnull;

  nsresult rv;
  nsCOMPtr<nsIFrameTraversal> trav(do_CreateInstance(kFrameTraversalCID, &rv));
  NS_ENSURE_SUCCESS(rv, rv);
  nsCOMPtr<nsIBidirectionalEnumerator> frameTraversal;

  // --- Get frame to start with ---
  if (!aStartFrame) {
    // No frame means we need to start with the root content again.
    NS_ENSURE_TRUE(mPresContext, NS_ERROR_FAILURE);
    nsIPresShell *presShell = mPresContext->GetPresShell();
    NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
    presShell->GetPrimaryFrameFor(aRootContent, &aStartFrame);
    NS_ENSURE_TRUE(aStartFrame, NS_ERROR_FAILURE);
    rv = trav->NewFrameTraversal(getter_AddRefs(frameTraversal), FOCUS,
                                mPresContext, aStartFrame);
    NS_ENSURE_SUCCESS(rv, rv);
    if (!forward) {
      rv = frameTraversal->Last();
    }
  }
  else {
    rv = trav->NewFrameTraversal(getter_AddRefs(frameTraversal), FOCUS,
                                mPresContext, aStartFrame);
    NS_ENSURE_SUCCESS(rv, rv);
    if (!aStartContent || aStartContent->Tag() != nsHTMLAtoms::area ||
        !aStartContent->IsContentOfType(nsIContent::eHTML)) {
      // Need to do special check in case we're in an imagemap which has multiple
      // content per frame, so don't skip over the starting frame.
      rv = forward ? frameTraversal->Next() : frameTraversal->Prev();
    }
  }

  // -- Walk frames to find something tabbable matching mCurrentTabIndex --
  while (NS_SUCCEEDED(rv)) {
    nsISupports* currentItem;
    frameTraversal->CurrentItem(&currentItem);
    *aResultFrame = (nsIFrame*)currentItem;
    if (!*aResultFrame) {
      break;
    }

    // TabIndex not set defaults to 0 for form elements, anchors and other
    // elements that are normally focusable. Tabindex defaults to -1
    // for elements that are not normally focusable.
    // The returned computed tabindex from IsFocusable() is as follows:
    //          < 0 not tabbable at all
    //          == 0 in normal tab order (last after positive tabindex'd items)
    //          > 0 can be tabbed to in the order specified by this value
    PRInt32 tabIndex;
    nsIContent* currentContent = (*aResultFrame)->GetContent();
    (*aResultFrame)->IsFocusable(&tabIndex);
    if (tabIndex >= 0) {
      if (currentContent->Tag() == nsHTMLAtoms::img &&
          currentContent->HasAttr(kNameSpaceID_None, nsHTMLAtoms::usemap)) {
        // Must be an image w/ a map -- it's tabbable but no tabindex is specified
        // Special case for image maps: they don't get walked by nsIFrameTraversal
        nsIContent *areaContent = GetNextTabbableMapArea(forward, currentContent);
        if (areaContent) {
          NS_ADDREF(*aResultNode = areaContent);
          return NS_OK;
        }
      }
      else if ((aIgnoreTabIndex || mCurrentTabIndex == tabIndex) &&
          currentContent != aStartContent) {
        NS_ADDREF(*aResultNode = currentContent);
        return NS_OK;
      }
    }
    rv = forward ? frameTraversal->Next() : frameTraversal->Prev();
  }

  // -- Reached end or beginning of document --

  // If already at lowest priority tab (0), end search completely.
  // A bit counterintuitive but true, tabindex order goes 1, 2, ... 32767, 0
  if (mCurrentTabIndex == (forward? 0: 1)) {
    return NS_OK;
  }

  // else continue looking for next highest priority tabindex
  mCurrentTabIndex = GetNextTabIndex(aRootContent, forward);
  return GetNextTabbableContent(aRootContent, aStartContent, nsnull, forward,
                                aIgnoreTabIndex, aResultNode, aResultFrame);
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsIContent * nsEventStateManager::GetNextTabbableMapArea ( PRBool  aForward,
nsIContent imageContent 
) [protected]

Definition at line 3761 of file nsEventStateManager.cpp.

{
  nsAutoString useMap;
  aImageContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::usemap, useMap);

  nsCOMPtr<nsIDocument> doc = aImageContent->GetDocument();
  if (doc) {
    nsCOMPtr<nsIDOMHTMLMapElement> imageMap = nsImageMapUtils::FindImageMap(doc, useMap);
    nsCOMPtr<nsIContent> mapContent = do_QueryInterface(imageMap);
    PRUint32 count = mapContent->GetChildCount();
    // First see if mCurrentFocus is in this map
    PRInt32 index = mapContent->IndexOf(mCurrentFocus);
    PRInt32 tabIndex;
    if (index < 0 || (mCurrentFocus->IsFocusable(&tabIndex) &&
                      tabIndex != mCurrentTabIndex)) {
      // If mCurrentFocus is in this map we must start iterating past it.
      // We skip the case where mCurrentFocus has tabindex == mCurrentTabIndex
      // since the next tab ordered element might be before it
      // (or after for backwards) in the child list.
      index = aForward ? -1 : (PRInt32)count;
    }

    // GetChildAt will return nsnull if our index < 0 or index >= count
    nsCOMPtr<nsIContent> areaContent;
    while ((areaContent = mapContent->GetChildAt(aForward? ++index : --index)) != nsnull) {
      if (areaContent->IsFocusable(&tabIndex) && tabIndex == mCurrentTabIndex) {
        return areaContent;
      }
    }
  }

  return nsnull;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PRInt32 nsEventStateManager::GetNextTabIndex ( nsIContent aParent,
PRBool  foward 
) [protected]

Definition at line 3797 of file nsEventStateManager.cpp.

{
  PRInt32 tabIndex, childTabIndex;
  nsIContent *child;

  PRUint32 count = aParent->GetChildCount();

  if (forward) {
    tabIndex = 0;
    for (PRUint32 index = 0; index < count; index++) {
      child = aParent->GetChildAt(index);
      childTabIndex = GetNextTabIndex(child, forward);
      if (childTabIndex > mCurrentTabIndex && childTabIndex != tabIndex) {
        tabIndex = (tabIndex == 0 || childTabIndex < tabIndex) ? childTabIndex : tabIndex;
      }

      nsAutoString tabIndexStr;
      child->GetAttr(kNameSpaceID_None, nsHTMLAtoms::tabindex, tabIndexStr);
      PRInt32 ec, val = tabIndexStr.ToInteger(&ec);
      if (NS_SUCCEEDED (ec) && val > mCurrentTabIndex && val != tabIndex) {
        tabIndex = (tabIndex == 0 || val < tabIndex) ? val : tabIndex;
      }
    }
  }
  else { /* !forward */
    tabIndex = 1;
    for (PRUint32 index = 0; index < count; index++) {
      child = aParent->GetChildAt(index);
      childTabIndex = GetNextTabIndex(child, forward);
      if ((mCurrentTabIndex == 0 && childTabIndex > tabIndex) ||
          (childTabIndex < mCurrentTabIndex && childTabIndex > tabIndex)) {
        tabIndex = childTabIndex;
      }

      nsAutoString tabIndexStr;
      child->GetAttr(kNameSpaceID_None, nsHTMLAtoms::tabindex, tabIndexStr);
      PRInt32 ec, val = tabIndexStr.ToInteger(&ec);
      if (NS_SUCCEEDED (ec)) {
        if ((mCurrentTabIndex == 0 && val > tabIndex) ||
            (val < mCurrentTabIndex && val > tabIndex) ) {
          tabIndex = val;
        }
      }
    }
  }
  return tabIndex;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsEventStateManager::GetParentScrollingView ( nsInputEvent aEvent,
nsPresContext aPresContext,
nsIFrame *&  targetOuterFrame,
nsPresContext *&  presCtxOuter 
) [protected]

Definition at line 1992 of file nsEventStateManager.cpp.

{
  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;
  for (PRUint32 i = 0; i < parentDoc->GetNumberOfShells(); i++) {
    nsIPresShell *tmpPresShell = parentDoc->GetShellAt(i);
    NS_ENSURE_TRUE(tmpPresShell, NS_ERROR_FAILURE);
    NS_ENSURE_TRUE(tmpPresShell->GetPresContext(), NS_ERROR_FAILURE);
    if (tmpPresShell->GetPresContext()->Type() == aPresContext->Type()) {
      pPresShell = tmpPresShell;
      break;
    }
  }
  NS_ENSURE_TRUE(pPresShell, 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 = nsnull;
  pPresShell->GetPrimaryFrameFor(frameContent, &frameFrame);
  if (!frameFrame) return NS_ERROR_FAILURE;

  NS_IF_ADDREF(presCtxOuter = pPresShell->GetPresContext());
  targetOuterFrame = frameFrame;

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 5559 of file nsEventStateManager.cpp.

{
  NS_ASSERTION(aNode, "null docshell");
  NS_ASSERTION(aResult, "null out pointer");

  nsCOMPtr<nsIDocShellTreeNode> curNode = aNode;
  nsCOMPtr<nsIDocShellTreeItem> curItem = do_QueryInterface(curNode);
  nsCOMPtr<nsIDocShellTreeItem> parentItem;

  curItem->GetParent(getter_AddRefs(parentItem));
  if (!parentItem) {
    *aResult = nsnull;
    return;
  }

  PRInt32 childOffset = 0;
  curItem->GetChildOffset(&childOffset);
  if (childOffset) {
    nsCOMPtr<nsIDocShellTreeNode> parentNode = do_QueryInterface(parentItem);
    parentNode->GetChildAt(childOffset - 1, getter_AddRefs(curItem));

    // get the last child recursively of this node
    while (1) {
      PRInt32 childCount = 0;
      curNode = do_QueryInterface(curItem);
      curNode->GetChildCount(&childCount);
      if (!childCount)
        break;

      curNode->GetChildAt(childCount - 1, getter_AddRefs(curItem));
    }

    *aResult = curItem;
    NS_ADDREF(*aResult);
    return;
  }

  *aResult = parentItem;
  NS_ADDREF(*aResult);
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsEventStateManager::GetSelection ( nsIFrame inFrame,
nsPresContext inPresContext,
nsIFrameSelection **  outSelection 
) [protected]

Definition at line 1526 of file nsEventStateManager.cpp.

{
  *outSelection = nsnull;

  if (inFrame) {
    nsCOMPtr<nsISelectionController> selCon;
    nsresult rv = inFrame->GetSelectionController(inPresContext, getter_AddRefs(selCon));

    if (NS_SUCCEEDED(rv) && selCon) {
      nsCOMPtr<nsIFrameSelection> frameSel;

      frameSel = do_QueryInterface(selCon);

      if (! frameSel) {
        nsIPresShell *shell = inPresContext->GetPresShell();
        if (shell)
          frameSel = shell->FrameSelection();
      }

      *outSelection = frameSel.get();
      NS_IF_ADDREF(*outSelection);
    }
  }

} // GetSelection

Here is the call graph for this function:

Here is the caller graph for this function:

void nsEventStateManager::HandleAccessKey ( nsPresContext aPresContext,
nsKeyEvent aEvent,
nsEventStatus aStatus,
PRInt32  aChildOffset,
ProcessingAccessKeyState  aAccessKeyState,
PRInt32  aModifierMask 
) [protected]

Definition at line 1051 of file nsEventStateManager.cpp.

{
  nsCOMPtr<nsISupports> pcContainer = aPresContext->GetContainer();
  NS_ASSERTION(pcContainer, "no container for presContext");
  
  // Alt or other accesskey modifier is down, we may need to do an accesskey
  if (mAccessKeys && aModifierMask == GetAccessModifierMask(pcContainer)) {
    // Someone registered an accesskey.  Find and activate it.
    PRUint32 accKey = (IS_IN_BMP(aEvent->charCode)) ? 
      ToLowerCase((PRUnichar)aEvent->charCode) : aEvent->charCode;

    nsVoidKey key(NS_INT32_TO_PTR(accKey));
    if (mAccessKeys->Exists(&key)) {
      nsCOMPtr<nsIContent> content = dont_AddRef(NS_STATIC_CAST(nsIContent*, mAccessKeys->Get(&key)));

      // if it's a XUL element...
      if (content->IsContentOfType(nsIContent::eXUL)) {
        // find out what type of content node this is
        if (content->Tag() == nsXULAtoms::label) {
          // If anything fails, this will be null ...
          nsCOMPtr<nsIDOMElement> element;

          nsAutoString control;
          content->GetAttr(kNameSpaceID_None, nsXULAtoms::control, control);
          if (!control.IsEmpty()) {
            nsCOMPtr<nsIDOMDocument> domDocument =
              do_QueryInterface(content->GetDocument());
            if (domDocument)
              domDocument->GetElementById(control, getter_AddRefs(element));
          }
          // ... that here we'll either change |content| to the element
          // referenced by |element|, or clear it.
          content = do_QueryInterface(element);
        }

        if (!content)
          return;

        nsIFrame* frame = nsnull;
        aPresContext->PresShell()->GetPrimaryFrameFor(content, &frame);

        if (frame) {
          const nsStyleVisibility* vis = frame->GetStyleVisibility();
          PRBool viewShown = frame->AreAncestorViewsVisible();

          // get the XUL element
          nsCOMPtr<nsIDOMXULElement> element = do_QueryInterface(content);

          // if collapsed or hidden, we don't get tabbed into.
          if (viewShown &&
            vis->mVisible != NS_STYLE_VISIBILITY_COLLAPSE &&
            vis->mVisible != NS_STYLE_VISIBILITY_HIDDEN &&
            element) {

            // find out what type of content node this is
            nsIAtom *atom = content->Tag();

            // define behavior for each type of XUL element:
            if (atom == nsXULAtoms::textbox || atom == nsXULAtoms::menulist) {
              // if it's a text box or menulist, give it focus
              element->Focus();
            } else if (atom == nsXULAtoms::toolbarbutton) {
              // if it's a toolbar button, just click
              element->Click();
            } else {
              // otherwise, focus and click in it
              element->Focus();
              element->Click();
            }
          }
        }
      } else { // otherwise, it must be HTML
        // It's hard to say what HTML4 wants us to do in all cases.
        // So for now we'll settle for A) Set focus (except for <label>s
        // which focus their control in nsHTMLLabelElement::HandleDOMEvent)
        if (content->Tag() != nsHTMLAtoms::label || !sKeyCausesActivation) {
          ChangeFocusWith(content, eEventFocusedByKey);
        }
        if (sKeyCausesActivation) {
          // B) Click on it if the users prefs indicate to do so.

          // Propagate trusted state to the new event.
          nsEventStatus status = nsEventStatus_eIgnore;
          nsMouseEvent event(NS_IS_TRUSTED_EVENT(aEvent), NS_MOUSE_LEFT_CLICK,
                             nsnull, nsMouseEvent::eReal);

          nsAutoPopupStatePusher popupStatePusher(NS_IS_TRUSTED_EVENT(aEvent) ?
                                                  openAllowed : openAbused);

          nsCOMPtr<nsIContent> oldTargetContent = mCurrentTargetContent;
          mCurrentTargetContent = content;
          PRUint32 flags = NS_EVENT_FLAG_INIT;
          content->HandleDOMEvent(mPresContext, &event, nsnull, flags, &status);
          event.flags &= ~NS_EVENT_FLAG_STOP_DISPATCH;
          if (mCurrentTargetContent && mCurrentTargetContent == content) {
            flags |= NS_EVENT_FLAG_SYSTEM_EVENT;
            content->HandleDOMEvent(mPresContext, &event, nsnull, flags,
                                    &status);
          }
          mCurrentTargetContent = oldTargetContent;
        }

      }

      *aStatus = nsEventStatus_eConsumeNoDefault;
    }
  }
  // after the local accesskey handling
  if (nsEventStatus_eConsumeNoDefault != *aStatus) {
    // checking all sub docshells

    nsCOMPtr<nsIDocShellTreeNode> 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
      if (aAccessKeyState == eAccessKeyProcessingUp && counter == aChildOffset)
        continue;

      nsCOMPtr<nsIDocShellTreeItem> subShellItem;
      nsCOMPtr<nsIPresShell> subPS;
      nsCOMPtr<nsPresContext> subPC;

      docShell->GetChildAt(counter, getter_AddRefs(subShellItem));
      nsCOMPtr<nsIDocShell> subDS = do_QueryInterface(subShellItem);
      if (subDS && IsShellVisible(subDS)) {
        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 =
          NS_STATIC_CAST(nsEventStateManager *, subPC->EventStateManager());

        if (esm)
          esm->HandleAccessKey(subPC, aEvent, aStatus, -1,
                               eAccessKeyProcessingDown, aModifierMask);

        if (nsEventStatus_eConsumeNoDefault == *aStatus)
          break;
      }
    }
  }// if end . checking all sub docshell ends here.

  // bubble up the process to the parent docShell if necesary
  if (eAccessKeyProcessingDown != aAccessKeyState && nsEventStatus_eConsumeNoDefault != *aStatus) {
    nsCOMPtr<nsIDocShellTreeItem> docShell(do_QueryInterface(pcContainer));
    if (!docShell) {
      NS_WARNING("no docShellTreeNode for presContext");
      return;
    }

    nsCOMPtr<nsIDocShellTreeItem> parentShellItem;
    docShell->GetParent(getter_AddRefs(parentShellItem));
    nsCOMPtr<nsIDocShell> parentDS = do_QueryInterface(parentShellItem);
    if (parentDS) {
      PRInt32 myOffset;
      docShell->GetChildOffset(&myOffset);

      nsCOMPtr<nsIPresShell> 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 =
        NS_STATIC_CAST(nsEventStateManager *, parentPC->EventStateManager());

      if (esm)
        esm->HandleAccessKey(parentPC, aEvent, aStatus, myOffset,
                             eAccessKeyProcessingUp, aModifierMask);
    }
  }// if end. bubble up process
}// end of HandleAccessKey

Here is the call graph for this function:

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 267 of file nsEventStateManager.cpp.

{
  nsresult rv;
  nsCOMPtr<nsIObserverService> 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<nsIPrefBranch2> 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);

      nsIContent::sTabFocusModelAppliesToXUL =
        nsContentUtils::GetBoolPref("accessibility.tabfocus_applies_to_xul",
                                    nsIContent::sTabFocusModelAppliesToXUL);
    }
    prefBranch->AddObserver("accessibility.accesskeycausesactivation", this, PR_TRUE);
    prefBranch->AddObserver("accessibility.browsewithcaret", this, PR_TRUE);
    prefBranch->AddObserver("accessibility.tabfocus_applies_to_xul", 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);
  }

  if (sTextfieldSelectModel == eTextfieldSelect_unset) {
    nsCOMPtr<nsILookAndFeel> lookNFeel(do_GetService(kLookAndFeelCID));
    PRInt32 selectTextfieldsOnKeyFocus = 0;
    lookNFeel->GetMetric(nsILookAndFeel::eMetric_SelectTextfieldsOnKeyFocus,
                         selectTextfieldsOnKeyFocus);
    sTextfieldSelectModel = selectTextfieldsOnKeyFocus ? eTextfieldSelect_auto:
                                                         eTextfieldSelect_manual;
  }

  return rv;
}

Here is the call graph for this function:

Definition at line 5354 of file nsEventStateManager.cpp.

{
  NS_ASSERTION(aDocShell, "docshell is null");
  PRBool isFrameSet = PR_FALSE;

  // a frameset element will always be the immediate child
  // of the root content (the HTML tag)
  nsCOMPtr<nsIPresShell> presShell;
  aDocShell->GetPresShell(getter_AddRefs(presShell));
  if (presShell) {
    nsIDocument *doc = presShell->GetDocument();
    nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(doc);
    if (htmlDoc) {
      nsIContent *rootContent = doc->GetRootContent();
      if (rootContent) {
        PRUint32 childCount = rootContent->GetChildCount();
        for (PRUint32 i = 0; i < childCount; ++i) {
          nsIContent *childContent = rootContent->GetChildAt(i);

          nsINodeInfo *ni = childContent->GetNodeInfo();

          if (childContent->IsContentOfType(nsIContent::eHTML) &&
              ni->Equals(nsHTMLAtoms::frameset)) {
            isFrameSet = PR_TRUE;
            break;
          }
        }
      }
    }
  }

  return isFrameSet;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PRBool nsEventStateManager::IsHandlingUserInput ( ) [inline, static]

Definition at line 159 of file nsEventStateManager.h.

  {
    return sUserInputEventDepth > 0;
  }

Here is the caller graph for this function:

PRBool nsEventStateManager::IsIFrameDoc ( nsIDocShell aDocShell) [protected]

Definition at line 5392 of file nsEventStateManager.cpp.

{
  NS_ASSERTION(aDocShell, "docshell is null");

  nsCOMPtr<nsPIDOMWindow> domWindow = do_GetInterface(aDocShell);
  if (!domWindow) {
    NS_ERROR("We're a child of a docshell without a window?");
    return PR_FALSE;
  }

  nsCOMPtr<nsIContent> docContent =
    do_QueryInterface(domWindow->GetFrameElementInternal());

  if (!docContent) {
    return PR_FALSE;
  }

  return docContent->Tag() == nsHTMLAtoms::iframe;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 5416 of file nsEventStateManager.cpp.

{
  NS_ASSERTION(aShell, "docshell is null");

  nsCOMPtr<nsIBaseWindow> 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PRBool nsEventStateManager::IsTrackingDragGesture ( ) const [inline, protected]

Definition at line 277 of file nsEventStateManager.h.

{ return mGestureDownContent != nsnull; }

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 5168 of file nsEventStateManager.cpp.

{
  // If in HTML content and the pref accessibility.browsewithcaret is TRUE,
  // then always move the caret to beginning of a new focus

  PRInt32 itemType = nsIDocShellTreeItem::typeChrome;

  if (mPresContext) {
    nsCOMPtr<nsISupports> pcContainer = mPresContext->GetContainer();
    nsCOMPtr<nsIDocShellTreeItem> treeItem(do_QueryInterface(pcContainer));
    if (treeItem)
      treeItem->GetItemType(&itemType);
    nsCOMPtr<nsIEditorDocShell> editorDocShell(do_QueryInterface(treeItem));
    if (editorDocShell) {
      PRBool isEditable;
      editorDocShell->GetEditable(&isEditable);
      if (isEditable) {
        return NS_OK;  // Move focus to caret only if browsing, not editing
      }
    }
  }

  if (itemType != nsIDocShellTreeItem::typeChrome) {
    nsCOMPtr<nsIContent> selectionContent, endSelectionContent;
    nsIFrame *selectionFrame;
    PRUint32 selectionOffset;
    GetDocSelectionLocation(getter_AddRefs(selectionContent),
                            getter_AddRefs(endSelectionContent),
                            &selectionFrame, &selectionOffset);

    nsIPresShell *shell = mPresContext->GetPresShell();
    if (shell) {
      // rangeDoc is a document interface we can create a range with
      nsCOMPtr<nsIDOMDocumentRange> rangeDoc(do_QueryInterface(mDocument));

      if (rangeDoc) {
        nsCOMPtr<nsISelection> domSelection;
        shell->FrameSelection()->
          GetSelection(nsISelectionController::SELECTION_NORMAL,
                       getter_AddRefs(domSelection));
        if (domSelection) {
          nsCOMPtr<nsIDOMNode> currentFocusNode(do_QueryInterface(mCurrentFocus));
          // First clear the selection
          domSelection->RemoveAllRanges();
          if (currentFocusNode) {
            nsCOMPtr<nsIDOMRange> newRange;
            nsresult rv = rangeDoc->CreateRange(getter_AddRefs(newRange));
            if (NS_SUCCEEDED(rv)) {
              // Set the range to the start of the currently focused node
              // Make sure it's collapsed
              newRange->SelectNodeContents(currentFocusNode);
              nsCOMPtr<nsIDOMNode> firstChild;
              currentFocusNode->GetFirstChild(getter_AddRefs(firstChild));
              if (!firstChild ||
                  mCurrentFocus->IsContentOfType(nsIContent::eHTML_FORM_CONTROL)) {
                // If current focus node is a leaf, set range to before the
                // node by using the parent as a container.
                // This prevents it from appearing as selected.
                newRange->SetStartBefore(currentFocusNode);
                newRange->SetEndBefore(currentFocusNode);
              }
              domSelection->AddRange(newRange);
              domSelection->CollapseToStart();
            }
          }
        }
      }
    }
  }
  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NS_IMETHODIMP nsEventStateManager::MoveFocusToCaret ( PRBool  aCanFocusDoc,
PRBool aIsSelectionWithFocus 
) [virtual]

Implements nsIEventStateManager.

Definition at line 5036 of file nsEventStateManager.cpp.

{
  // mBrowseWithCaret equals the pref accessibility.browsewithcaret
  // When it's true, the user can arrow around the browser as if it's a
  // read only text editor.

  // If the user cursors over a focusable element or gets there with find text, then send focus to it

  *aIsSelectionWithFocus= PR_FALSE;
  nsCOMPtr<nsIContent> selectionContent, endSelectionContent;
  nsIFrame *selectionFrame;
  PRUint32 selectionOffset;
  GetDocSelectionLocation(getter_AddRefs(selectionContent), getter_AddRefs(endSelectionContent),
    &selectionFrame, &selectionOffset);

  if (!selectionContent)
    return NS_ERROR_FAILURE;

  nsCOMPtr<nsIContent> testContent(selectionContent);
  nsCOMPtr<nsIContent> nextTestContent(endSelectionContent);

  // We now have the correct start node in selectionContent!
  // Search for focusable elements, starting with selectionContent

  // Method #1: Keep going up while we look - an ancestor might be focusable
  // We could end the loop earlier, such as when we're no longer
  // in the same frame, by comparing getPrimaryFrameFor(selectionContent)
  // with a variable holding the starting selectionContent
  while (testContent) {
    // Keep testing while selectionContent is equal to something,
    // eventually we'll run out of ancestors

    if (testContent == mCurrentFocus) {
      *aIsSelectionWithFocus = PR_TRUE;
      return NS_OK;  // already focused on this node, this whole thing's moot
    }

    nsIAtom *tag = testContent->Tag();

    // Add better focusable test here later if necessary ...
    if (tag == nsHTMLAtoms::a &&
        testContent->IsContentOfType(nsIContent::eHTML)) {
      *aIsSelectionWithFocus = PR_TRUE;
    }
    else {
      *aIsSelectionWithFocus = testContent->HasAttr(kNameSpaceID_XLink, nsHTMLAtoms::href);
      if (*aIsSelectionWithFocus) {
        nsAutoString xlinkType;
        testContent->GetAttr(kNameSpaceID_XLink, nsHTMLAtoms::type, xlinkType);
        if (!xlinkType.EqualsLiteral("simple")) {
          *aIsSelectionWithFocus = PR_FALSE;  // Xlink must be type="simple"
        }
      }
    }

    if (*aIsSelectionWithFocus) {
      FocusElementButNotDocument(testContent);
      return NS_OK;
    }

    // Get the parent
    testContent = testContent->GetParent();

    if (!testContent) {
      // We run this loop again, checking the ancestor chain of the selection's end point
      testContent = nextTestContent;
      nextTestContent = nsnull;
    }
  }

  // We couldn't find an anchor that was an ancestor of the selection start
  // Method #2: look for anchor in selection's primary range (depth first search)

  // Turn into nodes so that we can use GetNextSibling() and GetFirstChild()
  nsCOMPtr<nsIDOMNode> selectionNode(do_QueryInterface(selectionContent));
  nsCOMPtr<nsIDOMNode> endSelectionNode(do_QueryInterface(endSelectionContent));
  nsCOMPtr<nsIDOMNode> testNode;

  do {
    testContent = do_QueryInterface(selectionNode);

    // We're looking for any focusable item that could be part of the
    // main document's selection.
    // Right now we only look for elements with the <a> tag.
    // Add better focusable test here later if necessary ...
    if (testContent) {
      if (testContent->Tag() == nsHTMLAtoms::a &&
          testContent->IsContentOfType(nsIContent::eHTML)) {
        *aIsSelectionWithFocus = PR_TRUE;
        FocusElementButNotDocument(testContent);
        return NS_OK;
      }
    }

    selectionNode->GetFirstChild(getter_AddRefs(testNode));
    if (testNode) {
      selectionNode = testNode;
      continue;
    }

    if (selectionNode == endSelectionNode)
      break;
    selectionNode->GetNextSibling(getter_AddRefs(testNode));
    if (testNode) {
      selectionNode = testNode;
      continue;
    }

    do {
      selectionNode->GetParentNode(getter_AddRefs(testNode));
      if (!testNode || testNode == endSelectionNode) {
        selectionNode = nsnull;
        break;
      }
      testNode->GetNextSibling(getter_AddRefs(selectionNode));
      if (selectionNode)
        break;
      selectionNode = testNode;
    } while (PR_TRUE);
  }
  while (selectionNode && selectionNode != endSelectionNode);

  if (aCanFocusDoc)
    FocusElementButNotDocument(nsnull);

  return NS_OK; // no errors, but caret not inside focusable element other than doc itself
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsEventStateManager::NotifyMouseOut ( nsGUIEvent aEvent,
nsIContent aMovingInto 
) [protected]

Tell this ESM and ESMs in affected child documents that the mouse has exited this document's currently hovered content.

Parameters:
aEventthe event that triggered the mouseout
aMovingIntothe content node we've moved into. This is used to set the relatedTarget for mouseout events. Also, if it's non-null NotifyMouseOut will NOT change the current hover content to null; in that case the caller is responsible for updating hover state.

Definition at line 2815 of file nsEventStateManager.cpp.

{
  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;
    CallQueryInterface(mLastMouseOverFrame, &subdocFrame);
    if (subdocFrame) {
      nsCOMPtr<nsIDocShell> docshell;
      subdocFrame->GetDocShell(getter_AddRefs(docshell));
      if (docshell) {
        nsCOMPtr<nsPresContext> presContext;
        docshell->GetPresContext(getter_AddRefs(presContext));
        
        if (presContext) {
          nsEventStateManager* kidESM =
            NS_STATIC_CAST(nsEventStateManager*, 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsEventStateManager::NotifyMouseOver ( nsGUIEvent aEvent,
nsIContent aContent 
) [protected]

Tell this ESM and ESMs in parent documents that the mouse is over some content in this document.

Definition at line 2874 of file nsEventStateManager.cpp.

{
  NS_ASSERTION(aContent, "Mouse must be over something");

  if (mLastMouseOverElement == aContent)
    return;

  // Before firing mouseover, check for recursion
  if (aContent == mFirstMouseOverEventElement && 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->GetShellAt(0);
      if (parentShell) {
        nsEventStateManager* parentESM =
          NS_STATIC_CAST(nsEventStateManager*,
                         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<nsIContent> 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsIObserver::observe ( in nsISupports  aSubject,
in string  aTopic,
in wstring  aData 
) [inherited]

Observe will be called when there is a notification for the topic |aTopic|.

This assumes that the object implementing this interface has been registered with an observer service such as the nsIObserverService.

If you expect multiple topics/subjects, the impl is responsible for filtering.

You should not modify, add, remove, or enumerate notifications in the implemention of observe.

Parameters:
aSubject: Notification specific interface pointer.
aTopic: The notification topic or subject.
aData: Notification specific wide string. subject event.
NS_IMETHODIMP nsEventStateManager::PostHandleEvent ( nsPresContext aPresContext,
nsEvent aEvent,
nsIFrame aTargetFrame,
nsEventStatus aStatus,
nsIView aView 
) [virtual]

Implements nsIEventStateManager.

Definition at line 2047 of file nsEventStateManager.cpp.

{
  NS_ENSURE_ARG(aPresContext);
  NS_ENSURE_ARG_POINTER(aStatus);
  mCurrentTarget = aTargetFrame;
  mCurrentTargetContent = nsnull;
  nsresult ret = NS_OK;
  //Keep the prescontext alive, we might need it after event dispatch
  nsRefPtr<nsPresContext> presContext = aPresContext;

  NS_ASSERTION(mCurrentTarget, "mCurrentTarget is null");
  if (!mCurrentTarget) return NS_ERROR_NULL_POINTER;

  SetFrameExternalReference(mCurrentTarget);

  switch (aEvent->message) {
  case NS_MOUSE_LEFT_BUTTON_DOWN:
  case NS_MOUSE_MIDDLE_BUTTON_DOWN:
  case NS_MOUSE_RIGHT_BUTTON_DOWN:
    {
      if (aEvent->message == NS_MOUSE_LEFT_BUTTON_DOWN && !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 (mConsumeFocusEvents) {
        mConsumeFocusEvents = PR_FALSE;
        break;
      }

      if (nsEventStatus_eConsumeNoDefault != *aStatus) {
        nsCOMPtr<nsIContent> newFocus;
        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);
        }

        nsIFrame* currFrame = mCurrentTarget;
        nsIContent* activeContent = nsnull;
        if (mCurrentTarget)
          activeContent = mCurrentTarget->GetContent();

        // Look for the nearest enclosing focusable frame.
        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<nsIDOMElement> domElement(do_QueryInterface(newFocus));
            if (domElement)
              break;
          }
          currFrame = currFrame->GetParent();
        }

        if (newFocus && currFrame)
          ChangeFocusWith(newFocus, eEventFocusedByMouse);
        else if (!suppressBlur) {
          SetContentState(nsnull, NS_EVENT_STATE_FOCUS);
        }

        // The rest is left button-specific.
        if (aEvent->message != NS_MOUSE_LEFT_BUTTON_DOWN)
          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<nsIDOMElement> 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_LEFT_BUTTON_UP:
  case NS_MOUSE_MIDDLE_BUTTON_UP:
  case NS_MOUSE_RIGHT_BUTTON_UP:
    {
      SetContentState(nsnull, NS_EVENT_STATE_ACTIVE);
      if (!mCurrentTarget) {
        nsIFrame* targ;
        GetEventTarget(&targ);
        if (!targ) return NS_ERROR_FAILURE;
      }
      ret = CheckForAndDispatchClick(presContext, (nsMouseEvent*)aEvent, aStatus);
      nsIPresShell *shell = presContext->GetPresShell();
      if (shell) {
        shell->FrameSelection()->SetMouseDownState(PR_FALSE);
      }
    }
    break;
  case NS_MOUSE_SCROLL:
    if (nsEventStatus_eConsumeNoDefault != *aStatus) {

      // Build the preference keys, based on the event properties.
      nsMouseScrollEvent *msEvent = (nsMouseScrollEvent*) aEvent;

      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");
      NS_NAMED_LITERAL_CSTRING(actionslot,      ".action");
      NS_NAMED_LITERAL_CSTRING(numlinesslot,    ".numlines");
      NS_NAMED_LITERAL_CSTRING(sysnumlinesslot, ".sysnumlines");

      nsCAutoString baseKey(prefbase);
      if (msEvent->scrollFlags & nsMouseScrollEvent::kIsHorizontal) {
        baseKey.Append(horizscroll);
      }
      if (msEvent->isShift) {
        baseKey.Append(withshift);
      } else if (msEvent->isControl) {
        baseKey.Append(withcontrol);
      } else if (msEvent->isAlt) {
        baseKey.Append(withalt);
      } else if (msEvent->isMeta) {
        baseKey.Append(withmetakey);
      } else {
        baseKey.Append(withno);
      }

      // Extract the preferences
      nsCAutoString actionKey(baseKey);
      actionKey.Append(actionslot);

      nsCAutoString sysNumLinesKey(baseKey);
      sysNumLinesKey.Append(sysnumlinesslot);

      PRInt32 action = nsContentUtils::GetIntPref(actionKey.get());
      PRInt32 numLines = 0;
      PRBool useSysNumLines =
        nsContentUtils::GetBoolPref(sysNumLinesKey.get());

      if (useSysNumLines) {
        numLines = msEvent->delta;
        if (msEvent->scrollFlags & nsMouseScrollEvent::kIsFullPage)
          action = MOUSE_SCROLL_PAGE;
        else if (msEvent->scrollFlags & nsMouseScrollEvent::kIsPixels)
          action = MOUSE_SCROLL_PIXELS;
      }
      else
        {
          // 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);

          numLines = nsContentUtils::GetIntPref(numLinesKey.get());

          bool swapDirs = (numLines < 0);
          PRInt32 userSize = swapDirs ? -numLines : numLines;

          PRInt32 deltaUp = (msEvent->delta < 0);
          if (swapDirs) {
            deltaUp = ! deltaUp;
          }

          numLines = deltaUp ? -userSize : userSize;
        }

      switch (action) {
      case MOUSE_SCROLL_N_LINES:
        {
          DoScrollText(presContext, aTargetFrame, msEvent, numLines,
                       (msEvent->scrollFlags & nsMouseScrollEvent::kIsHorizontal),
                       eScrollByLine);
        }
        break;

      case MOUSE_SCROLL_PAGE:
        {
          DoScrollText(presContext, aTargetFrame, msEvent, numLines,
                       (msEvent->scrollFlags & nsMouseScrollEvent::kIsHorizontal),
                       eScrollByPage);
        }
        break;

      case MOUSE_SCROLL_PIXELS:
        {
          DoScrollText(presContext, aTargetFrame, msEvent, numLines,
                       (msEvent->scrollFlags & nsMouseScrollEvent::kIsHorizontal),
                       eScrollByPixel);
        }
        break;

      case MOUSE_SCROLL_HISTORY:
        {
          DoScrollHistory(numLines);
        }
        break;

      case MOUSE_SCROLL_TEXTSIZE:
        {
          DoScrollTextsize(aTargetFrame, numLines);
        }
        break;

      default:  // Including -1 (do nothing)
        break;
      }
      *aStatus = nsEventStatus_eConsumeNoDefault;

    }

    break;

  case NS_DRAGDROP_DROP:
  case NS_DRAGDROP_EXIT:
    // clean up after ourselves. make sure we do this _after_ the event, else 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:
            if (mConsumeFocusEvents) {
              mConsumeFocusEvents = PR_FALSE;
              break;
            }
            if (!((nsInputEvent*)aEvent)->isControl) {
              //Shift focus forward or back depending on shift key
              ShiftFocus(!((nsInputEvent*)aEvent)->isShift);
            } else {
              ShiftFocusByDoc(!((nsInputEvent*)aEvent)->isShift);
            }
            *aStatus = nsEventStatus_eConsumeNoDefault;
            break;

          case NS_VK_F6:
            if (mConsumeFocusEvents) {
              mConsumeFocusEvents = PR_FALSE;
              break;
            }
            //Shift focus forward or back depending on shift key
            ShiftFocusByDoc(!((nsInputEvent*)aEvent)->isShift);
            *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 (!mCurrentFocus) {
              nsIScrollableView* sv = nsLayoutUtils::GetNearestScrollingView(aView, nsLayoutUtils::eVertical);
              if (sv) {
                nsKeyEvent * keyEvent = (nsKeyEvent *)aEvent;
                sv->ScrollByPages(0, (keyEvent->keyCode != NS_VK_PAGE_UP) ? 1 : -1);
              }
            }
            break;
          case NS_VK_HOME:
          case NS_VK_END:
            if (!mCurrentFocus) {
              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 (!mCurrentFocus) {
              nsIScrollableView* sv = nsLayoutUtils::GetNearestScrollingView(aView, nsLayoutUtils::eVertical);
              if (sv) {
                nsKeyEvent * keyEvent = (nsKeyEvent *)aEvent;
                sv->ScrollByLines(0, (keyEvent->keyCode == NS_VK_DOWN) ? 1 : -1);

                // 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 (!mCurrentFocus) {
              nsIScrollableView* sv = nsLayoutUtils::GetNearestScrollingView(aView, nsLayoutUtils::eHorizontal);
              if (sv) {
                nsKeyEvent * keyEvent = (nsKeyEvent *)aEvent;
                sv->ScrollByLines((keyEvent->keyCode == NS_VK_RIGHT) ? 1 : -1, 0);

                // 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 (!mCurrentFocus) {
                nsIScrollableView* sv = nsLayoutUtils::GetNearestScrollingView(aView, nsLayoutUtils::eVertical);
                if (sv) {
                  sv->ScrollByPages(0, 1);
                }
              }
            }
          }
          break;
#endif //NON_KEYBINDING
        }
      }
    }
    break;

  case NS_MOUSE_ENTER:
    if (mCurrentTarget) {
      nsCOMPtr<nsIContent> targetContent;
      mCurrentTarget->GetContentForEvent(presContext, aEvent,
                                         getter_AddRefs(targetContent));
      SetContentState(targetContent, NS_EVENT_STATE_HOVER);
    }
    break;

  //
  // OS custom application event, such as from MS IntelliMouse
  //
  case NS_APPCOMMAND:
    // by default, tell the driver we're not handling the event
    ret = PR_FALSE;

    nsAppCommandEvent* appCommandEvent = (nsAppCommandEvent*) aEvent;

    nsCOMPtr<nsISupports> pcContainer;
    switch (appCommandEvent->appCommand) {
      case NS_APPCOMMAND_BACK:
      case NS_APPCOMMAND_FORWARD:
      case NS_APPCOMMAND_REFRESH:
      case NS_APPCOMMAND_STOP:
        // handle these commands using nsIWebNavigation
        pcContainer = mPresContext->GetContainer();
        if (pcContainer) {
          nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(pcContainer));
          if (webNav) {
            // tell the driver we're handling the event
            ret = PR_TRUE;

            switch (appCommandEvent->appCommand) {
              case NS_APPCOMMAND_BACK:
                webNav->GoBack();
                break;

              case NS_APPCOMMAND_FORWARD:
                webNav->GoForward();
                break;

              case NS_APPCOMMAND_REFRESH:
                webNav->Reload(nsIWebNavigation::LOAD_FLAGS_BYPASS_CACHE);
                break;

              case NS_APPCOMMAND_STOP:
                webNav->Stop(nsIWebNavigation::STOP_ALL);
                break;

            }  // switch (appCommandEvent->appCommand)
          }  // if (webNav)
        }  // if (pcContainer)
        break;

      // XXX todo: handle these commands
      // case NS_APPCOMMAND_SEARCH:
      // case NS_APPCOMMAND_FAVORITES:
      // case NS_APPCOMMAND_HOME:

        // tell the driver we're handling the event
        // ret = PR_TRUE;
        // break;

    }  // switch (appCommandEvent->appCommand)

    break;
  }

  //Reset target frame to null to avoid mistargeting after reentrant event
  mCurrentTarget = nsnull;

  return ret;
}

Here is the call graph for this function:

NS_IMETHODIMP nsEventStateManager::PreHandleEvent ( nsPresContext aPresContext,
nsEvent aEvent,
nsIFrame aTargetFrame,
nsEventStatus aStatus,
nsIView aView 
) [virtual]

Implements nsIEventStateManager.

Definition at line 468 of file nsEventStateManager.cpp.

{
  NS_ENSURE_ARG_POINTER(aStatus);
  NS_ENSURE_ARG(aPresContext);

  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;
  }

  if (mCurrentTarget)
    SetFrameExternalReference(mCurrentTarget);

  *aStatus = nsEventStatus_eIgnore;

  if (!aEvent) {
    NS_ERROR("aEvent is null.  This should never happen.");
    return NS_ERROR_NULL_POINTER;
  }

  switch (aEvent->message) {
  case NS_MOUSE_LEFT_BUTTON_DOWN:
#ifndef XP_OS2
    BeginTrackingDragGesture ( aPresContext, (nsMouseEvent*)aEvent, aTargetFrame );
#endif
    mLClickCount = ((nsMouseEvent*)aEvent)->clickCount;
    SetClickCount(aPresContext, (nsMouseEvent*)aEvent, aStatus);
    mNormalLMouseEventInProcess = PR_TRUE;
    break;
  case NS_MOUSE_MIDDLE_BUTTON_DOWN:
    mMClickCount = ((nsMouseEvent*)aEvent)->clickCount;
    SetClickCount(aPresContext, (nsMouseEvent*)aEvent, aStatus);
    break;
  case NS_MOUSE_RIGHT_BUTTON_DOWN:
#ifdef XP_OS2
    BeginTrackingDragGesture ( aPresContext, (nsMouseEvent*)aEvent, aTargetFrame );
#endif
    mRClickCount = ((nsMouseEvent*)aEvent)->clickCount;
    SetClickCount(aPresContext, (nsMouseEvent*)aEvent, aStatus);
    break;
  case NS_MOUSE_LEFT_BUTTON_UP:
#ifdef CLICK_HOLD_CONTEXT_MENUS
    KillClickHoldTimer();
#endif
#ifndef XP_OS2
    StopTrackingDragGesture();
#endif
    mNormalLMouseEventInProcess = PR_FALSE;
  case NS_MOUSE_RIGHT_BUTTON_UP:
#ifdef XP_OS2
    StopTrackingDragGesture();
#endif
  case NS_MOUSE_MIDDLE_BUTTON_UP:
    SetClickCount(aPresContext, (nsMouseEvent*)aEvent, aStatus);
    break;
  case NS_MOUSE_EXIT:
    // If the event coordinate is within the bounds of the view,
    // and this is not the top-level window, then it's not really
    // an exit --- we may have traversed widget boundaries but
    // we're still in our toplevel window.
    // On the other hand, if we exit a toplevel window, then
    // it's really an exit even if the mouse is still in the
    // window bounds --- the mouse probably moved into some
    // "on top" window.
    {
      nsMouseEvent* mouseEvent = NS_STATIC_CAST(nsMouseEvent*, aEvent);
      nsCOMPtr<nsIWidget> parentWidget = getter_AddRefs(mouseEvent->widget->GetParent());
      if (parentWidget &&
        (aView->GetBounds() - aView->GetPosition()).Contains(aEvent->point)) {
        // treat it as a move so we don't generate spurious "exit"
        // events Any necessary exit events will be generated by
        // GenerateMouseEnterExit
        aEvent->message = NS_MOUSE_MOVE;
        // 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_OVER:
    GenerateDragDropEnterExit(aPresContext, (nsGUIEvent*)aEvent);
    break;
  case NS_GOTFOCUS:
    {
      // This is called when a child widget has received focus.
      // We need to take care of sending a blur event for the previously
      // focused content and document, then dispatching a focus
      // event to the target content, its document, and its window.

      EnsureDocument(aPresContext);

      // If the document didn't change, then the only thing that could have
      // changed is the focused content node.  That's handled elsewhere
      // (SetContentState and SendFocusBlur).

      if (gLastFocusedDocument == mDocument)
        break;

      if (mDocument) {
        if (gLastFocusedDocument && gLastFocusedPresContext) {
          nsCOMPtr<nsPIDOMWindow> ourWindow =
            do_QueryInterface(GetDocumentOuterWindow(gLastFocusedDocument));

          // If the focus controller is already suppressed, it means that we
          // are in the middle of an activate sequence. In this case, we do
          // _not_ want to fire a blur on the previously focused content, since
          // we will be focusing it again later when we receive the NS_ACTIVATE
          // event.  See bug 120209.

          // Hold a strong ref to the focus controller, since we need
          // it after event dispatch.
          nsCOMPtr<nsIFocusController> focusController;
          PRBool isAlreadySuppressed = PR_FALSE;

          if (ourWindow) {
            focusController = ourWindow->GetRootFocusController();
            if (focusController) {
              focusController->GetSuppressFocus(&isAlreadySuppressed);
              focusController->SetSuppressFocus(PR_TRUE,
                                                "NS_GOTFOCUS ESM Suppression");
            }
          }

          if (!isAlreadySuppressed) {

            // Fire the blur event on the previously focused document.

            nsEventStatus blurstatus = nsEventStatus_eIgnore;
            nsEvent blurevent(PR_TRUE, NS_BLUR_CONTENT);

            gLastFocusedDocument->HandleDOMEvent(gLastFocusedPresContext,
                                                 &blurevent,
                                                 nsnull, NS_EVENT_FLAG_INIT,
                                                 &blurstatus);

            if (!mCurrentFocus && gLastFocusedContent) {
              // We also need to blur the previously focused content node here,
              // if we don't have a focused content node in this document.
              // (SendFocusBlur isn't called in this case).

              nsCOMPtr<nsIContent> blurContent = gLastFocusedContent;
              gLastFocusedContent->HandleDOMEvent(gLastFocusedPresContext,
                                                  &blurevent, nsnull,
                                                  NS_EVENT_FLAG_INIT,
                                                  &blurstatus);

              // XXX bryner this isn't quite right -- it can result in
              // firing two blur events on the content.

              nsCOMPtr<nsIDocument> doc;
              if (gLastFocusedContent) // could have changed in HandleDOMEvent
                doc = gLastFocusedContent->GetDocument();
              if (doc) {
                nsIPresShell *shell = doc->GetShellAt(0);
                if (shell) {
                  nsCOMPtr<nsPresContext> oldPresContext =
                    shell->GetPresContext();

                  nsCOMPtr<nsIEventStateManager> esm;
                  esm = oldPresContext->EventStateManager();
                  esm->SetFocusedContent(gLastFocusedContent);
                  gLastFocusedContent->HandleDOMEvent(oldPresContext,
                                                      &blurevent, nsnull,
                                                      NS_EVENT_FLAG_INIT,
                                                      &blurstatus);
                  esm->SetFocusedContent(nsnull);
                  NS_IF_RELEASE(gLastFocusedContent);
                }
              }
            }
          }

          if (focusController)
            focusController->SetSuppressFocus(PR_FALSE,
                                              "NS_GOTFOCUS ESM Suppression");
        }

        // Now we should fire the focus event.  We fire it on the document,
        // then the content node, then the window.

        nsCOMPtr<nsIScriptGlobalObject> globalObject =
          GetDocumentOuterWindow(mDocument);

        if (globalObject) {
          // We don't want there to be a focused content node while we're
          // dispatching the focus event.

          nsCOMPtr<nsIContent> currentFocus = mCurrentFocus;
          // "leak" this reference, but we take it back later
          SetFocusedContent(nsnull);

          nsEventStatus status = nsEventStatus_eIgnore;
          nsEvent focusevent(PR_TRUE, NS_FOCUS_CONTENT);

          if (gLastFocusedDocument != mDocument) {
            mDocument->HandleDOMEvent(aPresContext, &focusevent, nsnull,
                                      NS_EVENT_FLAG_INIT, &status);
            if (currentFocus && currentFocus != gLastFocusedContent)
              currentFocus->HandleDOMEvent(aPresContext, &focusevent, nsnull,
                                           NS_EVENT_FLAG_INIT, &status);
          }

          globalObject->HandleDOMEvent(aPresContext, &focusevent, nsnull,
                                       NS_EVENT_FLAG_INIT, &status);

          SetFocusedContent(currentFocus); // we kept this reference above
          NS_IF_RELEASE(gLastFocusedContent);
          gLastFocusedContent = mCurrentFocus;
          NS_IF_ADDREF(gLastFocusedContent);
        }

        // Try to keep the focus controllers and the globals in synch
        if (gLastFocusedDocument && gLastFocusedDocument != mDocument) {

          nsIFocusController *lastController = nsnull;
          nsCOMPtr<nsPIDOMWindow> lastWindow =
            do_QueryInterface(GetDocumentOuterWindow(gLastFocusedDocument));
          if (lastWindow)
            lastController = lastWindow->GetRootFocusController();

          nsIFocusController *nextController = nsnull;
          nsCOMPtr<nsPIDOMWindow> nextWindow =
            do_QueryInterface(GetDocumentOuterWindow(mDocument));
          if (nextWindow)
            nextController = nextWindow->GetRootFocusController();

          if (lastController != nextController && lastController && nextController)
            lastController->SetActive(PR_FALSE);
        }

        NS_IF_RELEASE(gLastFocusedDocument);
        gLastFocusedDocument = mDocument;
        gLastFocusedPresContext = aPresContext;
        NS_IF_ADDREF(gLastFocusedDocument);
      }

      ResetBrowseWithCaret();
    }

    break;

  case NS_LOSTFOCUS:
    {
      // Hide the caret used in "browse with caret mode"
      if (mBrowseWithCaret && mPresContext) {
        nsIPresShell *presShell = mPresContext->GetPresShell();
        if (presShell)
           SetContentCaretVisible(presShell, mCurrentFocus, PR_FALSE);
      }

      // If focus is going to another mozilla window, we wait for the
      // focus event and fire a blur on the old focused content at that time.
      // This allows "-moz-user-focus: ignore" to work.

#if defined(XP_WIN) || defined(XP_OS2)
      if (!NS_STATIC_CAST(nsFocusEvent*, aEvent)->isMozWindowTakingFocus) {

        // This situation occurs when focus goes to a non-gecko child window
        // in an embedding application.  In this case we do fire a blur
        // immediately.

        EnsureDocument(aPresContext);

        // We can get a deactivate on an Ender (editor) widget.  In this
        // case, we would like to obtain the DOM Window to start
        // with by looking at gLastFocusedContent.
        nsCOMPtr<nsIScriptGlobalObject> ourGlobal;
        if (gLastFocusedContent) {
          nsIDocument* doc = gLastFocusedContent->GetDocument();

          if (doc) {
            ourGlobal = GetDocumentOuterWindow(doc);
          } else {
            ourGlobal = GetDocumentOuterWindow(mDocument);
            NS_RELEASE(gLastFocusedContent);
          }
        }
        else {
          ourGlobal = GetDocumentOuterWindow(mDocument);
        }

        // Now fire blurs.  We fire a blur on the focused document, element,
        // and window.

        nsEventStatus status = nsEventStatus_eIgnore;
        nsEvent event(PR_TRUE, NS_BLUR_CONTENT);

        if (gLastFocusedDocument && gLastFocusedPresContext) {
          if (gLastFocusedContent) {
            // Retrieve this content node's pres context. it can be out of sync
            // in the Ender widget case.
            nsCOMPtr<nsIDocument> doc = gLastFocusedContent->GetDocument();
            if (doc) {
              nsIPresShell *shell = doc->GetShellAt(0);
              if (shell) {
                nsCOMPtr<nsPresContext> oldPresContext =
                  shell->GetPresContext();

                nsCOMPtr<nsIEventStateManager> esm =
                  oldPresContext->EventStateManager();
                esm->SetFocusedContent(gLastFocusedContent);
                gLastFocusedContent->HandleDOMEvent(oldPresContext, &event,
                                                    nsnull, NS_EVENT_FLAG_INIT,
                                                    &status);
                esm->SetFocusedContent(nsnull);
                NS_IF_RELEASE(gLastFocusedContent);
              }
            }
          }

          // fire blur on document and window
          if (gLastFocusedDocument) {
            // get the window here, in case the event causes
            // gLastFocusedDocument to change.

            nsCOMPtr<nsIScriptGlobalObject> globalObject =
              GetDocumentOuterWindow(gLastFocusedDocument);

            gLastFocusedDocument->HandleDOMEvent(gLastFocusedPresContext,
                                                 &event, nsnull,
                                                 NS_EVENT_FLAG_INIT, &status);

            if (globalObject)
              globalObject->HandleDOMEvent(gLastFocusedPresContext, &event,
                                           nsnull, NS_EVENT_FLAG_INIT,
                                           &status);
          }

          // Now clear our our global variables
          mCurrentTarget = nsnull;
          NS_IF_RELEASE(gLastFocusedDocument);
          gLastFocusedPresContext = nsnull;
        }
      }
#endif
    }
    break;

 case NS_ACTIVATE:
    {
      // If we have a focus controller, and if it has a focused window and a
      // focused element in its focus memory, then restore the focus to those
      // objects.

      EnsureDocument(aPresContext);

      nsCOMPtr<nsPIDOMWindow> win =
        do_QueryInterface(GetDocumentOuterWindow(mDocument));

      if (!win) {
        NS_ERROR("win is null.  this happens [often on xlib builds].  see bug #79213");
        return NS_ERROR_NULL_POINTER;
      }

      // Hold a strong ref to the focus controller, since we need
      // it after event dispatch.
      nsCOMPtr<nsIFocusController> focusController =
        win->GetRootFocusController();
      nsCOMPtr<nsIDOMElement> focusedElement;
      nsCOMPtr<nsIDOMWindowInternal> focusedWindow;

      if (focusController) {
        // Obtain focus info from the focus controller.
        focusController->GetFocusedWindow(getter_AddRefs(focusedWindow));
        focusController->GetFocusedElement(getter_AddRefs(focusedElement));

        focusController->SetSuppressFocusScroll(PR_TRUE);
        focusController->SetActive(PR_TRUE);
      }

      if (!focusedWindow)
        focusedWindow = win;

      NS_WARN_IF_FALSE(focusedWindow,"check why focusedWindow is null!!!");

      // Focus the DOM window.
      if (focusedWindow) {
        focusedWindow->Focus();

        nsCOMPtr<nsIDocument> document = GetDocumentFromWindow(focusedWindow);

        if (document) {
          // Use a strong ref to make sure that the shell is alive still
          // when calling FrameSelection().
          nsCOMPtr<nsIPresShell> shell = document->GetShellAt(0);
          NS_ASSERTION(shell, "Focus events should not be getting thru when this is null!");
          if (shell) {
            if (focusedElement) {
              nsCOMPtr<nsIContent> focusContent = do_QueryInterface(focusedElement);
              nsCOMPtr<nsPresContext> context = shell->GetPresContext();
              focusContent->SetFocus(context);
            }

            // disable selection mousedown state on activation
            shell->FrameSelection()->SetMouseDownState(PR_FALSE);
          }
        }
      }

      if (focusController) {
        // Make sure the focus controller is up-to-date, since restoring
        // focus memory may have caused focus to go elsewhere.

        if (gLastFocusedDocument && gLastFocusedDocument == mDocument) {
          nsCOMPtr<nsIDOMElement> focusElement = do_QueryInterface(mCurrentFocus);
          focusController->SetFocusedElement(focusElement);
        }

        PRBool isSuppressed;
        focusController->GetSuppressFocus(&isSuppressed);
        while (isSuppressed) {
          // Unsuppress and let the focus controller listen again.
          focusController->SetSuppressFocus(PR_FALSE,
                                            "Activation Suppression");

          focusController->GetSuppressFocus(&isSuppressed);
        }
        focusController->SetSuppressFocusScroll(PR_FALSE);
      }
    }
    break;

 case NS_DEACTIVATE:
    {
      EnsureDocument(aPresContext);

      nsCOMPtr<nsIScriptGlobalObject> ourGlobal =
        GetDocumentOuterWindow(mDocument);

      // Suppress the focus controller for the duration of the
      // de-activation.  This will cause it to remember the last
      // focused sub-window and sub-element for this top-level
      // window.

      nsCOMPtr<nsIFocusController> focusController =
        GetFocusControllerForDocument(mDocument);

      if (focusController)
        focusController->SetSuppressFocus(PR_TRUE, "Deactivate Suppression");

      // Now fire blurs.  Blur the content, then the document, then the window.

      if (gLastFocusedDocument && gLastFocusedDocument == mDocument) {

        nsEventStatus status = nsEventStatus_eIgnore;
        nsEvent event(PR_TRUE, NS_BLUR_CONTENT);

        if (gLastFocusedContent) {
          nsIPresShell *shell = gLastFocusedDocument->GetShellAt(0);
          if (shell) {
            nsCOMPtr<nsPresContext> oldPresContext = shell->GetPresContext();

            nsCOMPtr<nsIDOMElement> focusedElement;
            if (focusController)
              focusController->GetFocusedElement(getter_AddRefs(focusedElement));

            nsCOMPtr<nsIEventStateManager> esm;
            esm = oldPresContext->EventStateManager();
            esm->SetFocusedContent(gLastFocusedContent);

            nsCOMPtr<nsIContent> focusedContent = do_QueryInterface(focusedElement);
            if (focusedContent) {
              // Blur the element.
              focusedContent->HandleDOMEvent(oldPresContext, &event, nsnull,
                                             NS_EVENT_FLAG_INIT, &status);
            }

            esm->SetFocusedContent(nsnull);
            NS_IF_RELEASE(gLastFocusedContent);
          }
        }

        // fire blur on document and window
        mDocument->HandleDOMEvent(aPresContext, &event, nsnull,
                                  NS_EVENT_FLAG_INIT, &status);

        if (ourGlobal)
          ourGlobal->HandleDOMEvent(aPresContext, &event, nsnull,
                                    NS_EVENT_FLAG_INIT, &status);

        // Now clear our our global variables
        mCurrentTarget = nsnull;
        NS_IF_RELEASE(gLastFocusedDocument);
        gLastFocusedPresContext = nsnull;
      }

      if (focusController) {
        focusController->SetActive(PR_FALSE);
        focusController->SetSuppressFocus(PR_FALSE, "Deactivate Suppression");
      }
    }

    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, -1,
                        eAccessKeyProcessingNormal, modifierMask);
    }
  case NS_KEY_DOWN:
  case NS_KEY_UP:
  case NS_MOUSE_SCROLL:
    {
      if (mCurrentFocus) {
        mCurrentTargetContent = mCurrentFocus;
      }
    }
    break;
  }
  return NS_OK;
}

Here is the call graph for this function:

Implements nsIEventStateManager.

Definition at line 4652 of file nsEventStateManager.cpp.

{
  if (!mAccessKeys) {
    mAccessKeys = new nsSupportsHashtable();
    if (!mAccessKeys) {
      return NS_ERROR_FAILURE;
    }
  }

  if (aContent) {
    PRUint32 accKey = (IS_IN_BMP(aKey)) ? ToLowerCase((PRUnichar)aKey) : aKey;

    nsVoidKey key(NS_INT32_TO_PTR(accKey));

#ifdef DEBUG_jag
    nsCOMPtr<nsIContent> oldContent = dont_AddRef(NS_STATIC_CAST(nsIContent*,  mAccessKeys->Get(&key)));
    NS_ASSERTION(!oldContent, "Overwriting accesskey registration");
#endif
    mAccessKeys->Put(&key, aContent);
  }

  return NS_OK;
}

Here is the call graph for this function:

Definition at line 5303 of file nsEventStateManager.cpp.

{
  // This is called when browse with caret changes on the fly
  // or when a document gets focused

  if (!mPresContext)
    return;

  nsCOMPtr<nsISupports> pcContainer = mPresContext->GetContainer();
  PRInt32 itemType;
  nsCOMPtr<nsIDocShellTreeItem> shellItem(do_QueryInterface(pcContainer));
  if (!shellItem)
    return;

  shellItem->GetItemType(&itemType);

  if (itemType == nsIDocShellTreeItem::typeChrome)
    return;  // Never browse with caret in chrome

  nsCOMPtr<nsIEditorDocShell> editorDocShell(do_QueryInterface(shellItem));
  if (editorDocShell) {
    PRBool isEditable;
    editorDocShell->GetEditable(&isEditable);
    if (isEditable) {
      return;  // Reset caret visibility only if browsing, not editing
    }
  }

  PRPackedBool browseWithCaret =
    nsContentUtils::GetBoolPref("accessibility.browsewithcaret");

  mBrowseWithCaret = browseWithCaret;

  nsIPresShell *presShell = mPresContext->GetPresShell();

  // Make caret visible or not, depending on what's appropriate
  if (presShell) {
    SetContentCaretVisible(presShell, mCurrentFocus,
                           browseWithCaret &&
                           (!gLastFocusedDocument ||
                            gLastFocusedDocument == mDocument));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsEventStateManager::SendFocusBlur ( nsPresContext aPresContext,
nsIContent aContent,
PRBool  aEnsureWindowHasFocus 
) [protected]

Definition at line 4265 of file nsEventStateManager.cpp.

{
  // Keep a ref to presShell since dispatching the DOM event may cause
  // the document to be destroyed.
  nsCOMPtr<nsIPresShell> presShell = aPresContext->PresShell();
  if (!presShell)
    return NS_OK;

  nsCOMPtr<nsIContent> previousFocus = mCurrentFocus;

  // Make sure previousFocus is in a document.  If it's not, then
  // we should never abort firing events based on what happens when we
  // send it a blur.

  if (previousFocus && !previousFocus->GetDocument())
    previousFocus = nsnull;

  // Track the old focus controller if any focus suppressions is used on it.
  nsFocusSuppressor oldFocusSuppressor;
  
  if (nsnull != gLastFocusedPresContext) {

    nsCOMPtr<nsIContent> focusAfterBlur;

    if (gLastFocusedContent && gLastFocusedContent != mFirstBlurEvent) {

      //Store the first blur event we fire and don't refire blur
      //to that element while the first blur is still ongoing.
      PRBool clearFirstBlurEvent = PR_FALSE;
      if (!mFirstBlurEvent) {
        mFirstBlurEvent = gLastFocusedContent;
        clearFirstBlurEvent = PR_TRUE;
      }

      // Retrieve this content node's pres context. it can be out of sync in
      // the Ender widget case.
      nsCOMPtr<nsIDocument> doc = gLastFocusedContent->GetDocument();
      if (doc) {
        // The order of the nsIViewManager and nsIPresShell COM pointers is
        // important below.  We want the pres shell to get released before the
        // associated view manager on exit from this function.
        // See bug 53763.
        nsCOMPtr<nsIViewManager> kungFuDeathGrip;
        nsIPresShell *shell = doc->GetShellAt(0);
        if (shell) {
          kungFuDeathGrip = shell->GetViewManager();

          nsCOMPtr<nsPresContext> oldPresContext = shell->GetPresContext();

          //fire blur
          nsEventStatus status = nsEventStatus_eIgnore;
          nsEvent event(PR_TRUE, NS_BLUR_CONTENT);

          EnsureDocument(presShell);

          // Make sure we're not switching command dispatchers, if so,
          // surpress the blurred one
          if(gLastFocusedDocument && mDocument) {
            nsCOMPtr<nsPIDOMWindow> newWindow =
              do_QueryInterface(GetDocumentOuterWindow(mDocument));
            if (newWindow) {
              nsIFocusController *newFocusController =
                newFocusController = newWindow->GetRootFocusController();
              nsCOMPtr<nsPIDOMWindow> oldWindow =
                do_QueryInterface(GetDocumentOuterWindow(gLastFocusedDocument));
              if (oldWindow) {
                nsIFocusController *suppressed = oldWindow->GetRootFocusController();
                if (suppressed != newFocusController) {
                  oldFocusSuppressor.Suppress(suppressed, "SendFocusBlur Window Switch #1");
                }
              }
            }
          }

          nsCOMPtr<nsIEventStateManager> esm;
          esm = oldPresContext->EventStateManager();
          esm->SetFocusedContent(gLastFocusedContent);
          nsCOMPtr<nsIContent> temp = gLastFocusedContent;
          NS_RELEASE(gLastFocusedContent); // nulls out gLastFocusedContent

          nsCxPusher pusher;
          if (pusher.Push(temp)) {
            temp->HandleDOMEvent(oldPresContext, &event, nsnull,
                                 NS_EVENT_FLAG_INIT, &status);
            pusher.Pop();
          }

          focusAfterBlur = mCurrentFocus;
          if (!previousFocus || previousFocus == focusAfterBlur)
            esm->SetFocusedContent(nsnull);
        }
      }

      if (clearFirstBlurEvent) {
        mFirstBlurEvent = nsnull;
      }

      if (previousFocus && previousFocus != focusAfterBlur) {
        // The content node's blur handler focused something else.
        // In this case, abort firing any more blur or focus events.
        EnsureFocusSynchronization();
        return NS_OK;
      }
    }

    // Go ahead and fire a blur on the window.
    nsCOMPtr<nsIScriptGlobalObject> globalObject;

    if(gLastFocusedDocument)
      globalObject = GetDocumentOuterWindow(gLastFocusedDocument);

    EnsureDocument(presShell);

    if (gLastFocusedDocument && (gLastFocusedDocument != mDocument) && globalObject) {
      nsEventStatus status = nsEventStatus_eIgnore;
      nsEvent event(PR_TRUE, NS_BLUR_CONTENT);

      // Make sure we're not switching command dispatchers, if so,
      // suppress the blurred one if it isn't already suppressed
      if (mDocument && !oldFocusSuppressor.Suppressing()) {
        nsCOMPtr<nsPIDOMWindow> newWindow =
          do_QueryInterface(GetDocumentOuterWindow(mDocument));

        if (newWindow) {
          nsCOMPtr<nsPIDOMWindow> oldWindow =
            do_QueryInterface(GetDocumentOuterWindow(gLastFocusedDocument));
          nsIFocusController *newFocusController = newWindow->GetRootFocusController();
          if (oldWindow) {
            nsIFocusController *suppressed = oldWindow->GetRootFocusController();
            if (suppressed != newFocusController) {
              oldFocusSuppressor.Suppress(suppressed, "SendFocusBlur Window Switch #2");
            }
          }
        }
      }

      gLastFocusedPresContext->EventStateManager()->SetFocusedContent(nsnull);
      nsCOMPtr<nsIDocument> temp = gLastFocusedDocument;
      NS_RELEASE(gLastFocusedDocument);
      gLastFocusedDocument = nsnull;

      nsCxPusher pusher;
      if (pusher.Push(temp)) {
        temp->HandleDOMEvent(gLastFocusedPresContext, &event, nsnull,
                             NS_EVENT_FLAG_INIT, &status);
        pusher.Pop();
      }

      if (previousFocus && mCurrentFocus != previousFocus) {
        // The document's blur handler focused something else.
        // Abort firing any additional blur or focus events, and make sure
        // nsFocusController:mFocusedElement is not nulled out, but agrees
        // with our current concept of focus.
        EnsureFocusSynchronization();
        return NS_OK;
      }

      pusher.Push(globalObject);
      globalObject->HandleDOMEvent(gLastFocusedPresContext, &event, nsnull, NS_EVENT_FLAG_INIT, &status);

      if (previousFocus && mCurrentFocus != previousFocus) {
        // The window's blur handler focused something else.
        // Abort firing any additional blur or focus events.
        EnsureFocusSynchronization();
        return NS_OK;
      }
    }
  }

  if (aContent) {
    // Check if the HandleDOMEvent calls above destroyed our frame (bug #118685)
    nsIFrame* frame = nsnull;
    presShell->GetPrimaryFrameFor(aContent, &frame);
    if (!frame) {
      aContent = nsnull;
    }
  }

  NS_IF_RELEASE(gLastFocusedContent);
  gLastFocusedContent = aContent;
  NS_IF_ADDREF(gLastFocusedContent);
  SetFocusedContent(aContent);

  // Moved widget focusing code here, from end of SendFocusBlur
  // This fixes the order of accessibility focus events, so that
  // the window focus event goes first, and then the focus event for the control
  if (aEnsureWindowHasFocus) {
    // This raises the window that has both content and scroll bars in it
    // instead of the child window just below it that contains only the content
    // That way we focus the same window that gets focused by a mouse click
    nsIViewManager* vm = presShell->GetViewManager();
    if (vm) {
      nsCOMPtr<nsIWidget> widget;
      vm->GetWidget(getter_AddRefs(widget));
      if (widget)
        widget->SetFocus(PR_TRUE);
    }
  }

  if (nsnull != aContent && aContent != mFirstFocusEvent) {

    //Store the first focus event we fire and don't refire focus
    //to that element while the first focus is still ongoing.
    PRBool clearFirstFocusEvent = PR_FALSE;
    if (!mFirstFocusEvent) {
      mFirstFocusEvent = aContent;
      clearFirstFocusEvent = PR_TRUE;
    }

    //fire focus
    nsEventStatus status = nsEventStatus_eIgnore;
    nsEvent event(PR_TRUE, NS_FOCUS_CONTENT);

    if (nsnull != mPresContext) {
      nsCxPusher pusher;
      if (pusher.Push(aContent)) {
        aContent->HandleDOMEvent(mPresContext, &event, nsnull,
                                 NS_EVENT_FLAG_INIT, &status);
      }
    }

    nsAutoString tabIndex;
    aContent->GetAttr(kNameSpaceID_None, nsHTMLAtoms::tabindex, tabIndex);
    PRInt32 ec, val = tabIndex.ToInteger(&ec);
    if (NS_SUCCEEDED (ec)) {
      mCurrentTabIndex = val;
    }

    if (clearFirstFocusEvent) {
      mFirstFocusEvent = nsnull;
    }
  } else if (!aContent) {
    //fire focus on document even if the content isn't focusable (ie. text)
    //see bugzilla bug 93521
    nsEventStatus status = nsEventStatus_eIgnore;
    nsEvent event(PR_TRUE, NS_FOCUS_CONTENT);

    if (nsnull != mPresContext && mDocument) {
      nsCxPusher pusher;
      if (pusher.Push(mDocument)) {
        mDocument->HandleDOMEvent(mPresContext, &event, nsnull,
                                  NS_EVENT_FLAG_INIT, &status);
      }
    }
  }

  if (mBrowseWithCaret)
    SetContentCaretVisible(presShell, aContent, PR_TRUE);

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsEventStateManager::SetCaretEnabled ( nsIPresShell aPresShell,
PRBool  aVisibility 
) [protected]

Definition at line 5241 of file nsEventStateManager.cpp.

{
  nsCOMPtr<nsICaret> caret;
  aPresShell->GetCaret(getter_AddRefs(caret));

  nsCOMPtr<nsISelectionController> selCon(do_QueryInterface(aPresShell));
  if (!selCon || !caret)
    return NS_ERROR_FAILURE;

  selCon->SetCaretEnabled(aEnabled);
  caret->SetCaretVisible(aEnabled);

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsEventStateManager::SetClickCount ( nsPresContext aPresContext,
nsMouseEvent aEvent,
nsEventStatus aStatus 
) [protected]

Definition at line 3106 of file nsEventStateManager.cpp.

{
  nsresult ret = NS_OK;
  nsCOMPtr<nsIContent> mouseContent;

  mCurrentTarget->GetContentForEvent(aPresContext, aEvent, getter_AddRefs(mouseContent));

  switch (aEvent->message) {
  case NS_MOUSE_LEFT_BUTTON_DOWN:
    mLastLeftMouseDownContent = mouseContent;
    break;

  case NS_MOUSE_LEFT_BUTTON_UP:
    if (mLastLeftMouseDownContent == mouseContent) {
      aEvent->clickCount = mLClickCount;
      mLClickCount = 0;
    }
    else {
      aEvent->clickCount = 0;
    }
    mLastLeftMouseDownContent = nsnull;
    break;

  case NS_MOUSE_MIDDLE_BUTTON_DOWN:
    mLastMiddleMouseDownContent = mouseContent;
    break;

  case NS_MOUSE_MIDDLE_BUTTON_UP:
    if (mLastMiddleMouseDownContent == mouseContent) {
      aEvent->clickCount = mMClickCount;
      mMClickCount = 0;
    }
    else {
      aEvent->clickCount = 0;
    }
    break;

  case NS_MOUSE_RIGHT_BUTTON_DOWN:
    mLastRightMouseDownContent = mouseContent;
    break;

  case NS_MOUSE_RIGHT_BUTTON_UP:
    if (mLastRightMouseDownContent == mouseContent) {
      aEvent->clickCount = mRClickCount;
      mRClickCount = 0;
    }
    else {
      aEvent->clickCount = 0;
    }
    break;
  }

  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsEventStateManager::SetContentCaretVisible ( nsIPresShell aPresShell,
nsIContent aContent,
PRBool  aVisible 
) [protected]

Definition at line 5257 of file nsEventStateManager.cpp.

{
  // When browsing with caret, make sure caret is visible after new focus
  nsCOMPtr<nsICaret> caret;
  aPresShell->GetCaret(getter_AddRefs(caret));

  nsCOMPtr<nsIFrameSelection> frameSelection;
  if (aFocusedContent) {
    nsIFrame *focusFrame = nsnull;
    aPresShell->GetPrimaryFrameFor(aFocusedContent, &focusFrame);

    GetSelection(focusFrame, mPresContext, getter_AddRefs(frameSelection));
  }

  nsIFrameSelection *docFrameSelection = aPresShell->FrameSelection();

  if (docFrameSelection && caret &&
     (frameSelection == docFrameSelection || !aFocusedContent)) {
    nsCOMPtr<nsISelection> domSelection;
    docFrameSelection->GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(domSelection));
    if (domSelection) {
      // First, tell the caret which selection to use
      caret->SetCaretDOMSelection(domSelection);

      // In content, we need to set the caret
      // the only other case is edit fields, where they have a different frame selection from the doc's
      // in that case they'll take care of making the caret visible themselves

      // Then make sure it's visible
      return SetCaretEnabled(aPresShell, aVisible);
    }
  }

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NS_IMETHODIMP nsEventStateManager::SetContentState ( nsIContent aContent,
PRInt32  aState 
) [virtual]

Implements nsIEventStateManager.

Definition at line 4001 of file nsEventStateManager.cpp.

{
  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 NS_OK;
  }

  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<nsIContent> commonActiveAncestor, oldActive, newActive;
  if ((aState & NS_EVENT_STATE_ACTIVE) && (aContent != mActiveContent)) {
    oldActive = mActiveContent;
    newActive = aContent;
    commonActiveAncestor = FindCommonAncestor(mActiveContent, aContent);
    mActiveContent = aContent;
  }

  nsCOMPtr<nsIContent> commonHoverAncestor, oldHover, newHover;
  if ((aState & NS_EVENT_STATE_HOVER) && (aContent != mHoverContent)) {
    oldHover = mHoverContent;
    newHover = aContent;
    commonHoverAncestor = FindCommonAncestor(mHoverContent, aContent);
    mHoverContent = aContent;
  }

  if ((aState & NS_EVENT_STATE_FOCUS)) {
    EnsureDocument(mPresContext);
    if (aContent && (aContent == mCurrentFocus) && gLastFocusedDocument == mDocument) {
      // gLastFocusedDocument appears to always be correct, that is why
      // I'm not setting it here. This is to catch an edge case.
      NS_IF_RELEASE(gLastFocusedContent);
      gLastFocusedContent = mCurrentFocus;
      NS_IF_ADDREF(gLastFocusedContent);
      //If this notification was for focus alone then get rid of aContent
      //ref to avoid unnecessary notification.
      if (!(aState & ~NS_EVENT_STATE_FOCUS)) {
        aContent = nsnull;
      }
    } else {
      // see comments in ShiftFocusInternal on mCurrentFocus overloading
      PRBool fcActive = PR_FALSE;
      if (mDocument) {
        nsIFocusController *fc = GetFocusControllerForDocument(mDocument);
        if (fc)
          fc->GetActive(&fcActive);
      }
      notifyContent[2] = gLastFocusedContent;
      NS_IF_ADDREF(gLastFocusedContent);
      // only raise window if the the focus controller is active
      SendFocusBlur(mPresContext, aContent, fcActive);

#ifdef DEBUG_aleventhal
      nsCOMPtr<nsPIDOMWindow> currentWindow =
        do_QueryInterface(GetDocumentOuterWindow(mDocument));
      if (currentWindow) {
        nsIFocusController *fc = currentWindow->GetRootFocusController();
        if (fc) {
          nsCOMPtr<nsIDOMElement> focusedElement;
          fc->GetFocusedElement(getter_AddRefs(focusedElement));
          if (!SameCOMIdentity(mCurrentFocus, focusedElement)) {
            printf("\n\nFocus out of whack!!!\n\n");
          }
        }
      }
#endif
      // If we now have focused content, ensure that the canvas focus ring
      // is removed.
      if (mDocument) {
        nsCOMPtr<nsIDocShell> docShell =
          do_QueryInterface(nsCOMPtr<nsISupports>(mDocument->GetContainer()));

        if (docShell && mCurrentFocus)
          docShell->SetCanvasHasFocus(PR_FALSE);

#if !defined(XP_WIN) && !defined(XP_OS2)
        // Also make sure that gLastFocusedDocument and gLastFocusedPresContext
        // aren't NULL if we have focused content.  Not doing this can mess up
        // the NS_GOTFOCUS case in nsEventStateManager::PreHandleEvent().
        // gLastFocusedDocument is NULLed by the call to SendFocusBlur() above.
        // gLastFocusedPresContext is NULLed by the NS_DEACTIVATE case in
        // nsEventStateManager::PreHandleEvent() (which is invoked switching
        // from one browser window to another).
        // Setting gLastFocusedDocument to mDocument here causes harm on
        // Windows -- it sometimes causes the wrong nsIContent to be focused in
        // the NS_LOSTFOCUS case of nsEventStateManager::PreHandleEvent() (as a
        // result of dispatching an NS_FOCUS_BLUR event to gLastFocusedContent).
        // Because the "bad" code in PreHandleEvent() is in an #ifdef block
        // that's only compiled on Windows and OS/2, we now only compile this
        // block on everything but Windows and OS/2.  This resolves bmo bug
        // 406214.
        if (!gLastFocusedDocument) {
          gLastFocusedDocument = mDocument;
          NS_ADDREF(gLastFocusedDocument);
        }
        if (!gLastFocusedPresContext) {
          gLastFocusedPresContext = mPresContext;
        }
#endif
      }
    }
  }

  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<nsIDocument> 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 NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

NS_IMETHODIMP nsEventStateManager::SetCursor ( PRInt32  aCursor,
imgIContainer aContainer,
PRBool  aHaveHotspot,
float  aHotspotX,
float  aHotspotY,
nsIWidget aWidget,
PRBool  aLockCursor 
) [virtual]

Implements nsIEventStateManager.

Definition at line 2591 of file nsEventStateManager.cpp.

{
  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;
  }

  // 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 NSToUintRound?
      hotspotX = aHotspotX > 0.0f
                   ? PRUint32(aHotspotX + ROUND_CONST_FLOAT) : PRUint32(0);
      if (hotspotX >= PRUint32(imgWidth))
        hotspotX = imgWidth - 1;
      hotspotY = aHotspotY > 0.0f
                   ? PRUint32(aHotspotY + ROUND_CONST_FLOAT) : PRUint32(0);
      if (hotspotY >= PRUint32(imgHeight))
        hotspotY = imgHeight - 1;
    } else {
      hotspotX = 0;
      hotspotY = 0;
      nsCOMPtr<nsIProperties> props(do_QueryInterface(aContainer));
      if (props) {
        nsCOMPtr<nsISupportsPRUint32> 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 4549 of file nsEventStateManager.cpp.

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 2500 of file nsEventStateManager.cpp.

{
  if (aPresContext == nsnull) {
    // A pres context is going away. Make sure we do cleanup.
    if (mPresContext == gLastFocusedPresContext) {
      gLastFocusedPresContext = nsnull;
      NS_IF_RELEASE(gLastFocusedDocument);
      NS_IF_RELEASE(gLastFocusedContent);
    }
  }

  mPresContext = aPresContext;
  return NS_OK;
}
NS_IMETHODIMP nsEventStateManager::ShiftFocus ( PRBool  aForward,
nsIContent aStart = nsnull 
) [virtual]

Implements nsIEventStateManager.

Definition at line 3343 of file nsEventStateManager.cpp.

{
  nsCOMPtr<nsILookAndFeel> lookNFeel(do_GetService(kLookAndFeelCID));
  lookNFeel->GetMetric(nsILookAndFeel::eMetric_TabFocusModel,
                       nsIContent::sTabFocusModel);

  // We use mTabbedThroughDocument to indicate that we have passed
  // the end (or beginning) of the document we started tabbing from,
  // without finding anything else to focus.  If we pass the end of
  // the same document again (and the flag is set), we know that there
  // is no focusable content anywhere in the tree, and should stop.

  mTabbedThroughDocument = PR_FALSE;
  return ShiftFocusInternal(aForward, aStart);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 5607 of file nsEventStateManager.cpp.

{
  // Note that we use the docshell tree here instead of iteratively calling
  // ShiftFocus.  The docshell tree should be kept in depth-first frame tree
  // order, the same as we use for tabbing, so the effect should be the same,
  // but this is much faster.

  NS_ASSERTION(mPresContext, "no prescontext");

  nsCOMPtr<nsISupports> pcContainer = mPresContext->GetContainer();
  nsCOMPtr<nsIDocShellTreeNode> curNode = do_QueryInterface(pcContainer);

  // perform a depth first search (preorder) of the docshell tree
  // looking for an HTML Frame or a chrome document

  nsCOMPtr<nsIDocShellTreeItem> nextItem;
  nsCOMPtr<nsIDocShell> nextShell;
  do {
    if (aForward) {
      GetNextDocShell(curNode, getter_AddRefs(nextItem));
      if (!nextItem) {
        nsCOMPtr<nsIDocShellTreeItem> curItem = do_QueryInterface(pcContainer);
        // wrap around to the beginning, which is the top of the tree
        curItem->GetRootTreeItem(getter_AddRefs(nextItem));
      }
    }
    else {
      GetPrevDocShell(curNode, getter_AddRefs(nextItem));
      if (!nextItem) {
        nsCOMPtr<nsIDocShellTreeItem> curItem = do_QueryInterface(pcContainer);
        // wrap around to the end, which is the last node in the tree
        nsCOMPtr<nsIDocShellTreeItem> rootItem;
        curItem->GetRootTreeItem(getter_AddRefs(rootItem));
        GetLastChildDocShell(rootItem, getter_AddRefs(nextItem));
      }
    }

    curNode = do_QueryInterface(nextItem);
    nextShell = do_QueryInterface(nextItem);
  } while (IsFrameSetDoc(nextShell) || IsIFrameDoc(nextShell) || !IsShellVisible(nextShell));

  if (nextShell) {
    // NOTE: always tab forward into the document, this ensures that we
    // focus the document itself, not its last focusable content.
    // chrome documents will get their first focusable content focused.
    SetContentState(nsnull, NS_EVENT_STATE_FOCUS);
    TabIntoDocument(nextShell, PR_TRUE);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsEventStateManager::ShiftFocusInternal ( PRBool  aForward,
nsIContent aStart = nsnull 
) [protected]

Definition at line 3360 of file nsEventStateManager.cpp.

{
#ifdef DEBUG_DOCSHELL_FOCUS
  printf("[%p] ShiftFocusInternal: aForward=%d, aStart=%p, mCurrentFocus=%p\n",
         this, aForward, aStart, mCurrentFocus.get());
#endif
  NS_ASSERTION(mPresContext, "no pres context");
  EnsureDocument(mPresContext);
  NS_ASSERTION(mDocument, "no document");

  nsCOMPtr<nsIContent> rootContent = mDocument->GetRootContent();

  nsCOMPtr<nsISupports> pcContainer = mPresContext->GetContainer();
  NS_ASSERTION(pcContainer, "no container for presContext");

  nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(pcContainer));
  PRBool docHasFocus = PR_FALSE;

  // ignoreTabIndex allows the user to tab to the next link after clicking before it link in the page
  // or using find text to get to the link. Without ignoreTabIndex in those cases, pages that
  // use tabindex would still enforce that order in those situations.
  PRBool ignoreTabIndex = PR_FALSE;

  if (!aStart && !mCurrentFocus) {
    // mCurrentFocus is ambiguous for determining whether
    // we're in document-focus mode, because it's nulled out
    // when the document is blurred, and it's also nulled out
    // when the document/canvas has focus.
    //
    // So, use the docshell focus state to disambiguate.

    docShell->GetHasFocus(&docHasFocus);
  }

  nsIFrame* selectionFrame = nsnull;
  nsIFrame* curFocusFrame = nsnull;   // This will hold the location we're moving away from

  // If in content, navigate from last cursor position rather than last focus
  // If we're in UI, selection location will return null
  nsIPresShell *presShell = mPresContext->PresShell();

  // We might use the selection position, rather than mCurrentFocus, as our position to shift focus from
  PRInt32 itemType;
  nsCOMPtr<nsIDocShellTreeItem> shellItem(do_QueryInterface(docShell));
  shellItem->GetItemType(&itemType);

  // Tab from the selection if it exists, but not if we're in chrome or an explicit starting
  // point was given.
  if (!aStart && itemType != nsIDocShellTreeItem::typeChrome) {
    // We're going to tab from the selection position
    if (!mCurrentFocus || (mLastFocusedWith != eEventFocusedByMouse && mCurrentFocus->Tag() != nsHTMLAtoms::area)) {
      nsCOMPtr<nsIContent> selectionContent, endSelectionContent;  // We won't be using this, need arg for method call
      PRUint32 selectionOffset; // We won't be using this either, need arg for method call
      GetDocSelectionLocation(getter_AddRefs(selectionContent), getter_AddRefs(endSelectionContent), &selectionFrame, &selectionOffset);
      if (selectionContent == rootContent)  // If selection on rootContent, same as null -- we have no selection yet
        selectionFrame = nsnull;
      // Only use tabindex if selection is synchronized with focus
      // That way, if the user clicks in content, or does a find text that lands between focusable elements,
      // they can then tab relative to that selection
      if (selectionFrame) {
        PRBool selectionWithFocus;
        MoveFocusToCaret(PR_FALSE, &selectionWithFocus);
        ignoreTabIndex = !selectionWithFocus;
        // Refresh |selectionFrame| since MoveFocusToCaret() could have
        // destroyed it. (bug 308086)
        GetDocSelectionLocation(getter_AddRefs(selectionContent),
                                getter_AddRefs(endSelectionContent),
                                &selectionFrame, &selectionOffset);
      }
    }
  }

  nsIContent *startContent = nsnull;

  if (aStart) {
    presShell->GetPrimaryFrameFor(aStart, &curFocusFrame);

    // If there is no frame, we can't navigate from this content node, and we
    // fall back to navigating from the document root.
    if (curFocusFrame)
      startContent = aStart;
  } else if (selectionFrame) {
    // We moved focus to the caret location above, so mCurrentFocus
    // reflects the starting content node.
    startContent = mCurrentFocus;
    curFocusFrame = selectionFrame;
  } else if (!docHasFocus) {
    startContent = mCurrentFocus;
    GetFocusedFrame(&curFocusFrame);
  }

  if (aStart) {
    if (aStart->HasAttr(kNameSpaceID_None, nsHTMLAtoms::tabindex)) {
      aStart->IsFocusable(&mCurrentTabIndex);
    } else {
      ignoreTabIndex = PR_TRUE; // ignore current tabindex, bug 81481
    }
  } else if (!mCurrentFocus) {  // Get tabindex ready
    if (aForward) {
      mCurrentTabIndex = docHasFocus && selectionFrame ? 0 : 1;
    } else if (!docHasFocus) {
      mCurrentTabIndex = 0;
    } else if (selectionFrame) {
      mCurrentTabIndex = 1;   // will keep it from wrapping around to end
    }
  }

  nsCOMPtr<nsIContent> nextFocus;
  nsIFrame* nextFocusFrame;
  if (aForward || !docHasFocus || selectionFrame)
    GetNextTabbableContent(rootContent, startContent, curFocusFrame,
                           aForward, ignoreTabIndex || mCurrentTabIndex < 0,
                           getter_AddRefs(nextFocus), &nextFocusFrame);

  // Clear out mCurrentTabIndex. It has a garbage value because of GetNextTabbableContent()'s side effects
  // It will be set correctly when focus is changed via ChangeFocusWith()
  mCurrentTabIndex = 0;

  if (nextFocus) {
    // Check to see if the next focused element has a subshell.
    // This is the case for an IFRAME or FRAME element.  If it
    // does, we send focus into the subshell.

    nsCOMPtr<nsIDocShell> sub_shell;
    nsCOMPtr<nsIDocument> doc = nextFocus->GetDocument();

    if (doc) {
      nsIDocument *sub_doc = doc->GetSubDocumentFor(nextFocus);

      if (sub_doc) {
        nsCOMPtr<nsISupports> container = sub_doc->GetContainer();
        sub_shell = do_QueryInterface(container);
      }
    }

    if (sub_shell) {
      // Make sure to scroll before possibly dispatching focus/blur events.
      presShell->ScrollFrameIntoView(nextFocusFrame,
                                     NS_PRESSHELL_SCROLL_ANYWHERE,
                                     NS_PRESSHELL_SCROLL_ANYWHERE);

      SetContentState(nsnull, NS_EVENT_STATE_FOCUS);

      // if we are in the middle of tabbing into
      // sub_shell, bail out, to avoid recursion
      // see bug #195011 and bug #137191
      if (mTabbingFromDocShells.IndexOf(sub_shell) != -1)
        return NS_OK;

      TabIntoDocument(sub_shell, aForward);
    } else {
      // there is no subshell, so just focus nextFocus
#ifdef DEBUG_DOCSHELL_FOCUS
      printf("focusing next focusable content: %p\n", nextFocus.get());
#endif
      mCurrentTarget = nextFocusFrame;

      //This may be new frame that hasn't been through the ESM so we
      //must set its NS_FRAME_EXTERNAL_REFERENCE bit.
      if (mCurrentTarget)
        SetFrameExternalReference(mCurrentTarget);

      nsCOMPtr<nsIContent> oldFocus(mCurrentFocus);
      ChangeFocusWith(nextFocus, eEventFocusedByKey);
      if (!mCurrentFocus && oldFocus) {
        // ChangeFocusWith failed to move focus to nextFocus because a blur handler
        // made it unfocusable. (bug #118685)
        // Try again unless it's from the same point, bug 232368.
        if (oldFocus != aStart && oldFocus->GetDocument()) {
          mCurrentTarget = nsnull;
          return ShiftFocusInternal(aForward, oldFocus);
        } else {
          return NS_OK;
        }
      } else {
        if (mCurrentFocus != nextFocus) {
          // A focus or blur handler switched the focus from one of
          // its focus/blur/change handlers, don't mess with what the
          // page wanted...

          return NS_OK;
        }
        GetFocusedFrame(&mCurrentTarget);
        if (mCurrentTarget)
          SetFrameExternalReference(mCurrentTarget);
      }

      // It's possible that the act of removing focus from our previously
      // focused element caused nextFocus to be removed from the document.
      // In this case, we can restart the frame traversal from our previously
      // focused content.

      if (oldFocus && doc != nextFocus->GetDocument()) {
        mCurrentTarget = nsnull;
        return ShiftFocusInternal(aForward, oldFocus);
      }

      if (!docHasFocus)
        docShell->SetHasFocus(PR_TRUE);
    }
  } else {

    // If we're going backwards past the first content,
    // focus the document.

    PRBool focusDocument;
    if (itemType == nsIDocShellTreeItem::typeChrome)
      focusDocument = PR_FALSE;
    else {
      // Check for a frameset document
      focusDocument = !(IsFrameSetDoc(docShell));
    }

    if (!aForward && !docHasFocus && focusDocument) {
#ifdef DEBUG_DOCSHELL_FOCUS
      printf("Focusing document\n");
#endif
      SetContentState(nsnull, NS_EVENT_STATE_FOCUS);
      docShell->SetHasFocus(PR_TRUE);
      docShell->SetCanvasHasFocus(PR_TRUE);
      // Next time forward we start at the beginning of the document
      // Next time backward we go to URL bar
      // We need to move the caret to the document root, so that we don't
      // tab from the most recently focused element next time around
      SetFocusedContent(rootContent);
      MoveCaretToFocus();
      SetFocusedContent(nsnull);

    } else {
      // If there's nothing left to focus in this document,
      // pop out to our parent document, and have it shift focus
      // in the same direction starting at the content element
      // corresponding to our docshell.
      // Guard against infinite recursion (see explanation in ShiftFocus)

      if (mTabbedThroughDocument)
        return NS_OK;

      SetFocusedContent(rootContent);
      mCurrentTabIndex = 0;
      MoveCaretToFocus();
      SetFocusedContent(nsnull);

      mTabbedThroughDocument = PR_TRUE;

      nsCOMPtr<nsIDocShellTreeItem> treeItem = do_QueryInterface(pcContainer);
      nsCOMPtr<nsIDocShellTreeItem> treeParent;
      treeItem->GetParent(getter_AddRefs(treeParent));
      if (treeParent) {
        nsCOMPtr<nsIDocShell> parentDS = do_QueryInterface(treeParent);
        if (parentDS) {
          nsCOMPtr<nsIPresShell> parentShell;
          parentDS->GetPresShell(getter_AddRefs(parentShell));

          nsIDocument *parent_doc = parentShell->GetDocument();
          nsIContent *docContent = parent_doc->FindContentForSubDocument(mDocument);

          nsCOMPtr<nsPresContext> parentPC = parentShell->GetPresContext();
          nsIEventStateManager *parentESM = parentPC->EventStateManager();

          SetContentState(nsnull, NS_EVENT_STATE_FOCUS);

#ifdef DEBUG_DOCSHELL_FOCUS
          printf("popping out focus to parent docshell\n");
#endif
          parentESM->MoveCaretToFocus();
          parentESM->ShiftFocus(aForward, docContent);
        }
      } else {
        PRBool tookFocus = PR_FALSE;
        nsCOMPtr<nsIDocShell> subShell = do_QueryInterface(pcContainer);
        if (subShell) {
          subShell->TabToTreeOwner(aForward, &tookFocus);
        }

#ifdef DEBUG_DOCSHEL_FOCUS
        printf("offered focus to tree owner, tookFocus=%d\n",
               tookFocus);
#endif

        if (tookFocus) {
          SetContentState(nsnull, NS_EVENT_STATE_FOCUS);
          docShell->SetHasFocus(PR_FALSE);
        } else {
          // there is nowhere else to send the focus, so
          // refocus ourself.
          // Next time forward we start at the beginning of the document

#ifdef DEBUG_DOCSHELL_FOCUS
          printf("wrapping around within this document\n");
#endif

          SetFocusedContent(nsnull);
          docShell->SetHasFocus(PR_FALSE);
          ShiftFocusInternal(aForward);
        }
      }
    }
  }

  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 364 of file nsEventStateManager.cpp.

{
  nsCOMPtr<nsIPrefBranch2> prefBranch =
    do_QueryInterface(nsContentUtils::GetPrefBranch());

  if (prefBranch) {
    prefBranch->RemoveObserver("accessibility.accesskeycausesactivation", this);
    prefBranch->RemoveObserver("accessibility.browsewithcaret", this);
    prefBranch->RemoveObserver("accessibility.tabfocus_applies_to_xul", 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 149 of file nsEventStateManager.h.

Here is the caller graph for this function:

static void nsEventStateManager::StopHandlingUserInput ( ) [inline, static]

Definition at line 154 of file nsEventStateManager.h.

Here is the caller graph for this function:

Definition at line 1513 of file nsEventStateManager.cpp.

Here is the caller graph for this function:

void nsEventStateManager::TabIntoDocument ( nsIDocShell aDocShell,
PRBool  aForward 
) [protected]

Definition at line 5441 of file nsEventStateManager.cpp.

{
  NS_ASSERTION(aDocShell, "null docshell");
  nsCOMPtr<nsIDOMWindowInternal> domwin = do_GetInterface(aDocShell);
  if (domwin)
    domwin->Focus();

  PRInt32 itemType;
  nsCOMPtr<nsIDocShellTreeItem> treeItem = do_QueryInterface(aDocShell);
  treeItem->GetItemType(&itemType);

  nsCOMPtr<nsPresContext> presContext;
  aDocShell->GetPresContext(getter_AddRefs(presContext));
  PRBool focusDocument;
  if (presContext &&
      presContext->Type() == nsPresContext::eContext_PrintPreview) {
    // Don't focus any content in print preview mode, bug 244128.
    focusDocument = PR_TRUE;
  } else {
    if (!aForward || (itemType == nsIDocShellTreeItem::typeChrome))
      focusDocument = PR_FALSE;
    else {
      // Check for a frameset document
      focusDocument = !(IsFrameSetDoc(aDocShell));
    }
  }

  if (focusDocument) {
    // make sure we're in view
    aDocShell->SetCanvasHasFocus(PR_TRUE);
  }
  else {
    aDocShell->SetHasFocus(PR_FALSE);

    if (presContext) {
      nsIEventStateManager *docESM = presContext->EventStateManager();

      // we are about to shift focus to aDocShell
      // keep track of the document, so we don't try to go back into it.
      mTabbingFromDocShells.AppendObject(aDocShell);

      // clear out any existing focus state
      docESM->SetContentState(nsnull, NS_EVENT_STATE_FOCUS);
      // now focus the first (or last) focusable content
      docESM->ShiftFocus(aForward, nsnull);

      // remove the document from the list
      mTabbingFromDocShells.RemoveObject(aDocShell);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Implements nsIEventStateManager.

Definition at line 4677 of file nsEventStateManager.cpp.

{
  if (!mAccessKeys) {
    return NS_ERROR_FAILURE;
  }

  if (aContent) {
    PRUint32 accKey = (IS_IN_BMP(aKey)) ? ToLowerCase((PRUnichar)aKey) : aKey;

    nsVoidKey key(NS_INT32_TO_PTR(accKey));

    nsCOMPtr<nsIContent> oldContent = dont_AddRef(NS_STATIC_CAST(nsIContent*, mAccessKeys->Get(&key)));
#ifdef DEBUG_jag
    NS_ASSERTION(oldContent == aContent, "Trying to unregister wrong content");
#endif
    if (oldContent != aContent)
      return NS_OK;

    mAccessKeys->Remove(&key);
  }
  return NS_OK;
}

Here is the call graph for this function:

void nsEventStateManager::UpdateCursor ( nsPresContext aPresContext,
nsEvent aEvent,
nsIFrame aTargetFrame,
nsEventStatus aStatus 
) [protected]

Definition at line 2539 of file nsEventStateManager.cpp.

{
  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;
      if (NS_FAILED(aTargetFrame->GetCursor(aEvent->point, 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;
  }

  // Check whether or not to show the busy cursor
  nsCOMPtr<nsISupports> pcContainer = aPresContext->GetContainer();
  nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(pcContainer));
  if (!docShell) return;
  PRUint32 busyFlags = nsIDocShell::BUSY_FLAGS_NONE;
  docShell->GetBusyFlags(&busyFlags);

  // Show busy cursor everywhere before page loads
  // and just replace the arrow cursor after page starts loading
  if (busyFlags & nsIDocShell::BUSY_FLAGS_BUSY &&
        (cursor == NS_STYLE_CURSOR_AUTO || cursor == NS_STYLE_CURSOR_DEFAULT))
  {
    cursor = NS_STYLE_CURSOR_SPINNING;
    container = nsnull;
  }

  if (aTargetFrame) {
    SetCursor(cursor, container, haveHotspot, hotspotX, hotspotY,
              aTargetFrame->GetWindow(), PR_FALSE);
  }

  if (mLockCursor || NS_STYLE_CURSOR_AUTO != cursor) {
    *aStatus = nsEventStatus_eConsumeDoDefault;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:


Member Data Documentation

Definition at line 368 of file nsEventStateManager.h.

nsSupportsHashtable* nsEventStateManager::mAccessKeys [protected]

Definition at line 385 of file nsEventStateManager.h.

Definition at line 331 of file nsEventStateManager.h.

Definition at line 375 of file nsEventStateManager.h.

Definition at line 372 of file nsEventStateManager.h.

Definition at line 364 of file nsEventStateManager.h.

Definition at line 335 of file nsEventStateManager.h.

Definition at line 337 of file nsEventStateManager.h.

Definition at line 308 of file nsEventStateManager.h.

Definition at line 338 of file nsEventStateManager.h.

Definition at line 306 of file nsEventStateManager.h.

Definition at line 307 of file nsEventStateManager.h.

Definition at line 358 of file nsEventStateManager.h.

Definition at line 382 of file nsEventStateManager.h.

Definition at line 333 of file nsEventStateManager.h.

Definition at line 346 of file nsEventStateManager.h.

Definition at line 347 of file nsEventStateManager.h.

Definition at line 355 of file nsEventStateManager.h.

Definition at line 351 of file nsEventStateManager.h.

Definition at line 324 of file nsEventStateManager.h.

Definition at line 316 of file nsEventStateManager.h.

Definition at line 323 of file nsEventStateManager.h.

Definition at line 320 of file nsEventStateManager.h.

Definition at line 325 of file nsEventStateManager.h.

Definition at line 314 of file nsEventStateManager.h.

Definition at line 322 of file nsEventStateManager.h.

Definition at line 332 of file nsEventStateManager.h.

Definition at line 342 of file nsEventStateManager.h.

Definition at line 311 of file nsEventStateManager.h.

Definition at line 336 of file nsEventStateManager.h.

Definition at line 339 of file nsEventStateManager.h.

Definition at line 327 of file nsEventStateManager.h.

Definition at line 328 of file nsEventStateManager.h.

Definition at line 310 of file nsEventStateManager.h.

Definition at line 309 of file nsEventStateManager.h.

Definition at line 329 of file nsEventStateManager.h.

Definition at line 360 of file nsEventStateManager.h.

Definition at line 303 of file nsEventStateManager.h.

Definition at line 361 of file nsEventStateManager.h.

Definition at line 366 of file nsEventStateManager.h.

Definition at line 357 of file nsEventStateManager.h.

Definition at line 362 of file nsEventStateManager.h.

Definition at line 286 of file nsEventStateManager.h.

Definition at line 378 of file nsEventStateManager.h.

Definition at line 387 of file nsEventStateManager.h.

Definition at line 334 of file nsEventStateManager.h.

Definition at line 401 of file nsEventStateManager.h.


The documentation for this class was generated from the following files: