The Tor Browser: layout/xul/nsMenuBarFrame.cpp@7e26c7da4463 (annotated)

layout/xul/nsMenuBarFrame.cpp@7e26c7da4463 (annotated)

layout/xul/nsMenuBarFrame.cpp

Wed, 31 Dec 2014 06:55:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:55:50 +0100
changeset 2: 7e26c7da4463
permissions: -rw-r--r--

Added tag UPSTREAM_283F7C6 for changeset ca08bd8f51b2

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "nsMenuBarFrame.h"
 #include "nsIServiceManager.h"
 #include "nsIContent.h"
 #include "nsIAtom.h"
 #include "nsPresContext.h"
 #include "nsStyleContext.h"
 #include "nsCSSRendering.h"
 #include "nsNameSpaceManager.h"
 #include "nsIDocument.h"
 #include "nsGkAtoms.h"
 #include "nsMenuFrame.h"
 #include "nsMenuPopupFrame.h"
 #include "nsUnicharUtils.h"
 #include "nsPIDOMWindow.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsCSSFrameConstructor.h"
 #ifdef XP_WIN
 #include "nsISound.h"
 #include "nsWidgetsCID.h"
 #endif
 #include "nsContentUtils.h"
 #include "nsUTF8Utils.h"
 #include "mozilla/TextEvents.h"
 using namespace mozilla;
 //
 // NS_NewMenuBarFrame
 //
 // Wrapper for creating a new menu Bar container
 //
 nsIFrame*
 NS_NewMenuBarFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
 {
   return new (aPresShell) nsMenuBarFrame (aPresShell, aContext);
 }
 NS_IMPL_FRAMEARENA_HELPERS(nsMenuBarFrame)
 NS_QUERYFRAME_HEAD(nsMenuBarFrame)
   NS_QUERYFRAME_ENTRY(nsMenuBarFrame)
 NS_QUERYFRAME_TAIL_INHERITING(nsBoxFrame)
 //
 // nsMenuBarFrame cntr
 //
 nsMenuBarFrame::nsMenuBarFrame(nsIPresShell* aShell, nsStyleContext* aContext):
   nsBoxFrame(aShell, aContext),
     mMenuBarListener(nullptr),
     mStayActive(false),
     mIsActive(false),
     mCurrentMenu(nullptr),
     mTarget(nullptr)
 {
 } // cntr
 void
 nsMenuBarFrame::Init(nsIContent*      aContent,
                      nsIFrame*        aParent,
                      nsIFrame*        aPrevInFlow)
 {
   nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
   // Create the menu bar listener.
   mMenuBarListener = new nsMenuBarListener(this);
   NS_ADDREF(mMenuBarListener);
   // Hook up the menu bar as a key listener on the whole document.  It will see every
   // key press that occurs, but after everyone else does.
   mTarget = aContent->GetDocument();
   // Also hook up the listener to the window listening for focus events. This is so we can keep proper
   // state as the user alt-tabs through processes.
   mTarget->AddEventListener(NS_LITERAL_STRING("keypress"), mMenuBarListener, false);
   mTarget->AddEventListener(NS_LITERAL_STRING("keydown"), mMenuBarListener, false);
   mTarget->AddEventListener(NS_LITERAL_STRING("keyup"), mMenuBarListener, false);
   // mousedown event should be handled in all phase
   mTarget->AddEventListener(NS_LITERAL_STRING("mousedown"), mMenuBarListener, true);
   mTarget->AddEventListener(NS_LITERAL_STRING("mousedown"), mMenuBarListener, false);
   mTarget->AddEventListener(NS_LITERAL_STRING("blur"), mMenuBarListener, true);
 }
 NS_IMETHODIMP
 nsMenuBarFrame::SetActive(bool aActiveFlag)
 {
   // If the activity is not changed, there is nothing to do.
   if (mIsActive == aActiveFlag)
     return NS_OK;
   if (!aActiveFlag) {
     // Don't deactivate when switching between menus on the menubar.
     if (mStayActive)
       return NS_OK;
     // if there is a request to deactivate the menu bar, check to see whether
     // there is a menu popup open for the menu bar. In this case, don't
     // deactivate the menu bar.
     nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
     if (pm && pm->IsPopupOpenForMenuParent(this))
       return NS_OK;
   }
   mIsActive = aActiveFlag;
   if (mIsActive) {
     InstallKeyboardNavigator();
   }
   else {
     mActiveByKeyboard = false;
     RemoveKeyboardNavigator();
   }
   NS_NAMED_LITERAL_STRING(active, "DOMMenuBarActive");
   NS_NAMED_LITERAL_STRING(inactive, "DOMMenuBarInactive");
   FireDOMEvent(mIsActive ? active : inactive, mContent);
   return NS_OK;
 }
 nsMenuFrame*
 nsMenuBarFrame::ToggleMenuActiveState()
 {
   if (mIsActive) {
     // Deactivate the menu bar
     SetActive(false);
     if (mCurrentMenu) {
       nsMenuFrame* closeframe = mCurrentMenu;
       closeframe->SelectMenu(false);
       mCurrentMenu = nullptr;
       return closeframe;
     }
   }
   else {
     // if the menu bar is already selected (eg. mouseover), deselect it
     if (mCurrentMenu)
       mCurrentMenu->SelectMenu(false);
     // Set the active menu to be the top left item (e.g., the File menu).
     // We use an attribute called "menuactive" to track the current
     // active menu.
     nsMenuFrame* firstFrame = nsXULPopupManager::GetNextMenuItem(this, nullptr, false);
     if (firstFrame) {
       // Activate the menu bar
       SetActive(true);
       firstFrame->SelectMenu(true);
       // Track this item for keyboard navigation.
       mCurrentMenu = firstFrame;
     }
   }
   return nullptr;
 }
 static void
 GetInsertionPoint(nsIPresShell* aShell, nsIFrame* aFrame, nsIFrame* aChild,
                   nsIFrame** aResult)
 {
   nsIContent* child = nullptr;
   if (aChild)
     child = aChild->GetContent();
   *aResult = aShell->FrameConstructor()->
     GetInsertionPoint(aFrame->GetContent(), child);
 }
 nsMenuFrame*
 nsMenuBarFrame::FindMenuWithShortcut(nsIDOMKeyEvent* aKeyEvent)
 {
   uint32_t charCode;
   aKeyEvent->GetCharCode(&charCode);
   nsAutoTArray<uint32_t, 10> accessKeys;
   WidgetKeyboardEvent* nativeKeyEvent =
     aKeyEvent->GetInternalNSEvent()->AsKeyboardEvent();
   if (nativeKeyEvent)
     nsContentUtils::GetAccessKeyCandidates(nativeKeyEvent, accessKeys);
   if (accessKeys.IsEmpty() && charCode)
     accessKeys.AppendElement(charCode);
   if (accessKeys.IsEmpty())
     return nullptr; // no character was pressed so just return
   // Enumerate over our list of frames.
   nsIFrame* immediateParent = nullptr;
   GetInsertionPoint(PresContext()->PresShell(), this, nullptr, &immediateParent);
   if (!immediateParent)
     immediateParent = this;
   // Find a most preferred accesskey which should be returned.
   nsIFrame* foundMenu = nullptr;
   uint32_t foundIndex = accessKeys.NoIndex;
   nsIFrame* currFrame = immediateParent->GetFirstPrincipalChild();
   while (currFrame) {
     nsIContent* current = currFrame->GetContent();
     // See if it's a menu item.
     if (nsXULPopupManager::IsValidMenuItem(PresContext(), current, false)) {
       // Get the shortcut attribute.
       nsAutoString shortcutKey;
       current->GetAttr(kNameSpaceID_None, nsGkAtoms::accesskey, shortcutKey);
       if (!shortcutKey.IsEmpty()) {
         ToLowerCase(shortcutKey);
         const char16_t* start = shortcutKey.BeginReading();
         const char16_t* end = shortcutKey.EndReading();
         uint32_t ch = UTF16CharEnumerator::NextChar(&start, end);
         uint32_t index = accessKeys.IndexOf(ch);
         if (index != accessKeys.NoIndex &&
             (foundIndex == accessKeys.NoIndex || index < foundIndex)) {
           foundMenu = currFrame;
           foundIndex = index;
         }
       }
     }
     currFrame = currFrame->GetNextSibling();
   }
   if (foundMenu) {
     return do_QueryFrame(foundMenu);
   }
   // didn't find a matching menu item
 #ifdef XP_WIN
   // behavior on Windows - this item is on the menu bar, beep and deactivate the menu bar
   if (mIsActive) {
     nsCOMPtr<nsISound> soundInterface = do_CreateInstance("@mozilla.org/sound;1");
     if (soundInterface)
       soundInterface->Beep();
   }
   nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
   if (pm) {
     nsIFrame* popup = pm->GetTopPopup(ePopupTypeAny);
     if (popup)
       pm->HidePopup(popup->GetContent(), true, true, true, false);
   }
   SetCurrentMenuItem(nullptr);
   SetActive(false);
 #endif  // #ifdef XP_WIN
   return nullptr;
 }
 /* virtual */ nsMenuFrame*
 nsMenuBarFrame::GetCurrentMenuItem()
 {
   return mCurrentMenu;
 }
 NS_IMETHODIMP
 nsMenuBarFrame::SetCurrentMenuItem(nsMenuFrame* aMenuItem)
 {
   if (mCurrentMenu == aMenuItem)
     return NS_OK;
   if (mCurrentMenu)
     mCurrentMenu->SelectMenu(false);
   if (aMenuItem)
     aMenuItem->SelectMenu(true);
   mCurrentMenu = aMenuItem;
   return NS_OK;
 }
 void
 nsMenuBarFrame::CurrentMenuIsBeingDestroyed()
 {
   mCurrentMenu->SelectMenu(false);
   mCurrentMenu = nullptr;
 }
 class nsMenuBarSwitchMenu : public nsRunnable
 {
 public:
   nsMenuBarSwitchMenu(nsIContent* aMenuBar,
                       nsIContent *aOldMenu,
                       nsIContent *aNewMenu,
                       bool aSelectFirstItem)
     : mMenuBar(aMenuBar), mOldMenu(aOldMenu), mNewMenu(aNewMenu),
       mSelectFirstItem(aSelectFirstItem)
   {
   }
   NS_IMETHOD Run() MOZ_OVERRIDE
   {
     nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
     if (!pm)
       return NS_ERROR_UNEXPECTED;
     // if switching from one menu to another, set a flag so that the call to
     // HidePopup doesn't deactivate the menubar when the first menu closes.
     nsMenuBarFrame* menubar = nullptr;
     if (mOldMenu && mNewMenu) {
       menubar = do_QueryFrame(mMenuBar->GetPrimaryFrame());
       if (menubar)
         menubar->SetStayActive(true);
     }
     if (mOldMenu) {
       nsWeakFrame weakMenuBar(menubar);
       pm->HidePopup(mOldMenu, false, false, false, false);
       // clear the flag again
       if (mNewMenu && weakMenuBar.IsAlive())
         menubar->SetStayActive(false);
     }
     if (mNewMenu)
       pm->ShowMenu(mNewMenu, mSelectFirstItem, false);
     return NS_OK;
   }
 private:
   nsCOMPtr<nsIContent> mMenuBar;
   nsCOMPtr<nsIContent> mOldMenu;
   nsCOMPtr<nsIContent> mNewMenu;
   bool mSelectFirstItem;
 };
 NS_IMETHODIMP
 nsMenuBarFrame::ChangeMenuItem(nsMenuFrame* aMenuItem,
                                bool aSelectFirstItem)
 {
   if (mCurrentMenu == aMenuItem)
     return NS_OK;
   // check if there's an open context menu, we ignore this
   nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
   if (pm && pm->HasContextMenu(nullptr))
     return NS_OK;
   nsIContent* aOldMenu = nullptr, *aNewMenu = nullptr;
   // Unset the current child.
   bool wasOpen = false;
   if (mCurrentMenu) {
     wasOpen = mCurrentMenu->IsOpen();
     mCurrentMenu->SelectMenu(false);
     if (wasOpen) {
       nsMenuPopupFrame* popupFrame = mCurrentMenu->GetPopup();
       if (popupFrame)
         aOldMenu = popupFrame->GetContent();
     }
   }
   // set to null first in case the IsAlive check below returns false
   mCurrentMenu = nullptr;
   // Set the new child.
   if (aMenuItem) {
     nsCOMPtr<nsIContent> content = aMenuItem->GetContent();
     aMenuItem->SelectMenu(true);
     mCurrentMenu = aMenuItem;
     if (wasOpen && !aMenuItem->IsDisabled())
       aNewMenu = content;
   }
   // use an event so that hiding and showing can be done synchronously, which
   // avoids flickering
   nsCOMPtr<nsIRunnable> event =
     new nsMenuBarSwitchMenu(GetContent(), aOldMenu, aNewMenu, aSelectFirstItem);
   return NS_DispatchToCurrentThread(event);
 }
 nsMenuFrame*
 nsMenuBarFrame::Enter(WidgetGUIEvent* aEvent)
 {
   if (!mCurrentMenu)
     return nullptr;
   if (mCurrentMenu->IsOpen())
     return mCurrentMenu->Enter(aEvent);
   return mCurrentMenu;
 }
 bool
 nsMenuBarFrame::MenuClosed()
 {
   SetActive(false);
   if (!mIsActive && mCurrentMenu) {
     mCurrentMenu->SelectMenu(false);
     mCurrentMenu = nullptr;
     return true;
   }
   return false;
 }
 void
 nsMenuBarFrame::InstallKeyboardNavigator()
 {
   nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
   if (pm)
     pm->SetActiveMenuBar(this, true);
 }
 void
 nsMenuBarFrame::RemoveKeyboardNavigator()
 {
   if (!mIsActive) {
     nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
     if (pm)
       pm->SetActiveMenuBar(this, false);
   }
 }
 void
 nsMenuBarFrame::DestroyFrom(nsIFrame* aDestructRoot)
 {
   nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
   if (pm)
     pm->SetActiveMenuBar(this, false);
   mTarget->RemoveEventListener(NS_LITERAL_STRING("keypress"), mMenuBarListener, false);
   mTarget->RemoveEventListener(NS_LITERAL_STRING("keydown"), mMenuBarListener, false);
   mTarget->RemoveEventListener(NS_LITERAL_STRING("keyup"), mMenuBarListener, false);
   mTarget->RemoveEventListener(NS_LITERAL_STRING("mousedown"), mMenuBarListener, true);
   mTarget->RemoveEventListener(NS_LITERAL_STRING("mousedown"), mMenuBarListener, false);
   mTarget->RemoveEventListener(NS_LITERAL_STRING("blur"), mMenuBarListener, true);
   NS_IF_RELEASE(mMenuBarListener);
   nsBoxFrame::DestroyFrom(aDestructRoot);
 }

The Tor Browser / annotate

layout/xul/nsMenuBarFrame.cpp@7e26c7da4463 (annotated)

layout/xul/nsMenuBarFrame.cpp