michael@0: /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: #include "nscore.h"
michael@0: #include "nsCOMPtr.h"
michael@0: #include "nsUnicharUtils.h"
michael@0: #include "nsListControlFrame.h"
michael@0: #include "nsFormControlFrame.h" // for COMPARE macro
michael@0: #include "nsGkAtoms.h"
michael@0: #include "nsIDOMHTMLSelectElement.h"
michael@0: #include "nsIDOMHTMLOptionElement.h"
michael@0: #include "nsComboboxControlFrame.h"
michael@0: #include "nsIDOMHTMLOptGroupElement.h"
michael@0: #include "nsIPresShell.h"
michael@0: #include "nsIDOMMouseEvent.h"
michael@0: #include "nsIXULRuntime.h"
michael@0: #include "nsFontMetrics.h"
michael@0: #include "nsIScrollableFrame.h"
michael@0: #include "nsCSSRendering.h"
michael@0: #include "nsIDOMEventListener.h"
michael@0: #include "nsLayoutUtils.h"
michael@0: #include "nsDisplayList.h"
michael@0: #include "nsContentUtils.h"
michael@0: #include "mozilla/Attributes.h"
michael@0: #include "mozilla/dom/HTMLOptionsCollection.h"
michael@0: #include "mozilla/dom/HTMLSelectElement.h"
michael@0: #include "mozilla/EventStateManager.h"
michael@0: #include "mozilla/EventStates.h"
michael@0: #include "mozilla/LookAndFeel.h"
michael@0: #include "mozilla/MouseEvents.h"
michael@0: #include "mozilla/Preferences.h"
michael@0: #include "mozilla/TextEvents.h"
michael@0: #include <algorithm>
michael@0: 
michael@0: using namespace mozilla;
michael@0: 
michael@0: // Constants
michael@0: const uint32_t kMaxDropDownRows         = 20; // This matches the setting for 4.x browsers
michael@0: const int32_t kNothingSelected          = -1;
michael@0: 
michael@0: // Static members
michael@0: nsListControlFrame * nsListControlFrame::mFocused = nullptr;
michael@0: nsString * nsListControlFrame::sIncrementalString = nullptr;
michael@0: 
michael@0: // Using for incremental typing navigation
michael@0: #define INCREMENTAL_SEARCH_KEYPRESS_TIME 1000
michael@0: // XXX, kyle.yuan@sun.com, there are 4 definitions for the same purpose:
michael@0: //  nsMenuPopupFrame.h, nsListControlFrame.cpp, listbox.xml, tree.xml
michael@0: //  need to find a good place to put them together.
michael@0: //  if someone changes one, please also change the other.
michael@0: 
michael@0: DOMTimeStamp nsListControlFrame::gLastKeyTime = 0;
michael@0: 
michael@0: /******************************************************************************
michael@0:  * nsListEventListener
michael@0:  * This class is responsible for propagating events to the nsListControlFrame.
michael@0:  * Frames are not refcounted so they can't be used as event listeners.
michael@0:  *****************************************************************************/
michael@0: 
michael@0: class nsListEventListener MOZ_FINAL : public nsIDOMEventListener
michael@0: {
michael@0: public:
michael@0:   nsListEventListener(nsListControlFrame *aFrame)
michael@0:     : mFrame(aFrame) { }
michael@0: 
michael@0:   void SetFrame(nsListControlFrame *aFrame) { mFrame = aFrame; }
michael@0: 
michael@0:   NS_DECL_ISUPPORTS
michael@0:   NS_DECL_NSIDOMEVENTLISTENER
michael@0: 
michael@0: private:
michael@0:   nsListControlFrame  *mFrame;
michael@0: };
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: nsIFrame*
michael@0: NS_NewListControlFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
michael@0: {
michael@0:   nsListControlFrame* it =
michael@0:     new (aPresShell) nsListControlFrame(aPresShell, aPresShell->GetDocument(), aContext);
michael@0: 
michael@0:   it->AddStateBits(NS_FRAME_INDEPENDENT_SELECTION);
michael@0: 
michael@0:   return it;
michael@0: }
michael@0: 
michael@0: NS_IMPL_FRAMEARENA_HELPERS(nsListControlFrame)
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: nsListControlFrame::nsListControlFrame(
michael@0:   nsIPresShell* aShell, nsIDocument* aDocument, nsStyleContext* aContext)
michael@0:   : nsHTMLScrollFrame(aShell, aContext, false),
michael@0:     mMightNeedSecondPass(false),
michael@0:     mHasPendingInterruptAtStartOfReflow(false),
michael@0:     mDropdownCanGrow(false),
michael@0:     mLastDropdownComputedHeight(NS_UNCONSTRAINEDSIZE)
michael@0: {
michael@0:   mComboboxFrame      = nullptr;
michael@0:   mChangesSinceDragStart = false;
michael@0:   mButtonDown         = false;
michael@0: 
michael@0:   mIsAllContentHere   = false;
michael@0:   mIsAllFramesHere    = false;
michael@0:   mHasBeenInitialized = false;
michael@0:   mNeedToReset        = true;
michael@0:   mPostChildrenLoadedReset = false;
michael@0: 
michael@0:   mControlSelectMode           = false;
michael@0: }
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: nsListControlFrame::~nsListControlFrame()
michael@0: {
michael@0:   mComboboxFrame = nullptr;
michael@0: }
michael@0: 
michael@0: // for Bug 47302 (remove this comment later)
michael@0: void
michael@0: nsListControlFrame::DestroyFrom(nsIFrame* aDestructRoot)
michael@0: {
michael@0:   // get the receiver interface from the browser button's content node
michael@0:   ENSURE_TRUE(mContent);
michael@0: 
michael@0:   // Clear the frame pointer on our event listener, just in case the
michael@0:   // event listener can outlive the frame.
michael@0: 
michael@0:   mEventListener->SetFrame(nullptr);
michael@0: 
michael@0:   mContent->RemoveSystemEventListener(NS_LITERAL_STRING("keydown"),
michael@0:                                       mEventListener, false);
michael@0:   mContent->RemoveSystemEventListener(NS_LITERAL_STRING("keypress"),
michael@0:                                       mEventListener, false);
michael@0:   mContent->RemoveSystemEventListener(NS_LITERAL_STRING("mousedown"),
michael@0:                                       mEventListener, false);
michael@0:   mContent->RemoveSystemEventListener(NS_LITERAL_STRING("mouseup"),
michael@0:                                       mEventListener, false);
michael@0:   mContent->RemoveSystemEventListener(NS_LITERAL_STRING("mousemove"),
michael@0:                                       mEventListener, false);
michael@0: 
michael@0:   nsFormControlFrame::RegUnRegAccessKey(static_cast<nsIFrame*>(this), false);
michael@0:   nsHTMLScrollFrame::DestroyFrom(aDestructRoot);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,
michael@0:                                      const nsRect&           aDirtyRect,
michael@0:                                      const nsDisplayListSet& aLists)
michael@0: {
michael@0:   // We allow visibility:hidden <select>s to contain visible options.
michael@0:   
michael@0:   // Don't allow painting of list controls when painting is suppressed.
michael@0:   // XXX why do we need this here? we should never reach this. Maybe
michael@0:   // because these can have widgets? Hmm
michael@0:   if (aBuilder->IsBackgroundOnly())
michael@0:     return;
michael@0: 
michael@0:   DO_GLOBAL_REFLOW_COUNT_DSP("nsListControlFrame");
michael@0: 
michael@0:   if (IsInDropDownMode()) {
michael@0:     NS_ASSERTION(NS_GET_A(mLastDropdownBackstopColor) == 255,
michael@0:                  "need an opaque backstop color");
michael@0:     // XXX Because we have an opaque widget and we get called to paint with
michael@0:     // this frame as the root of a stacking context we need make sure to draw
michael@0:     // some opaque color over the whole widget. (Bug 511323)
michael@0:     aLists.BorderBackground()->AppendNewToBottom(
michael@0:       new (aBuilder) nsDisplaySolidColor(aBuilder,
michael@0:         this, nsRect(aBuilder->ToReferenceFrame(this), GetSize()),
michael@0:         mLastDropdownBackstopColor));
michael@0:   }
michael@0: 
michael@0:   nsHTMLScrollFrame::BuildDisplayList(aBuilder, aDirtyRect, aLists);
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * This is called by the SelectsAreaFrame, which is the same
michael@0:  * as the frame returned by GetOptionsContainer. It's the frame which is
michael@0:  * scrolled by us.
michael@0:  * @param aPt the offset of this frame, relative to the rendering reference
michael@0:  * frame
michael@0:  */
michael@0: void nsListControlFrame::PaintFocus(nsRenderingContext& aRC, nsPoint aPt)
michael@0: {
michael@0:   if (mFocused != this) return;
michael@0: 
michael@0:   nsPresContext* presContext = PresContext();
michael@0: 
michael@0:   nsIFrame* containerFrame = GetOptionsContainer();
michael@0:   if (!containerFrame) return;
michael@0: 
michael@0:   nsIFrame* childframe = nullptr;
michael@0:   nsCOMPtr<nsIContent> focusedContent = GetCurrentOption();
michael@0:   if (focusedContent) {
michael@0:     childframe = focusedContent->GetPrimaryFrame();
michael@0:   }
michael@0: 
michael@0:   nsRect fRect;
michael@0:   if (childframe) {
michael@0:     // get the child rect
michael@0:     fRect = childframe->GetRect();
michael@0:     // get it into our coordinates
michael@0:     fRect.MoveBy(childframe->GetParent()->GetOffsetTo(this));
michael@0:   } else {
michael@0:     float inflation = nsLayoutUtils::FontSizeInflationFor(this);
michael@0:     fRect.x = fRect.y = 0;
michael@0:     fRect.width = GetScrollPortRect().width;
michael@0:     fRect.height = CalcFallbackRowHeight(inflation);
michael@0:     fRect.MoveBy(containerFrame->GetOffsetTo(this));
michael@0:   }
michael@0:   fRect += aPt;
michael@0:   
michael@0:   bool lastItemIsSelected = false;
michael@0:   if (focusedContent) {
michael@0:     nsCOMPtr<nsIDOMHTMLOptionElement> domOpt =
michael@0:       do_QueryInterface(focusedContent);
michael@0:     if (domOpt) {
michael@0:       domOpt->GetSelected(&lastItemIsSelected);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // set up back stop colors and then ask L&F service for the real colors
michael@0:   nscolor color =
michael@0:     LookAndFeel::GetColor(lastItemIsSelected ?
michael@0:                             LookAndFeel::eColorID_WidgetSelectForeground :
michael@0:                             LookAndFeel::eColorID_WidgetSelectBackground);
michael@0: 
michael@0:   nsCSSRendering::PaintFocus(presContext, aRC, fRect, color);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::InvalidateFocus()
michael@0: {
michael@0:   if (mFocused != this)
michael@0:     return;
michael@0: 
michael@0:   nsIFrame* containerFrame = GetOptionsContainer();
michael@0:   if (containerFrame) {
michael@0:     containerFrame->InvalidateFrame();
michael@0:   }
michael@0: }
michael@0: 
michael@0: NS_QUERYFRAME_HEAD(nsListControlFrame)
michael@0:   NS_QUERYFRAME_ENTRY(nsIFormControlFrame)
michael@0:   NS_QUERYFRAME_ENTRY(nsIListControlFrame)
michael@0:   NS_QUERYFRAME_ENTRY(nsISelectControlFrame)
michael@0: NS_QUERYFRAME_TAIL_INHERITING(nsHTMLScrollFrame)
michael@0: 
michael@0: #ifdef ACCESSIBILITY
michael@0: a11y::AccType
michael@0: nsListControlFrame::AccessibleType()
michael@0: {
michael@0:   return a11y::eHTMLSelectListType;
michael@0: }
michael@0: #endif
michael@0: 
michael@0: static nscoord
michael@0: GetMaxOptionHeight(nsIFrame* aContainer)
michael@0: {
michael@0:   nscoord result = 0;
michael@0:   for (nsIFrame* option = aContainer->GetFirstPrincipalChild();
michael@0:        option; option = option->GetNextSibling()) {
michael@0:     nscoord optionHeight;
michael@0:     if (nsCOMPtr<nsIDOMHTMLOptGroupElement>
michael@0:         (do_QueryInterface(option->GetContent()))) {
michael@0:       // an optgroup
michael@0:       optionHeight = GetMaxOptionHeight(option);
michael@0:     } else {
michael@0:       // an option
michael@0:       optionHeight = option->GetSize().height;
michael@0:     }
michael@0:     if (result < optionHeight)
michael@0:       result = optionHeight;
michael@0:   }
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: //-----------------------------------------------------------------
michael@0: // Main Reflow for ListBox/Dropdown
michael@0: //-----------------------------------------------------------------
michael@0: 
michael@0: nscoord
michael@0: nsListControlFrame::CalcHeightOfARow()
michael@0: {
michael@0:   // Calculate the height of a single row in the listbox or dropdown list by
michael@0:   // using the tallest thing in the subtree, since there may be option groups
michael@0:   // in addition to option elements, either of which may be visible or
michael@0:   // invisible, may use different fonts, etc.
michael@0:   int32_t heightOfARow = GetMaxOptionHeight(GetOptionsContainer());
michael@0: 
michael@0:   // Check to see if we have zero items (and optimize by checking
michael@0:   // heightOfARow first)
michael@0:   if (heightOfARow == 0 && GetNumberOfOptions() == 0) {
michael@0:     float inflation = nsLayoutUtils::FontSizeInflationFor(this);
michael@0:     heightOfARow = CalcFallbackRowHeight(inflation);
michael@0:   }
michael@0: 
michael@0:   return heightOfARow;
michael@0: }
michael@0: 
michael@0: nscoord
michael@0: nsListControlFrame::GetPrefWidth(nsRenderingContext *aRenderingContext)
michael@0: {
michael@0:   nscoord result;
michael@0:   DISPLAY_PREF_WIDTH(this, result);
michael@0: 
michael@0:   // Always add scrollbar widths to the pref-width of the scrolled
michael@0:   // content. Combobox frames depend on this happening in the dropdown,
michael@0:   // and standalone listboxes are overflow:scroll so they need it too.
michael@0:   result = GetScrolledFrame()->GetPrefWidth(aRenderingContext);
michael@0:   result = NSCoordSaturatingAdd(result,
michael@0:           GetDesiredScrollbarSizes(PresContext(), aRenderingContext).LeftRight());
michael@0: 
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: nscoord
michael@0: nsListControlFrame::GetMinWidth(nsRenderingContext *aRenderingContext)
michael@0: {
michael@0:   nscoord result;
michael@0:   DISPLAY_MIN_WIDTH(this, result);
michael@0: 
michael@0:   // Always add scrollbar widths to the min-width of the scrolled
michael@0:   // content. Combobox frames depend on this happening in the dropdown,
michael@0:   // and standalone listboxes are overflow:scroll so they need it too.
michael@0:   result = GetScrolledFrame()->GetMinWidth(aRenderingContext);
michael@0:   result += GetDesiredScrollbarSizes(PresContext(), aRenderingContext).LeftRight();
michael@0: 
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: nsresult 
michael@0: nsListControlFrame::Reflow(nsPresContext*           aPresContext, 
michael@0:                            nsHTMLReflowMetrics&     aDesiredSize,
michael@0:                            const nsHTMLReflowState& aReflowState, 
michael@0:                            nsReflowStatus&          aStatus)
michael@0: {
michael@0:   NS_PRECONDITION(aReflowState.ComputedWidth() != NS_UNCONSTRAINEDSIZE,
michael@0:                   "Must have a computed width");
michael@0: 
michael@0:   SchedulePaint();
michael@0: 
michael@0:   mHasPendingInterruptAtStartOfReflow = aPresContext->HasPendingInterrupt();
michael@0: 
michael@0:   // If all the content and frames are here 
michael@0:   // then initialize it before reflow
michael@0:   if (mIsAllContentHere && !mHasBeenInitialized) {
michael@0:     if (false == mIsAllFramesHere) {
michael@0:       CheckIfAllFramesHere();
michael@0:     }
michael@0:     if (mIsAllFramesHere && !mHasBeenInitialized) {
michael@0:       mHasBeenInitialized = true;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (GetStateBits() & NS_FRAME_FIRST_REFLOW) {
michael@0:     nsFormControlFrame::RegUnRegAccessKey(this, true);
michael@0:   }
michael@0: 
michael@0:   if (IsInDropDownMode()) {
michael@0:     return ReflowAsDropdown(aPresContext, aDesiredSize, aReflowState, aStatus);
michael@0:   }
michael@0: 
michael@0:   /*
michael@0:    * Due to the fact that our intrinsic height depends on the heights of our
michael@0:    * kids, we end up having to do two-pass reflow, in general -- the first pass
michael@0:    * to find the intrinsic height and a second pass to reflow the scrollframe
michael@0:    * at that height (which will size the scrollbars correctly, etc).
michael@0:    *
michael@0:    * Naturaly, we want to avoid doing the second reflow as much as possible.
michael@0:    * We can skip it in the following cases (in all of which the first reflow is
michael@0:    * already happening at the right height):
michael@0:    *
michael@0:    * - We're reflowing with a constrained computed height -- just use that
michael@0:    *   height.
michael@0:    * - We're not dirty and have no dirty kids and shouldn't be reflowing all
michael@0:    *   kids.  In this case, our cached max height of a child is not going to
michael@0:    *   change.
michael@0:    * - We do our first reflow using our cached max height of a child, then
michael@0:    *   compute the new max height and it's the same as the old one.
michael@0:    */
michael@0: 
michael@0:   bool autoHeight = (aReflowState.ComputedHeight() == NS_UNCONSTRAINEDSIZE);
michael@0: 
michael@0:   mMightNeedSecondPass = autoHeight &&
michael@0:     (NS_SUBTREE_DIRTY(this) || aReflowState.ShouldReflowAllKids());
michael@0:   
michael@0:   nsHTMLReflowState state(aReflowState);
michael@0:   int32_t length = GetNumberOfRows();
michael@0: 
michael@0:   nscoord oldHeightOfARow = HeightOfARow();
michael@0: 
michael@0:   if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW) && autoHeight) {
michael@0:     // When not doing an initial reflow, and when the height is auto, start off
michael@0:     // with our computed height set to what we'd expect our height to be.
michael@0:     nscoord computedHeight = CalcIntrinsicHeight(oldHeightOfARow, length);
michael@0:     computedHeight = state.ApplyMinMaxHeight(computedHeight);
michael@0:     state.SetComputedHeight(computedHeight);
michael@0:   }
michael@0: 
michael@0:   nsresult rv = nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize,
michael@0:                                           state, aStatus);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   if (!mMightNeedSecondPass) {
michael@0:     NS_ASSERTION(!autoHeight || HeightOfARow() == oldHeightOfARow,
michael@0:                  "How did our height of a row change if nothing was dirty?");
michael@0:     NS_ASSERTION(!autoHeight ||
michael@0:                  !(GetStateBits() & NS_FRAME_FIRST_REFLOW),
michael@0:                  "How do we not need a second pass during initial reflow at "
michael@0:                  "auto height?");
michael@0:     NS_ASSERTION(!IsScrollbarUpdateSuppressed(),
michael@0:                  "Shouldn't be suppressing if we don't need a second pass!");
michael@0:     if (!autoHeight) {
michael@0:       // Update our mNumDisplayRows based on our new row height now that we
michael@0:       // know it.  Note that if autoHeight and we landed in this code then we
michael@0:       // already set mNumDisplayRows in CalcIntrinsicHeight.  Also note that we
michael@0:       // can't use HeightOfARow() here because that just uses a cached value
michael@0:       // that we didn't compute.
michael@0:       nscoord rowHeight = CalcHeightOfARow();
michael@0:       if (rowHeight == 0) {
michael@0:         // Just pick something
michael@0:         mNumDisplayRows = 1;
michael@0:       } else {
michael@0:         mNumDisplayRows = std::max(1, state.ComputedHeight() / rowHeight);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   mMightNeedSecondPass = false;
michael@0: 
michael@0:   // Now see whether we need a second pass.  If we do, our nsSelectsAreaFrame
michael@0:   // will have suppressed the scrollbar update.
michael@0:   if (!IsScrollbarUpdateSuppressed()) {
michael@0:     // All done.  No need to do more reflow.
michael@0:     NS_ASSERTION(!IsScrollbarUpdateSuppressed(),
michael@0:                  "Shouldn't be suppressing if the height of a row has not "
michael@0:                  "changed!");
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   SetSuppressScrollbarUpdate(false);
michael@0: 
michael@0:   // Gotta reflow again.
michael@0:   // XXXbz We're just changing the height here; do we need to dirty ourselves
michael@0:   // or anything like that?  We might need to, per the letter of the reflow
michael@0:   // protocol, but things seem to work fine without it...  Is that just an
michael@0:   // implementation detail of nsHTMLScrollFrame that we're depending on?
michael@0:   nsHTMLScrollFrame::DidReflow(aPresContext, &state,
michael@0:                                nsDidReflowStatus::FINISHED);
michael@0: 
michael@0:   // Now compute the height we want to have
michael@0:   nscoord computedHeight = CalcIntrinsicHeight(HeightOfARow(), length); 
michael@0:   computedHeight = state.ApplyMinMaxHeight(computedHeight);
michael@0:   state.SetComputedHeight(computedHeight);
michael@0: 
michael@0:   nsHTMLScrollFrame::WillReflow(aPresContext);
michael@0: 
michael@0:   // XXXbz to make the ascent really correct, we should add our
michael@0:   // mComputedPadding.top to it (and subtract it from descent).  Need that
michael@0:   // because nsGfxScrollFrame just adds in the border....
michael@0:   return nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsListControlFrame::ReflowAsDropdown(nsPresContext*           aPresContext, 
michael@0:                                      nsHTMLReflowMetrics&     aDesiredSize,
michael@0:                                      const nsHTMLReflowState& aReflowState, 
michael@0:                                      nsReflowStatus&          aStatus)
michael@0: {
michael@0:   NS_PRECONDITION(aReflowState.ComputedHeight() == NS_UNCONSTRAINEDSIZE,
michael@0:                   "We should not have a computed height here!");
michael@0:   
michael@0:   mMightNeedSecondPass = NS_SUBTREE_DIRTY(this) ||
michael@0:     aReflowState.ShouldReflowAllKids();
michael@0: 
michael@0: #ifdef DEBUG
michael@0:   nscoord oldHeightOfARow = HeightOfARow();
michael@0:   nscoord oldVisibleHeight = (GetStateBits() & NS_FRAME_FIRST_REFLOW) ?
michael@0:     NS_UNCONSTRAINEDSIZE : GetScrolledFrame()->GetSize().height;
michael@0: #endif
michael@0: 
michael@0:   nsHTMLReflowState state(aReflowState);
michael@0: 
michael@0:   if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
michael@0:     // When not doing an initial reflow, and when the height is auto, start off
michael@0:     // with our computed height set to what we'd expect our height to be.
michael@0:     // Note: At this point, mLastDropdownComputedHeight can be
michael@0:     // NS_UNCONSTRAINEDSIZE in cases when last time we didn't have to constrain
michael@0:     // the height.  That's fine; just do the same thing as last time.
michael@0:     state.SetComputedHeight(mLastDropdownComputedHeight);
michael@0:   }
michael@0: 
michael@0:   nsresult rv = nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize,
michael@0:                                           state, aStatus);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   if (!mMightNeedSecondPass) {
michael@0:     NS_ASSERTION(oldVisibleHeight == GetScrolledFrame()->GetSize().height,
michael@0:                  "How did our kid's height change if nothing was dirty?");
michael@0:     NS_ASSERTION(HeightOfARow() == oldHeightOfARow,
michael@0:                  "How did our height of a row change if nothing was dirty?");
michael@0:     NS_ASSERTION(!IsScrollbarUpdateSuppressed(),
michael@0:                  "Shouldn't be suppressing if we don't need a second pass!");
michael@0:     NS_ASSERTION(!(GetStateBits() & NS_FRAME_FIRST_REFLOW),
michael@0:                  "How can we avoid a second pass during first reflow?");
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   mMightNeedSecondPass = false;
michael@0: 
michael@0:   // Now see whether we need a second pass.  If we do, our nsSelectsAreaFrame
michael@0:   // will have suppressed the scrollbar update.
michael@0:   if (!IsScrollbarUpdateSuppressed()) {
michael@0:     // All done.  No need to do more reflow.
michael@0:     NS_ASSERTION(!(GetStateBits() & NS_FRAME_FIRST_REFLOW),
michael@0:                  "How can we avoid a second pass during first reflow?");
michael@0:     return rv;
michael@0:   }
michael@0: 
michael@0:   SetSuppressScrollbarUpdate(false);
michael@0: 
michael@0:   nscoord visibleHeight = GetScrolledFrame()->GetSize().height;
michael@0:   nscoord heightOfARow = HeightOfARow();
michael@0: 
michael@0:   // Gotta reflow again.
michael@0:   // XXXbz We're just changing the height here; do we need to dirty ourselves
michael@0:   // or anything like that?  We might need to, per the letter of the reflow
michael@0:   // protocol, but things seem to work fine without it...  Is that just an
michael@0:   // implementation detail of nsHTMLScrollFrame that we're depending on?
michael@0:   nsHTMLScrollFrame::DidReflow(aPresContext, &state,
michael@0:                                nsDidReflowStatus::FINISHED);
michael@0: 
michael@0:   // Now compute the height we want to have.
michael@0:   // Note: no need to apply min/max constraints, since we have no such
michael@0:   // rules applied to the combobox dropdown.
michael@0: 
michael@0:   mDropdownCanGrow = false;
michael@0:   if (visibleHeight <= 0 || heightOfARow <= 0) {
michael@0:     // Looks like we have no options.  Just size us to a single row height.
michael@0:     state.SetComputedHeight(heightOfARow);
michael@0:     mNumDisplayRows = 1;
michael@0:   } else {
michael@0:     nsComboboxControlFrame* combobox = static_cast<nsComboboxControlFrame*>(mComboboxFrame);
michael@0:     nsPoint translation;
michael@0:     nscoord above, below;
michael@0:     combobox->GetAvailableDropdownSpace(&above, &below, &translation);
michael@0:     if (above <= 0 && below <= 0) {
michael@0:       state.SetComputedHeight(heightOfARow);
michael@0:       mNumDisplayRows = 1;
michael@0:       mDropdownCanGrow = GetNumberOfRows() > 1;
michael@0:     } else {
michael@0:       nscoord bp = aReflowState.ComputedPhysicalBorderPadding().TopBottom();
michael@0:       nscoord availableHeight = std::max(above, below) - bp;
michael@0:       nscoord newHeight;
michael@0:       uint32_t rows;
michael@0:       if (visibleHeight <= availableHeight) {
michael@0:         // The dropdown fits in the available height.
michael@0:         rows = GetNumberOfRows();
michael@0:         mNumDisplayRows = clamped<uint32_t>(rows, 1, kMaxDropDownRows);
michael@0:         if (mNumDisplayRows == rows) {
michael@0:           newHeight = visibleHeight;  // use the exact height
michael@0:         } else {
michael@0:           newHeight = mNumDisplayRows * heightOfARow; // approximate
michael@0:         }
michael@0:       } else {
michael@0:         rows = availableHeight / heightOfARow;
michael@0:         mNumDisplayRows = clamped<uint32_t>(rows, 1, kMaxDropDownRows);
michael@0:         newHeight = mNumDisplayRows * heightOfARow; // approximate
michael@0:       }
michael@0:       state.SetComputedHeight(newHeight);
michael@0:       mDropdownCanGrow = visibleHeight - newHeight >= heightOfARow &&
michael@0:                          mNumDisplayRows != kMaxDropDownRows;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   mLastDropdownComputedHeight = state.ComputedHeight();
michael@0: 
michael@0:   nsHTMLScrollFrame::WillReflow(aPresContext);
michael@0:   return nsHTMLScrollFrame::Reflow(aPresContext, aDesiredSize, state, aStatus);
michael@0: }
michael@0: 
michael@0: ScrollbarStyles
michael@0: nsListControlFrame::GetScrollbarStyles() const
michael@0: {
michael@0:   // We can't express this in the style system yet; when we can, this can go away
michael@0:   // and GetScrollbarStyles can be devirtualized
michael@0:   int32_t verticalStyle = IsInDropDownMode() ? NS_STYLE_OVERFLOW_AUTO
michael@0:     : NS_STYLE_OVERFLOW_SCROLL;
michael@0:   return ScrollbarStyles(NS_STYLE_OVERFLOW_HIDDEN, verticalStyle);
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsListControlFrame::ShouldPropagateComputedHeightToScrolledContent() const
michael@0: {
michael@0:   return !IsInDropDownMode();
michael@0: }
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: nsIFrame*
michael@0: nsListControlFrame::GetContentInsertionFrame() {
michael@0:   return GetOptionsContainer()->GetContentInsertionFrame();
michael@0: }
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: bool
michael@0: nsListControlFrame::ExtendedSelection(int32_t aStartIndex,
michael@0:                                       int32_t aEndIndex,
michael@0:                                       bool aClearAll)
michael@0: {
michael@0:   return SetOptionsSelectedFromFrame(aStartIndex, aEndIndex,
michael@0:                                      true, aClearAll);
michael@0: }
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: bool
michael@0: nsListControlFrame::SingleSelection(int32_t aClickedIndex, bool aDoToggle)
michael@0: {
michael@0:   if (mComboboxFrame) {
michael@0:     mComboboxFrame->UpdateRecentIndex(GetSelectedIndex());
michael@0:   }
michael@0: 
michael@0:   bool wasChanged = false;
michael@0:   // Get Current selection
michael@0:   if (aDoToggle) {
michael@0:     wasChanged = ToggleOptionSelectedFromFrame(aClickedIndex);
michael@0:   } else {
michael@0:     wasChanged = SetOptionsSelectedFromFrame(aClickedIndex, aClickedIndex,
michael@0:                                 true, true);
michael@0:   }
michael@0:   nsWeakFrame weakFrame(this);
michael@0:   ScrollToIndex(aClickedIndex);
michael@0:   if (!weakFrame.IsAlive()) {
michael@0:     return wasChanged;
michael@0:   }
michael@0: 
michael@0: #ifdef ACCESSIBILITY
michael@0:   bool isCurrentOptionChanged = mEndSelectionIndex != aClickedIndex;
michael@0: #endif
michael@0:   mStartSelectionIndex = aClickedIndex;
michael@0:   mEndSelectionIndex = aClickedIndex;
michael@0:   InvalidateFocus();
michael@0: 
michael@0: #ifdef ACCESSIBILITY
michael@0:   if (isCurrentOptionChanged) {
michael@0:     FireMenuItemActiveEvent();
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   return wasChanged;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::InitSelectionRange(int32_t aClickedIndex)
michael@0: {
michael@0:   //
michael@0:   // If nothing is selected, set the start selection depending on where
michael@0:   // the user clicked and what the initial selection is:
michael@0:   // - if the user clicked *before* selectedIndex, set the start index to
michael@0:   //   the end of the first contiguous selection.
michael@0:   // - if the user clicked *after* the end of the first contiguous
michael@0:   //   selection, set the start index to selectedIndex.
michael@0:   // - if the user clicked *within* the first contiguous selection, set the
michael@0:   //   start index to selectedIndex.
michael@0:   // The last two rules, of course, boil down to the same thing: if the user
michael@0:   // clicked >= selectedIndex, return selectedIndex.
michael@0:   //
michael@0:   // This makes it so that shift click works properly when you first click
michael@0:   // in a multiple select.
michael@0:   //
michael@0:   int32_t selectedIndex = GetSelectedIndex();
michael@0:   if (selectedIndex >= 0) {
michael@0:     // Get the end of the contiguous selection
michael@0:     nsRefPtr<dom::HTMLOptionsCollection> options = GetOptions();
michael@0:     NS_ASSERTION(options, "Collection of options is null!");
michael@0:     uint32_t numOptions = options->Length();
michael@0:     // Push i to one past the last selected index in the group.
michael@0:     uint32_t i;
michael@0:     for (i = selectedIndex + 1; i < numOptions; i++) {
michael@0:       if (!options->ItemAsOption(i)->Selected()) {
michael@0:         break;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     if (aClickedIndex < selectedIndex) {
michael@0:       // User clicked before selection, so start selection at end of
michael@0:       // contiguous selection
michael@0:       mStartSelectionIndex = i-1;
michael@0:       mEndSelectionIndex = selectedIndex;
michael@0:     } else {
michael@0:       // User clicked after selection, so start selection at start of
michael@0:       // contiguous selection
michael@0:       mStartSelectionIndex = selectedIndex;
michael@0:       mEndSelectionIndex = i-1;
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: static uint32_t
michael@0: CountOptionsAndOptgroups(nsIFrame* aFrame)
michael@0: {
michael@0:   uint32_t count = 0;
michael@0:   nsFrameList::Enumerator e(aFrame->PrincipalChildList());
michael@0:   for (; !e.AtEnd(); e.Next()) {
michael@0:     nsIFrame* child = e.get();
michael@0:     nsIContent* content = child->GetContent();
michael@0:     if (content) {
michael@0:       if (content->IsHTML(nsGkAtoms::option)) {
michael@0:         ++count;
michael@0:       } else {
michael@0:         nsCOMPtr<nsIDOMHTMLOptGroupElement> optgroup = do_QueryInterface(content);
michael@0:         if (optgroup) {
michael@0:           nsAutoString label;
michael@0:           optgroup->GetLabel(label);
michael@0:           if (label.Length() > 0) {
michael@0:             ++count;
michael@0:           }
michael@0:           count += CountOptionsAndOptgroups(child);
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0:   return count;
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: nsListControlFrame::GetNumberOfRows()
michael@0: {
michael@0:   return ::CountOptionsAndOptgroups(GetContentInsertionFrame());
michael@0: }
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: bool
michael@0: nsListControlFrame::PerformSelection(int32_t aClickedIndex,
michael@0:                                      bool aIsShift,
michael@0:                                      bool aIsControl)
michael@0: {
michael@0:   bool wasChanged = false;
michael@0: 
michael@0:   if (aClickedIndex == kNothingSelected) {
michael@0:   }
michael@0:   else if (GetMultiple()) {
michael@0:     if (aIsShift) {
michael@0:       // Make sure shift+click actually does something expected when
michael@0:       // the user has never clicked on the select
michael@0:       if (mStartSelectionIndex == kNothingSelected) {
michael@0:         InitSelectionRange(aClickedIndex);
michael@0:       }
michael@0: 
michael@0:       // Get the range from beginning (low) to end (high)
michael@0:       // Shift *always* works, even if the current option is disabled
michael@0:       int32_t startIndex;
michael@0:       int32_t endIndex;
michael@0:       if (mStartSelectionIndex == kNothingSelected) {
michael@0:         startIndex = aClickedIndex;
michael@0:         endIndex   = aClickedIndex;
michael@0:       } else if (mStartSelectionIndex <= aClickedIndex) {
michael@0:         startIndex = mStartSelectionIndex;
michael@0:         endIndex   = aClickedIndex;
michael@0:       } else {
michael@0:         startIndex = aClickedIndex;
michael@0:         endIndex   = mStartSelectionIndex;
michael@0:       }
michael@0: 
michael@0:       // Clear only if control was not pressed
michael@0:       wasChanged = ExtendedSelection(startIndex, endIndex, !aIsControl);
michael@0:       nsWeakFrame weakFrame(this);
michael@0:       ScrollToIndex(aClickedIndex);
michael@0:       if (!weakFrame.IsAlive()) {
michael@0:         return wasChanged;
michael@0:       }
michael@0: 
michael@0:       if (mStartSelectionIndex == kNothingSelected) {
michael@0:         mStartSelectionIndex = aClickedIndex;
michael@0:       }
michael@0: #ifdef ACCESSIBILITY
michael@0:       bool isCurrentOptionChanged = mEndSelectionIndex != aClickedIndex;
michael@0: #endif
michael@0:       mEndSelectionIndex = aClickedIndex;
michael@0:       InvalidateFocus();
michael@0: 
michael@0: #ifdef ACCESSIBILITY
michael@0:       if (isCurrentOptionChanged) {
michael@0:         FireMenuItemActiveEvent();
michael@0:       }
michael@0: #endif
michael@0:     } else if (aIsControl) {
michael@0:       wasChanged = SingleSelection(aClickedIndex, true); // might destroy us
michael@0:     } else {
michael@0:       wasChanged = SingleSelection(aClickedIndex, false); // might destroy us
michael@0:     }
michael@0:   } else {
michael@0:     wasChanged = SingleSelection(aClickedIndex, false); // might destroy us
michael@0:   }
michael@0: 
michael@0:   return wasChanged;
michael@0: }
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: bool
michael@0: nsListControlFrame::HandleListSelection(nsIDOMEvent* aEvent,
michael@0:                                         int32_t aClickedIndex)
michael@0: {
michael@0:   nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aEvent);
michael@0:   bool isShift;
michael@0:   bool isControl;
michael@0: #ifdef XP_MACOSX
michael@0:   mouseEvent->GetMetaKey(&isControl);
michael@0: #else
michael@0:   mouseEvent->GetCtrlKey(&isControl);
michael@0: #endif
michael@0:   mouseEvent->GetShiftKey(&isShift);
michael@0:   return PerformSelection(aClickedIndex, isShift, isControl); // might destroy us
michael@0: }
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: void
michael@0: nsListControlFrame::CaptureMouseEvents(bool aGrabMouseEvents)
michael@0: {
michael@0:   // Currently cocoa widgets use a native popup widget which tracks clicks synchronously,
michael@0:   // so we never want to do mouse capturing. Note that we only bail if the list
michael@0:   // is in drop-down mode, and the caller is requesting capture (we let release capture
michael@0:   // requests go through to ensure that we can release capture requested via other
michael@0:   // code paths, if any exist).
michael@0:   if (aGrabMouseEvents && IsInDropDownMode() && nsComboboxControlFrame::ToolkitHasNativePopup())
michael@0:     return;
michael@0: 
michael@0:   if (aGrabMouseEvents) {
michael@0:     nsIPresShell::SetCapturingContent(mContent, CAPTURE_IGNOREALLOWED);
michael@0:   } else {
michael@0:     nsIContent* capturingContent = nsIPresShell::GetCapturingContent();
michael@0: 
michael@0:     bool dropDownIsHidden = false;
michael@0:     if (IsInDropDownMode()) {
michael@0:       dropDownIsHidden = !mComboboxFrame->IsDroppedDown();
michael@0:     }
michael@0:     if (capturingContent == mContent || dropDownIsHidden) {
michael@0:       // only clear the capturing content if *we* are the ones doing the
michael@0:       // capturing (or if the dropdown is hidden, in which case NO-ONE should
michael@0:       // be capturing anything - it could be a scrollbar inside this listbox
michael@0:       // which is actually grabbing
michael@0:       // This shouldn't be necessary. We should simply ensure that events targeting
michael@0:       // scrollbars are never visible to DOM consumers.
michael@0:       nsIPresShell::SetCapturingContent(nullptr, 0);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: nsresult 
michael@0: nsListControlFrame::HandleEvent(nsPresContext* aPresContext,
michael@0:                                 WidgetGUIEvent* aEvent,
michael@0:                                 nsEventStatus* aEventStatus)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aEventStatus);
michael@0: 
michael@0:   /*const char * desc[] = {"NS_MOUSE_MOVE", 
michael@0:                           "NS_MOUSE_LEFT_BUTTON_UP",
michael@0:                           "NS_MOUSE_LEFT_BUTTON_DOWN",
michael@0:                           "<NA>","<NA>","<NA>","<NA>","<NA>","<NA>","<NA>",
michael@0:                           "NS_MOUSE_MIDDLE_BUTTON_UP",
michael@0:                           "NS_MOUSE_MIDDLE_BUTTON_DOWN",
michael@0:                           "<NA>","<NA>","<NA>","<NA>","<NA>","<NA>","<NA>","<NA>",
michael@0:                           "NS_MOUSE_RIGHT_BUTTON_UP",
michael@0:                           "NS_MOUSE_RIGHT_BUTTON_DOWN",
michael@0:                           "NS_MOUSE_ENTER_SYNTH",
michael@0:                           "NS_MOUSE_EXIT_SYNTH",
michael@0:                           "NS_MOUSE_LEFT_DOUBLECLICK",
michael@0:                           "NS_MOUSE_MIDDLE_DOUBLECLICK",
michael@0:                           "NS_MOUSE_RIGHT_DOUBLECLICK",
michael@0:                           "NS_MOUSE_LEFT_CLICK",
michael@0:                           "NS_MOUSE_MIDDLE_CLICK",
michael@0:                           "NS_MOUSE_RIGHT_CLICK"};
michael@0:   int inx = aEvent->message-NS_MOUSE_MESSAGE_START;
michael@0:   if (inx >= 0 && inx <= (NS_MOUSE_RIGHT_CLICK-NS_MOUSE_MESSAGE_START)) {
michael@0:     printf("Mouse in ListFrame %s [%d]\n", desc[inx], aEvent->message);
michael@0:   } else {
michael@0:     printf("Mouse in ListFrame <UNKNOWN> [%d]\n", aEvent->message);
michael@0:   }*/
michael@0: 
michael@0:   if (nsEventStatus_eConsumeNoDefault == *aEventStatus)
michael@0:     return NS_OK;
michael@0: 
michael@0:   // do we have style that affects how we are selected?
michael@0:   // do we have user-input style?
michael@0:   const nsStyleUserInterface* uiStyle = StyleUserInterface();
michael@0:   if (uiStyle->mUserInput == NS_STYLE_USER_INPUT_NONE || uiStyle->mUserInput == NS_STYLE_USER_INPUT_DISABLED)
michael@0:     return nsFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
michael@0: 
michael@0:   EventStates eventStates = mContent->AsElement()->State();
michael@0:   if (eventStates.HasState(NS_EVENT_STATE_DISABLED))
michael@0:     return NS_OK;
michael@0: 
michael@0:   return nsHTMLScrollFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
michael@0: }
michael@0: 
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: nsresult
michael@0: nsListControlFrame::SetInitialChildList(ChildListID    aListID,
michael@0:                                         nsFrameList&   aChildList)
michael@0: {
michael@0:   // First check to see if all the content has been added
michael@0:   mIsAllContentHere = mContent->IsDoneAddingChildren();
michael@0:   if (!mIsAllContentHere) {
michael@0:     mIsAllFramesHere    = false;
michael@0:     mHasBeenInitialized = false;
michael@0:   }
michael@0:   nsresult rv = nsHTMLScrollFrame::SetInitialChildList(aListID, aChildList);
michael@0: 
michael@0:   // If all the content is here now check
michael@0:   // to see if all the frames have been created
michael@0:   /*if (mIsAllContentHere) {
michael@0:     // If all content and frames are here
michael@0:     // the reset/initialize
michael@0:     if (CheckIfAllFramesHere()) {
michael@0:       ResetList(aPresContext);
michael@0:       mHasBeenInitialized = true;
michael@0:     }
michael@0:   }*/
michael@0: 
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: void
michael@0: nsListControlFrame::Init(nsIContent*     aContent,
michael@0:                          nsIFrame*       aParent,
michael@0:                          nsIFrame*       aPrevInFlow)
michael@0: {
michael@0:   nsHTMLScrollFrame::Init(aContent, aParent, aPrevInFlow);
michael@0: 
michael@0:   // we shouldn't have to unregister this listener because when
michael@0:   // our frame goes away all these content node go away as well
michael@0:   // because our frame is the only one who references them.
michael@0:   // we need to hook up our listeners before the editor is initialized
michael@0:   mEventListener = new nsListEventListener(this);
michael@0: 
michael@0:   mContent->AddSystemEventListener(NS_LITERAL_STRING("keydown"),
michael@0:                                    mEventListener, false, false);
michael@0:   mContent->AddSystemEventListener(NS_LITERAL_STRING("keypress"),
michael@0:                                    mEventListener, false, false);
michael@0:   mContent->AddSystemEventListener(NS_LITERAL_STRING("mousedown"),
michael@0:                                    mEventListener, false, false);
michael@0:   mContent->AddSystemEventListener(NS_LITERAL_STRING("mouseup"),
michael@0:                                    mEventListener, false, false);
michael@0:   mContent->AddSystemEventListener(NS_LITERAL_STRING("mousemove"),
michael@0:                                    mEventListener, false, false);
michael@0: 
michael@0:   mStartSelectionIndex = kNothingSelected;
michael@0:   mEndSelectionIndex = kNothingSelected;
michael@0: 
michael@0:   mLastDropdownBackstopColor = PresContext()->DefaultBackgroundColor();
michael@0: 
michael@0:   if (IsInDropDownMode()) {
michael@0:     AddStateBits(NS_FRAME_IN_POPUP);
michael@0:   }
michael@0: }
michael@0: 
michael@0: dom::HTMLOptionsCollection*
michael@0: nsListControlFrame::GetOptions() const
michael@0: {
michael@0:   dom::HTMLSelectElement* select =
michael@0:     dom::HTMLSelectElement::FromContentOrNull(mContent);
michael@0:   NS_ENSURE_TRUE(select, nullptr);
michael@0: 
michael@0:   return select->Options();
michael@0: }
michael@0: 
michael@0: dom::HTMLOptionElement*
michael@0: nsListControlFrame::GetOption(uint32_t aIndex) const
michael@0: {
michael@0:   dom::HTMLSelectElement* select =
michael@0:     dom::HTMLSelectElement::FromContentOrNull(mContent);
michael@0:   NS_ENSURE_TRUE(select, nullptr);
michael@0: 
michael@0:   return select->Item(aIndex);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsListControlFrame::OnOptionSelected(int32_t aIndex, bool aSelected)
michael@0: {
michael@0:   if (aSelected) {
michael@0:     ScrollToIndex(aIndex);
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::OnContentReset()
michael@0: {
michael@0:   ResetList(true);
michael@0: }
michael@0: 
michael@0: void 
michael@0: nsListControlFrame::ResetList(bool aAllowScrolling)
michael@0: {
michael@0:   // if all the frames aren't here 
michael@0:   // don't bother reseting
michael@0:   if (!mIsAllFramesHere) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   if (aAllowScrolling) {
michael@0:     mPostChildrenLoadedReset = true;
michael@0: 
michael@0:     // Scroll to the selected index
michael@0:     int32_t indexToSelect = kNothingSelected;
michael@0: 
michael@0:     nsCOMPtr<nsIDOMHTMLSelectElement> selectElement(do_QueryInterface(mContent));
michael@0:     NS_ASSERTION(selectElement, "No select element!");
michael@0:     if (selectElement) {
michael@0:       selectElement->GetSelectedIndex(&indexToSelect);
michael@0:       nsWeakFrame weakFrame(this);
michael@0:       ScrollToIndex(indexToSelect);
michael@0:       if (!weakFrame.IsAlive()) {
michael@0:         return;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   mStartSelectionIndex = kNothingSelected;
michael@0:   mEndSelectionIndex = kNothingSelected;
michael@0:   InvalidateFocus();
michael@0:   // Combobox will redisplay itself with the OnOptionSelected event
michael@0: } 
michael@0:  
michael@0: void 
michael@0: nsListControlFrame::SetFocus(bool aOn, bool aRepaint)
michael@0: {
michael@0:   InvalidateFocus();
michael@0: 
michael@0:   if (aOn) {
michael@0:     ComboboxFocusSet();
michael@0:     mFocused = this;
michael@0:   } else {
michael@0:     mFocused = nullptr;
michael@0:   }
michael@0: 
michael@0:   InvalidateFocus();
michael@0: }
michael@0: 
michael@0: void nsListControlFrame::ComboboxFocusSet()
michael@0: {
michael@0:   gLastKeyTime = 0;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::SetComboboxFrame(nsIFrame* aComboboxFrame)
michael@0: {
michael@0:   if (nullptr != aComboboxFrame) {
michael@0:     mComboboxFrame = do_QueryFrame(aComboboxFrame);
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::GetOptionText(uint32_t aIndex, nsAString& aStr)
michael@0: {
michael@0:   aStr.Truncate();
michael@0:   if (dom::HTMLOptionElement* optionElement = GetOption(aIndex)) {
michael@0:     optionElement->GetText(aStr);
michael@0:   }
michael@0: }
michael@0: 
michael@0: int32_t
michael@0: nsListControlFrame::GetSelectedIndex()
michael@0: {
michael@0:   dom::HTMLSelectElement* select =
michael@0:     dom::HTMLSelectElement::FromContentOrNull(mContent);
michael@0:   return select->SelectedIndex();
michael@0: }
michael@0: 
michael@0: dom::HTMLOptionElement*
michael@0: nsListControlFrame::GetCurrentOption()
michael@0: {
michael@0:   // The mEndSelectionIndex is what is currently being selected. Use
michael@0:   // the selected index if this is kNothingSelected.
michael@0:   int32_t focusedIndex = (mEndSelectionIndex == kNothingSelected) ?
michael@0:     GetSelectedIndex() : mEndSelectionIndex;
michael@0: 
michael@0:   if (focusedIndex != kNothingSelected) {
michael@0:     return GetOption(SafeCast<uint32_t>(focusedIndex));
michael@0:   }
michael@0: 
michael@0:   // There is no selected item. Return the first non-disabled item.
michael@0:   nsRefPtr<dom::HTMLSelectElement> selectElement =
michael@0:     dom::HTMLSelectElement::FromContent(mContent);
michael@0: 
michael@0:   for (uint32_t i = 0, length = selectElement->Length(); i < length; ++i) {
michael@0:     dom::HTMLOptionElement* node = selectElement->Item(i);
michael@0:     if (!node) {
michael@0:       return nullptr;
michael@0:     }
michael@0: 
michael@0:     if (!selectElement->IsOptionDisabled(node)) {
michael@0:       return node;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: bool 
michael@0: nsListControlFrame::IsInDropDownMode() const
michael@0: {
michael@0:   return (mComboboxFrame != nullptr);
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: nsListControlFrame::GetNumberOfOptions()
michael@0: {
michael@0:   dom::HTMLOptionsCollection* options = GetOptions();
michael@0:   if (!options) {
michael@0:     return 0;
michael@0:   }
michael@0: 
michael@0:   return options->Length();
michael@0: }
michael@0: 
michael@0: //----------------------------------------------------------------------
michael@0: // nsISelectControlFrame
michael@0: //----------------------------------------------------------------------
michael@0: bool nsListControlFrame::CheckIfAllFramesHere()
michael@0: {
michael@0:   // Get the number of optgroups and options
michael@0:   //int32_t numContentItems = 0;
michael@0:   nsCOMPtr<nsIDOMNode> node(do_QueryInterface(mContent));
michael@0:   if (node) {
michael@0:     // XXX Need to find a fail proff way to determine that
michael@0:     // all the frames are there
michael@0:     mIsAllFramesHere = true;//NS_OK == CountAllChild(node, numContentItems);
michael@0:   }
michael@0:   // now make sure we have a frame each piece of content
michael@0: 
michael@0:   return mIsAllFramesHere;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsListControlFrame::DoneAddingChildren(bool aIsDone)
michael@0: {
michael@0:   mIsAllContentHere = aIsDone;
michael@0:   if (mIsAllContentHere) {
michael@0:     // Here we check to see if all the frames have been created 
michael@0:     // for all the content.
michael@0:     // If so, then we can initialize;
michael@0:     if (!mIsAllFramesHere) {
michael@0:       // if all the frames are now present we can initialize
michael@0:       if (CheckIfAllFramesHere()) {
michael@0:         mHasBeenInitialized = true;
michael@0:         ResetList(true);
michael@0:       }
michael@0:     }
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsListControlFrame::AddOption(int32_t aIndex)
michael@0: {
michael@0: #ifdef DO_REFLOW_DEBUG
michael@0:   printf("---- Id: %d nsLCF %p Added Option %d\n", mReflowId, this, aIndex);
michael@0: #endif
michael@0: 
michael@0:   if (!mIsAllContentHere) {
michael@0:     mIsAllContentHere = mContent->IsDoneAddingChildren();
michael@0:     if (!mIsAllContentHere) {
michael@0:       mIsAllFramesHere    = false;
michael@0:       mHasBeenInitialized = false;
michael@0:     } else {
michael@0:       mIsAllFramesHere = (aIndex == static_cast<int32_t>(GetNumberOfOptions()-1));
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Make sure we scroll to the selected option as needed
michael@0:   mNeedToReset = true;
michael@0: 
michael@0:   if (!mHasBeenInitialized) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   mPostChildrenLoadedReset = mIsAllContentHere;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: static int32_t
michael@0: DecrementAndClamp(int32_t aSelectionIndex, int32_t aLength)
michael@0: {
michael@0:   return aLength == 0 ? kNothingSelected : std::max(0, aSelectionIndex - 1);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsListControlFrame::RemoveOption(int32_t aIndex)
michael@0: {
michael@0:   NS_PRECONDITION(aIndex >= 0, "negative <option> index");
michael@0: 
michael@0:   // Need to reset if we're a dropdown
michael@0:   if (IsInDropDownMode()) {
michael@0:     mNeedToReset = true;
michael@0:     mPostChildrenLoadedReset = mIsAllContentHere;
michael@0:   }
michael@0: 
michael@0:   if (mStartSelectionIndex != kNothingSelected) {
michael@0:     NS_ASSERTION(mEndSelectionIndex != kNothingSelected, "");
michael@0:     int32_t numOptions = GetNumberOfOptions();
michael@0:     // NOTE: numOptions is the new number of options whereas aIndex is the
michael@0:     // unadjusted index of the removed option (hence the <= below).
michael@0:     NS_ASSERTION(aIndex <= numOptions, "out-of-bounds <option> index");
michael@0: 
michael@0:     int32_t forward = mEndSelectionIndex - mStartSelectionIndex;
michael@0:     int32_t* low  = forward >= 0 ? &mStartSelectionIndex : &mEndSelectionIndex;
michael@0:     int32_t* high = forward >= 0 ? &mEndSelectionIndex : &mStartSelectionIndex;
michael@0:     if (aIndex < *low)
michael@0:       *low = ::DecrementAndClamp(*low, numOptions);
michael@0:     if (aIndex <= *high)
michael@0:       *high = ::DecrementAndClamp(*high, numOptions);
michael@0:     if (forward == 0)
michael@0:       *low = *high;
michael@0:   }
michael@0:   else
michael@0:     NS_ASSERTION(mEndSelectionIndex == kNothingSelected, "");
michael@0: 
michael@0:   InvalidateFocus();
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: //---------------------------------------------------------
michael@0: // Set the option selected in the DOM.  This method is named
michael@0: // as it is because it indicates that the frame is the source
michael@0: // of this event rather than the receiver.
michael@0: bool
michael@0: nsListControlFrame::SetOptionsSelectedFromFrame(int32_t aStartIndex,
michael@0:                                                 int32_t aEndIndex,
michael@0:                                                 bool aValue,
michael@0:                                                 bool aClearAll)
michael@0: {
michael@0:   nsRefPtr<dom::HTMLSelectElement> selectElement =
michael@0:     dom::HTMLSelectElement::FromContent(mContent);
michael@0: 
michael@0:   uint32_t mask = dom::HTMLSelectElement::NOTIFY;
michael@0:   if (aValue) {
michael@0:     mask |= dom::HTMLSelectElement::IS_SELECTED;
michael@0:   }
michael@0: 
michael@0:   if (aClearAll) {
michael@0:     mask |= dom::HTMLSelectElement::CLEAR_ALL;
michael@0:   }
michael@0: 
michael@0:   return selectElement->SetOptionsSelectedByIndex(aStartIndex, aEndIndex, mask);
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsListControlFrame::ToggleOptionSelectedFromFrame(int32_t aIndex)
michael@0: {
michael@0:   nsRefPtr<dom::HTMLOptionElement> option =
michael@0:     GetOption(static_cast<uint32_t>(aIndex));
michael@0:   NS_ENSURE_TRUE(option, false);
michael@0: 
michael@0:   nsRefPtr<dom::HTMLSelectElement> selectElement =
michael@0:     dom::HTMLSelectElement::FromContent(mContent);
michael@0: 
michael@0:   uint32_t mask = dom::HTMLSelectElement::NOTIFY;
michael@0:   if (!option->Selected()) {
michael@0:     mask |= dom::HTMLSelectElement::IS_SELECTED;
michael@0:   }
michael@0: 
michael@0:   return selectElement->SetOptionsSelectedByIndex(aIndex, aIndex, mask);
michael@0: }
michael@0: 
michael@0: 
michael@0: // Dispatch event and such
michael@0: bool
michael@0: nsListControlFrame::UpdateSelection()
michael@0: {
michael@0:   if (mIsAllFramesHere) {
michael@0:     // if it's a combobox, display the new text
michael@0:     nsWeakFrame weakFrame(this);
michael@0:     if (mComboboxFrame) {
michael@0:       mComboboxFrame->RedisplaySelectedText();
michael@0:     }
michael@0:     // if it's a listbox, fire on change
michael@0:     else if (mIsAllContentHere) {
michael@0:       FireOnChange();
michael@0:     }
michael@0:     return weakFrame.IsAlive();
michael@0:   }
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::ComboboxFinish(int32_t aIndex)
michael@0: {
michael@0:   gLastKeyTime = 0;
michael@0: 
michael@0:   if (mComboboxFrame) {
michael@0:     nsWeakFrame weakFrame(this);
michael@0:     PerformSelection(aIndex, false, false);  // might destroy us
michael@0:     if (!weakFrame.IsAlive() || !mComboboxFrame) {
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     int32_t displayIndex = mComboboxFrame->GetIndexOfDisplayArea();
michael@0:     if (displayIndex != aIndex) {
michael@0:       mComboboxFrame->RedisplaySelectedText(); // might destroy us
michael@0:     }
michael@0: 
michael@0:     if (weakFrame.IsAlive() && mComboboxFrame) {
michael@0:       mComboboxFrame->RollupFromList(); // might destroy us
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: // Send out an onchange notification.
michael@0: void
michael@0: nsListControlFrame::FireOnChange()
michael@0: {
michael@0:   if (mComboboxFrame) {
michael@0:     // Return hit without changing anything
michael@0:     int32_t index = mComboboxFrame->UpdateRecentIndex(NS_SKIP_NOTIFY_INDEX);
michael@0:     if (index == NS_SKIP_NOTIFY_INDEX)
michael@0:       return;
michael@0: 
michael@0:     // See if the selection actually changed
michael@0:     if (index == GetSelectedIndex())
michael@0:       return;
michael@0:   }
michael@0: 
michael@0:   // Dispatch the change event.
michael@0:   nsContentUtils::DispatchTrustedEvent(mContent->OwnerDoc(), mContent,
michael@0:                                        NS_LITERAL_STRING("change"), true,
michael@0:                                        false);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsListControlFrame::OnSetSelectedIndex(int32_t aOldIndex, int32_t aNewIndex)
michael@0: {
michael@0:   if (mComboboxFrame) {
michael@0:     // UpdateRecentIndex with NS_SKIP_NOTIFY_INDEX, so that we won't fire an onchange
michael@0:     // event for this setting of selectedIndex.
michael@0:     mComboboxFrame->UpdateRecentIndex(NS_SKIP_NOTIFY_INDEX);
michael@0:   }
michael@0: 
michael@0:   nsWeakFrame weakFrame(this);
michael@0:   ScrollToIndex(aNewIndex);
michael@0:   if (!weakFrame.IsAlive()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0:   mStartSelectionIndex = aNewIndex;
michael@0:   mEndSelectionIndex = aNewIndex;
michael@0:   InvalidateFocus();
michael@0: 
michael@0: #ifdef ACCESSIBILITY
michael@0:   FireMenuItemActiveEvent();
michael@0: #endif
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: //----------------------------------------------------------------------
michael@0: // End nsISelectControlFrame
michael@0: //----------------------------------------------------------------------
michael@0: 
michael@0: nsresult
michael@0: nsListControlFrame::SetFormProperty(nsIAtom* aName,
michael@0:                                 const nsAString& aValue)
michael@0: {
michael@0:   if (nsGkAtoms::selected == aName) {
michael@0:     return NS_ERROR_INVALID_ARG; // Selected is readonly according to spec.
michael@0:   } else if (nsGkAtoms::selectedindex == aName) {
michael@0:     // You shouldn't be calling me for this!!!
michael@0:     return NS_ERROR_INVALID_ARG;
michael@0:   }
michael@0: 
michael@0:   // We should be told about selectedIndex by the DOM element through
michael@0:   // OnOptionSelected
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::AboutToDropDown()
michael@0: {
michael@0:   NS_ASSERTION(IsInDropDownMode(),
michael@0:     "AboutToDropDown called without being in dropdown mode");
michael@0: 
michael@0:   // Our widget doesn't get invalidated on changes to the rest of the document,
michael@0:   // so compute and store this color at the start of a dropdown so we don't
michael@0:   // get weird painting behaviour.
michael@0:   // We start looking for backgrounds above the combobox frame to avoid
michael@0:   // duplicating the combobox frame's background and compose each background
michael@0:   // color we find underneath until we have an opaque color, or run out of
michael@0:   // backgrounds. We compose with the PresContext default background color,
michael@0:   // which is always opaque, in case we don't end up with an opaque color.
michael@0:   // This gives us a very poor approximation of translucency.
michael@0:   nsIFrame* comboboxFrame = do_QueryFrame(mComboboxFrame);
michael@0:   nsStyleContext* context = comboboxFrame->StyleContext()->GetParent();
michael@0:   mLastDropdownBackstopColor = NS_RGBA(0,0,0,0);
michael@0:   while (NS_GET_A(mLastDropdownBackstopColor) < 255 && context) {
michael@0:     mLastDropdownBackstopColor =
michael@0:       NS_ComposeColors(context->StyleBackground()->mBackgroundColor,
michael@0:                        mLastDropdownBackstopColor);
michael@0:     context = context->GetParent();
michael@0:   }
michael@0:   mLastDropdownBackstopColor =
michael@0:     NS_ComposeColors(PresContext()->DefaultBackgroundColor(),
michael@0:                      mLastDropdownBackstopColor);
michael@0: 
michael@0:   if (mIsAllContentHere && mIsAllFramesHere && mHasBeenInitialized) {
michael@0:     nsWeakFrame weakFrame(this);
michael@0:     ScrollToIndex(GetSelectedIndex());
michael@0:     if (!weakFrame.IsAlive()) {
michael@0:       return;
michael@0:     }
michael@0: #ifdef ACCESSIBILITY
michael@0:     FireMenuItemActiveEvent(); // Inform assistive tech what got focus
michael@0: #endif
michael@0:   }
michael@0:   mItemSelectionStarted = false;
michael@0: }
michael@0: 
michael@0: // We are about to be rolledup from the outside (ComboboxFrame)
michael@0: void
michael@0: nsListControlFrame::AboutToRollup()
michael@0: {
michael@0:   // We've been updating the combobox with the keyboard up until now, but not
michael@0:   // with the mouse.  The problem is, even with mouse selection, we are
michael@0:   // updating the <select>.  So if the mouse goes over an option just before
michael@0:   // he leaves the box and clicks, that's what the <select> will show.
michael@0:   //
michael@0:   // To deal with this we say "whatever is in the combobox is canonical."
michael@0:   // - IF the combobox is different from the current selected index, we
michael@0:   //   reset the index.
michael@0: 
michael@0:   if (IsInDropDownMode()) {
michael@0:     ComboboxFinish(mComboboxFrame->GetIndexOfDisplayArea()); // might destroy us
michael@0:   }
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsListControlFrame::DidReflow(nsPresContext*           aPresContext,
michael@0:                               const nsHTMLReflowState* aReflowState,
michael@0:                               nsDidReflowStatus        aStatus)
michael@0: {
michael@0:   nsresult rv;
michael@0:   bool wasInterrupted = !mHasPendingInterruptAtStartOfReflow &&
michael@0:                           aPresContext->HasPendingInterrupt();
michael@0: 
michael@0:   rv = nsHTMLScrollFrame::DidReflow(aPresContext, aReflowState, aStatus);
michael@0: 
michael@0:   if (mNeedToReset && !wasInterrupted) {
michael@0:     mNeedToReset = false;
michael@0:     // Suppress scrolling to the selected element if we restored
michael@0:     // scroll history state AND the list contents have not changed
michael@0:     // since we loaded all the children AND nothing else forced us
michael@0:     // to scroll by calling ResetList(true). The latter two conditions
michael@0:     // are folded into mPostChildrenLoadedReset.
michael@0:     //
michael@0:     // The idea is that we want scroll history restoration to trump ResetList
michael@0:     // scrolling to the selected element, when the ResetList was probably only
michael@0:     // caused by content loading normally.
michael@0:     ResetList(!DidHistoryRestore() || mPostChildrenLoadedReset);
michael@0:   }
michael@0: 
michael@0:   mHasPendingInterruptAtStartOfReflow = false;
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: nsIAtom*
michael@0: nsListControlFrame::GetType() const
michael@0: {
michael@0:   return nsGkAtoms::listControlFrame; 
michael@0: }
michael@0: 
michael@0: #ifdef DEBUG_FRAME_DUMP
michael@0: nsresult
michael@0: nsListControlFrame::GetFrameName(nsAString& aResult) const
michael@0: {
michael@0:   return MakeFrameName(NS_LITERAL_STRING("ListControl"), aResult);
michael@0: }
michael@0: #endif
michael@0: 
michael@0: nscoord
michael@0: nsListControlFrame::GetHeightOfARow()
michael@0: {
michael@0:   return HeightOfARow();
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsListControlFrame::IsOptionDisabled(int32_t anIndex, bool &aIsDisabled)
michael@0: {
michael@0:   nsRefPtr<dom::HTMLSelectElement> sel =
michael@0:     dom::HTMLSelectElement::FromContent(mContent);
michael@0:   if (sel) {
michael@0:     sel->IsOptionDisabled(anIndex, &aIsDisabled);
michael@0:     return NS_OK;
michael@0:   }
michael@0:   return NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: //----------------------------------------------------------------------
michael@0: // helper
michael@0: //----------------------------------------------------------------------
michael@0: bool
michael@0: nsListControlFrame::IsLeftButton(nsIDOMEvent* aMouseEvent)
michael@0: {
michael@0:   // only allow selection with the left button
michael@0:   nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aMouseEvent);
michael@0:   if (mouseEvent) {
michael@0:     int16_t whichButton;
michael@0:     if (NS_SUCCEEDED(mouseEvent->GetButton(&whichButton))) {
michael@0:       return whichButton != 0?false:true;
michael@0:     }
michael@0:   }
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: nscoord
michael@0: nsListControlFrame::CalcFallbackRowHeight(float aFontSizeInflation)
michael@0: {
michael@0:   nscoord rowHeight = 0;
michael@0: 
michael@0:   nsRefPtr<nsFontMetrics> fontMet;
michael@0:   nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fontMet),
michael@0:                                         aFontSizeInflation);
michael@0:   if (fontMet) {
michael@0:     rowHeight = fontMet->MaxHeight();
michael@0:   }
michael@0: 
michael@0:   return rowHeight;
michael@0: }
michael@0: 
michael@0: nscoord
michael@0: nsListControlFrame::CalcIntrinsicHeight(nscoord aHeightOfARow,
michael@0:                                         int32_t aNumberOfOptions)
michael@0: {
michael@0:   NS_PRECONDITION(!IsInDropDownMode(),
michael@0:                   "Shouldn't be in dropdown mode when we call this");
michael@0: 
michael@0:   dom::HTMLSelectElement* select =
michael@0:     dom::HTMLSelectElement::FromContentOrNull(mContent);
michael@0:   if (select) {
michael@0:     mNumDisplayRows = select->Size();
michael@0:   } else {
michael@0:     mNumDisplayRows = 1;
michael@0:   }
michael@0: 
michael@0:   if (mNumDisplayRows < 1) {
michael@0:     mNumDisplayRows = 4;
michael@0:   }
michael@0: 
michael@0:   return mNumDisplayRows * aHeightOfARow;
michael@0: }
michael@0: 
michael@0: //----------------------------------------------------------------------
michael@0: // nsIDOMMouseListener
michael@0: //----------------------------------------------------------------------
michael@0: nsresult
michael@0: nsListControlFrame::MouseUp(nsIDOMEvent* aMouseEvent)
michael@0: {
michael@0:   NS_ASSERTION(aMouseEvent != nullptr, "aMouseEvent is null.");
michael@0: 
michael@0:   nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aMouseEvent);
michael@0:   NS_ENSURE_TRUE(mouseEvent, NS_ERROR_FAILURE);
michael@0: 
michael@0:   UpdateInListState(aMouseEvent);
michael@0: 
michael@0:   mButtonDown = false;
michael@0: 
michael@0:   EventStates eventStates = mContent->AsElement()->State();
michael@0:   if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // only allow selection with the left button
michael@0:   // if a right button click is on the combobox itself
michael@0:   // or on the select when in listbox mode, then let the click through
michael@0:   if (!IsLeftButton(aMouseEvent)) {
michael@0:     if (IsInDropDownMode()) {
michael@0:       if (!IgnoreMouseEventForSelection(aMouseEvent)) {
michael@0:         aMouseEvent->PreventDefault();
michael@0:         aMouseEvent->StopPropagation();
michael@0:       } else {
michael@0:         CaptureMouseEvents(false);
michael@0:         return NS_OK;
michael@0:       }
michael@0:       CaptureMouseEvents(false);
michael@0:       return NS_ERROR_FAILURE; // means consume event
michael@0:     } else {
michael@0:       CaptureMouseEvents(false);
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   const nsStyleVisibility* vis = StyleVisibility();
michael@0:       
michael@0:   if (!vis->IsVisible()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (IsInDropDownMode()) {
michael@0:     // XXX This is a bit of a hack, but.....
michael@0:     // But the idea here is to make sure you get an "onclick" event when you mouse
michael@0:     // down on the select and the drag over an option and let go
michael@0:     // And then NOT get an "onclick" event when when you click down on the select
michael@0:     // and then up outside of the select
michael@0:     // the EventStateManager tracks the content of the mouse down and the mouse up
michael@0:     // to make sure they are the same, and the onclick is sent in the PostHandleEvent
michael@0:     // depeneding on whether the clickCount is non-zero.
michael@0:     // So we cheat here by either setting or unsetting the clcikCount in the native event
michael@0:     // so the right thing happens for the onclick event
michael@0:     WidgetMouseEvent* mouseEvent =
michael@0:       aMouseEvent->GetInternalNSEvent()->AsMouseEvent();
michael@0: 
michael@0:     int32_t selectedIndex;
michael@0:     if (NS_SUCCEEDED(GetIndexFromDOMEvent(aMouseEvent, selectedIndex))) {
michael@0:       // If it's disabled, disallow the click and leave.
michael@0:       bool isDisabled = false;
michael@0:       IsOptionDisabled(selectedIndex, isDisabled);
michael@0:       if (isDisabled) {
michael@0:         aMouseEvent->PreventDefault();
michael@0:         aMouseEvent->StopPropagation();
michael@0:         CaptureMouseEvents(false);
michael@0:         return NS_ERROR_FAILURE;
michael@0:       }
michael@0: 
michael@0:       if (kNothingSelected != selectedIndex) {
michael@0:         nsWeakFrame weakFrame(this);
michael@0:         ComboboxFinish(selectedIndex);
michael@0:         if (!weakFrame.IsAlive())
michael@0:           return NS_OK;
michael@0:         FireOnChange();
michael@0:       }
michael@0: 
michael@0:       mouseEvent->clickCount = 1;
michael@0:     } else {
michael@0:       // the click was out side of the select or its dropdown
michael@0:       mouseEvent->clickCount = IgnoreMouseEventForSelection(aMouseEvent) ? 1 : 0;
michael@0:     }
michael@0:   } else {
michael@0:     CaptureMouseEvents(false);
michael@0:     // Notify
michael@0:     if (mChangesSinceDragStart) {
michael@0:       // reset this so that future MouseUps without a prior MouseDown
michael@0:       // won't fire onchange
michael@0:       mChangesSinceDragStart = false;
michael@0:       FireOnChange();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::UpdateInListState(nsIDOMEvent* aEvent)
michael@0: {
michael@0:   if (!mComboboxFrame || !mComboboxFrame->IsDroppedDown())
michael@0:     return;
michael@0: 
michael@0:   nsPoint pt = nsLayoutUtils::GetDOMEventCoordinatesRelativeTo(aEvent, this);
michael@0:   nsRect borderInnerEdge = GetScrollPortRect();
michael@0:   if (pt.y >= borderInnerEdge.y && pt.y < borderInnerEdge.YMost()) {
michael@0:     mItemSelectionStarted = true;
michael@0:   }
michael@0: }
michael@0: 
michael@0: bool nsListControlFrame::IgnoreMouseEventForSelection(nsIDOMEvent* aEvent)
michael@0: {
michael@0:   if (!mComboboxFrame)
michael@0:     return false;
michael@0: 
michael@0:   // Our DOM listener does get called when the dropdown is not
michael@0:   // showing, because it listens to events on the SELECT element
michael@0:   if (!mComboboxFrame->IsDroppedDown())
michael@0:     return true;
michael@0: 
michael@0:   return !mItemSelectionStarted;
michael@0: }
michael@0: 
michael@0: #ifdef ACCESSIBILITY
michael@0: void
michael@0: nsListControlFrame::FireMenuItemActiveEvent()
michael@0: {
michael@0:   if (mFocused != this && !IsInDropDownMode()) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIContent> optionContent = GetCurrentOption();
michael@0:   if (!optionContent) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   FireDOMEvent(NS_LITERAL_STRING("DOMMenuItemActive"), optionContent);
michael@0: }
michael@0: #endif
michael@0: 
michael@0: nsresult
michael@0: nsListControlFrame::GetIndexFromDOMEvent(nsIDOMEvent* aMouseEvent, 
michael@0:                                          int32_t&     aCurIndex)
michael@0: {
michael@0:   if (IgnoreMouseEventForSelection(aMouseEvent))
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   if (nsIPresShell::GetCapturingContent() != mContent) {
michael@0:     // If we're not capturing, then ignore movement in the border
michael@0:     nsPoint pt = nsLayoutUtils::GetDOMEventCoordinatesRelativeTo(aMouseEvent, this);
michael@0:     nsRect borderInnerEdge = GetScrollPortRect();
michael@0:     if (!borderInnerEdge.Contains(pt)) {
michael@0:       return NS_ERROR_FAILURE;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<dom::HTMLOptionElement> option;
michael@0:   for (nsCOMPtr<nsIContent> content =
michael@0:          PresContext()->EventStateManager()->GetEventTargetContent(nullptr);
michael@0:        content && !option;
michael@0:        content = content->GetParent()) {
michael@0:     option = dom::HTMLOptionElement::FromContent(content);
michael@0:   }
michael@0: 
michael@0:   if (option) {
michael@0:     aCurIndex = option->Index();
michael@0:     MOZ_ASSERT(aCurIndex >= 0);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   int32_t numOptions = GetNumberOfOptions();
michael@0:   if (numOptions < 1)
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsPoint pt = nsLayoutUtils::GetDOMEventCoordinatesRelativeTo(aMouseEvent, this);
michael@0: 
michael@0:   // If the event coordinate is above the first option frame, then target the
michael@0:   // first option frame
michael@0:   nsRefPtr<dom::HTMLOptionElement> firstOption = GetOption(0);
michael@0:   NS_ASSERTION(firstOption, "Can't find first option that's supposed to be there");
michael@0:   nsIFrame* optionFrame = firstOption->GetPrimaryFrame();
michael@0:   if (optionFrame) {
michael@0:     nsPoint ptInOptionFrame = pt - optionFrame->GetOffsetTo(this);
michael@0:     if (ptInOptionFrame.y < 0 && ptInOptionFrame.x >= 0 &&
michael@0:         ptInOptionFrame.x < optionFrame->GetSize().width) {
michael@0:       aCurIndex = 0;
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<dom::HTMLOptionElement> lastOption = GetOption(numOptions - 1);
michael@0:   // If the event coordinate is below the last option frame, then target the
michael@0:   // last option frame
michael@0:   NS_ASSERTION(lastOption, "Can't find last option that's supposed to be there");
michael@0:   optionFrame = lastOption->GetPrimaryFrame();
michael@0:   if (optionFrame) {
michael@0:     nsPoint ptInOptionFrame = pt - optionFrame->GetOffsetTo(this);
michael@0:     if (ptInOptionFrame.y >= optionFrame->GetSize().height && ptInOptionFrame.x >= 0 &&
michael@0:         ptInOptionFrame.x < optionFrame->GetSize().width) {
michael@0:       aCurIndex = numOptions - 1;
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsListControlFrame::MouseDown(nsIDOMEvent* aMouseEvent)
michael@0: {
michael@0:   NS_ASSERTION(aMouseEvent != nullptr, "aMouseEvent is null.");
michael@0: 
michael@0:   nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aMouseEvent);
michael@0:   NS_ENSURE_TRUE(mouseEvent, NS_ERROR_FAILURE);
michael@0: 
michael@0:   UpdateInListState(aMouseEvent);
michael@0: 
michael@0:   EventStates eventStates = mContent->AsElement()->State();
michael@0:   if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // only allow selection with the left button
michael@0:   // if a right button click is on the combobox itself
michael@0:   // or on the select when in listbox mode, then let the click through
michael@0:   if (!IsLeftButton(aMouseEvent)) {
michael@0:     if (IsInDropDownMode()) {
michael@0:       if (!IgnoreMouseEventForSelection(aMouseEvent)) {
michael@0:         aMouseEvent->PreventDefault();
michael@0:         aMouseEvent->StopPropagation();
michael@0:       } else {
michael@0:         return NS_OK;
michael@0:       }
michael@0:       return NS_ERROR_FAILURE; // means consume event
michael@0:     } else {
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   int32_t selectedIndex;
michael@0:   if (NS_SUCCEEDED(GetIndexFromDOMEvent(aMouseEvent, selectedIndex))) {
michael@0:     // Handle Like List
michael@0:     mButtonDown = true;
michael@0:     CaptureMouseEvents(true);
michael@0:     nsWeakFrame weakFrame(this);
michael@0:     bool change =
michael@0:       HandleListSelection(aMouseEvent, selectedIndex); // might destroy us
michael@0:     if (!weakFrame.IsAlive()) {
michael@0:       return NS_OK;
michael@0:     }
michael@0:     mChangesSinceDragStart = change;
michael@0:   } else {
michael@0:     // NOTE: the combo box is responsible for dropping it down
michael@0:     if (mComboboxFrame) {
michael@0:       if (XRE_GetProcessType() == GeckoProcessType_Content && BrowserTabsRemote()) {
michael@0:         nsContentUtils::DispatchChromeEvent(mContent->OwnerDoc(), mContent,
michael@0:                                             NS_LITERAL_STRING("mozshowdropdown"), true,
michael@0:                                             false);
michael@0:         return NS_OK;
michael@0:       }
michael@0: 
michael@0:       if (!IgnoreMouseEventForSelection(aMouseEvent)) {
michael@0:         return NS_OK;
michael@0:       }
michael@0: 
michael@0:       if (!nsComboboxControlFrame::ToolkitHasNativePopup())
michael@0:       {
michael@0:         bool isDroppedDown = mComboboxFrame->IsDroppedDown();
michael@0:         nsIFrame* comboFrame = do_QueryFrame(mComboboxFrame);
michael@0:         nsWeakFrame weakFrame(comboFrame);
michael@0:         mComboboxFrame->ShowDropDown(!isDroppedDown);
michael@0:         if (!weakFrame.IsAlive())
michael@0:           return NS_OK;
michael@0:         if (isDroppedDown) {
michael@0:           CaptureMouseEvents(false);
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: //----------------------------------------------------------------------
michael@0: // nsIDOMMouseMotionListener
michael@0: //----------------------------------------------------------------------
michael@0: nsresult
michael@0: nsListControlFrame::MouseMove(nsIDOMEvent* aMouseEvent)
michael@0: {
michael@0:   NS_ASSERTION(aMouseEvent, "aMouseEvent is null.");
michael@0:   nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aMouseEvent);
michael@0:   NS_ENSURE_TRUE(mouseEvent, NS_ERROR_FAILURE);
michael@0: 
michael@0:   UpdateInListState(aMouseEvent);
michael@0: 
michael@0:   if (IsInDropDownMode()) { 
michael@0:     if (mComboboxFrame->IsDroppedDown()) {
michael@0:       int32_t selectedIndex;
michael@0:       if (NS_SUCCEEDED(GetIndexFromDOMEvent(aMouseEvent, selectedIndex))) {
michael@0:         PerformSelection(selectedIndex, false, false); // might destroy us
michael@0:       }
michael@0:     }
michael@0:   } else {// XXX - temporary until we get drag events
michael@0:     if (mButtonDown) {
michael@0:       return DragMove(aMouseEvent); // might destroy us
michael@0:     }
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsListControlFrame::DragMove(nsIDOMEvent* aMouseEvent)
michael@0: {
michael@0:   NS_ASSERTION(aMouseEvent, "aMouseEvent is null.");
michael@0: 
michael@0:   UpdateInListState(aMouseEvent);
michael@0: 
michael@0:   if (!IsInDropDownMode()) { 
michael@0:     int32_t selectedIndex;
michael@0:     if (NS_SUCCEEDED(GetIndexFromDOMEvent(aMouseEvent, selectedIndex))) {
michael@0:       // Don't waste cycles if we already dragged over this item
michael@0:       if (selectedIndex == mEndSelectionIndex) {
michael@0:         return NS_OK;
michael@0:       }
michael@0:       nsCOMPtr<nsIDOMMouseEvent> mouseEvent = do_QueryInterface(aMouseEvent);
michael@0:       NS_ASSERTION(mouseEvent, "aMouseEvent is not an nsIDOMMouseEvent!");
michael@0:       bool isControl;
michael@0: #ifdef XP_MACOSX
michael@0:       mouseEvent->GetMetaKey(&isControl);
michael@0: #else
michael@0:       mouseEvent->GetCtrlKey(&isControl);
michael@0: #endif
michael@0:       nsWeakFrame weakFrame(this);
michael@0:       // Turn SHIFT on when you are dragging, unless control is on.
michael@0:       bool wasChanged = PerformSelection(selectedIndex,
michael@0:                                            !isControl, isControl);
michael@0:       if (!weakFrame.IsAlive()) {
michael@0:         return NS_OK;
michael@0:       }
michael@0:       mChangesSinceDragStart = mChangesSinceDragStart || wasChanged;
michael@0:     }
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: //----------------------------------------------------------------------
michael@0: // Scroll helpers.
michael@0: //----------------------------------------------------------------------
michael@0: void
michael@0: nsListControlFrame::ScrollToIndex(int32_t aIndex)
michael@0: {
michael@0:   if (aIndex < 0) {
michael@0:     // XXX shouldn't we just do nothing if we're asked to scroll to
michael@0:     // kNothingSelected?
michael@0:     ScrollTo(nsPoint(0, 0), nsIScrollableFrame::INSTANT);
michael@0:   } else {
michael@0:     nsRefPtr<dom::HTMLOptionElement> option =
michael@0:       GetOption(SafeCast<uint32_t>(aIndex));
michael@0:     if (option) {
michael@0:       ScrollToFrame(*option);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::ScrollToFrame(dom::HTMLOptionElement& aOptElement)
michael@0: {
michael@0:   // otherwise we find the content's frame and scroll to it
michael@0:   nsIFrame* childFrame = aOptElement.GetPrimaryFrame();
michael@0:   if (childFrame) {
michael@0:     PresContext()->PresShell()->
michael@0:       ScrollFrameRectIntoView(childFrame,
michael@0:                               nsRect(nsPoint(0, 0), childFrame->GetSize()),
michael@0:                               nsIPresShell::ScrollAxis(), nsIPresShell::ScrollAxis(),
michael@0:                               nsIPresShell::SCROLL_OVERFLOW_HIDDEN |
michael@0:                               nsIPresShell::SCROLL_FIRST_ANCESTOR_ONLY);
michael@0:   }
michael@0: }
michael@0: 
michael@0: //---------------------------------------------------------------------
michael@0: // Ok, the entire idea of this routine is to move to the next item that 
michael@0: // is suppose to be selected. If the item is disabled then we search in 
michael@0: // the same direction looking for the next item to select. If we run off 
michael@0: // the end of the list then we start at the end of the list and search 
michael@0: // backwards until we get back to the original item or an enabled option
michael@0: // 
michael@0: // aStartIndex - the index to start searching from
michael@0: // aNewIndex - will get set to the new index if it finds one
michael@0: // aNumOptions - the total number of options in the list
michael@0: // aDoAdjustInc - the initial increment 1-n
michael@0: // aDoAdjustIncNext - the increment used to search for the next enabled option
michael@0: //
michael@0: // the aDoAdjustInc could be a "1" for a single item or
michael@0: // any number greater representing a page of items
michael@0: //
michael@0: void
michael@0: nsListControlFrame::AdjustIndexForDisabledOpt(int32_t aStartIndex,
michael@0:                                               int32_t &aNewIndex,
michael@0:                                               int32_t aNumOptions,
michael@0:                                               int32_t aDoAdjustInc,
michael@0:                                               int32_t aDoAdjustIncNext)
michael@0: {
michael@0:   // Cannot select anything if there is nothing to select
michael@0:   if (aNumOptions == 0) {
michael@0:     aNewIndex = kNothingSelected;
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   // means we reached the end of the list and now we are searching backwards
michael@0:   bool doingReverse = false;
michael@0:   // lowest index in the search range
michael@0:   int32_t bottom      = 0;
michael@0:   // highest index in the search range
michael@0:   int32_t top         = aNumOptions;
michael@0: 
michael@0:   // Start off keyboard options at selectedIndex if nothing else is defaulted to
michael@0:   //
michael@0:   // XXX Perhaps this should happen for mouse too, to start off shift click
michael@0:   // automatically in multiple ... to do this, we'd need to override
michael@0:   // OnOptionSelected and set mStartSelectedIndex if nothing is selected.  Not
michael@0:   // sure of the effects, though, so I'm not doing it just yet.
michael@0:   int32_t startIndex = aStartIndex;
michael@0:   if (startIndex < bottom) {
michael@0:     startIndex = GetSelectedIndex();
michael@0:   }
michael@0:   int32_t newIndex    = startIndex + aDoAdjustInc;
michael@0: 
michael@0:   // make sure we start off in the range
michael@0:   if (newIndex < bottom) {
michael@0:     newIndex = 0;
michael@0:   } else if (newIndex >= top) {
michael@0:     newIndex = aNumOptions-1;
michael@0:   }
michael@0: 
michael@0:   while (1) {
michael@0:     // if the newIndex isn't disabled, we are golden, bail out
michael@0:     bool isDisabled = true;
michael@0:     if (NS_SUCCEEDED(IsOptionDisabled(newIndex, isDisabled)) && !isDisabled) {
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     // it WAS disabled, so sart looking ahead for the next enabled option
michael@0:     newIndex += aDoAdjustIncNext;
michael@0: 
michael@0:     // well, if we reach end reverse the search
michael@0:     if (newIndex < bottom) {
michael@0:       if (doingReverse) {
michael@0:         return; // if we are in reverse mode and reach the end bail out
michael@0:       } else {
michael@0:         // reset the newIndex to the end of the list we hit
michael@0:         // reverse the incrementer
michael@0:         // set the other end of the list to our original starting index
michael@0:         newIndex         = bottom;
michael@0:         aDoAdjustIncNext = 1;
michael@0:         doingReverse     = true;
michael@0:         top              = startIndex;
michael@0:       }
michael@0:     } else  if (newIndex >= top) {
michael@0:       if (doingReverse) {
michael@0:         return;        // if we are in reverse mode and reach the end bail out
michael@0:       } else {
michael@0:         // reset the newIndex to the end of the list we hit
michael@0:         // reverse the incrementer
michael@0:         // set the other end of the list to our original starting index
michael@0:         newIndex = top - 1;
michael@0:         aDoAdjustIncNext = -1;
michael@0:         doingReverse     = true;
michael@0:         bottom           = startIndex;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Looks like we found one
michael@0:   aNewIndex     = newIndex;
michael@0: }
michael@0: 
michael@0: nsAString& 
michael@0: nsListControlFrame::GetIncrementalString()
michael@0: { 
michael@0:   if (sIncrementalString == nullptr)
michael@0:     sIncrementalString = new nsString();
michael@0: 
michael@0:   return *sIncrementalString;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::Shutdown()
michael@0: {
michael@0:   delete sIncrementalString;
michael@0:   sIncrementalString = nullptr;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::DropDownToggleKey(nsIDOMEvent* aKeyEvent)
michael@0: {
michael@0:   // Cocoa widgets do native popups, so don't try to show
michael@0:   // dropdowns there.
michael@0:   if (IsInDropDownMode() && !nsComboboxControlFrame::ToolkitHasNativePopup()) {
michael@0:     aKeyEvent->PreventDefault();
michael@0:     if (!mComboboxFrame->IsDroppedDown()) {
michael@0:       mComboboxFrame->ShowDropDown(true);
michael@0:     } else {
michael@0:       nsWeakFrame weakFrame(this);
michael@0:       // mEndSelectionIndex is the last item that got selected.
michael@0:       ComboboxFinish(mEndSelectionIndex);
michael@0:       if (weakFrame.IsAlive()) {
michael@0:         FireOnChange();
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsListControlFrame::KeyDown(nsIDOMEvent* aKeyEvent)
michael@0: {
michael@0:   MOZ_ASSERT(aKeyEvent, "aKeyEvent is null.");
michael@0: 
michael@0:   EventStates eventStates = mContent->AsElement()->State();
michael@0:   if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   AutoIncrementalSearchResetter incrementalSearchResetter;
michael@0: 
michael@0:   // Don't check defaultPrevented value because other browsers don't prevent
michael@0:   // the key navigation of list control even if preventDefault() is called.
michael@0: 
michael@0:   const WidgetKeyboardEvent* keyEvent =
michael@0:     aKeyEvent->GetInternalNSEvent()->AsKeyboardEvent();
michael@0:   MOZ_ASSERT(keyEvent,
michael@0:     "DOM event must have WidgetKeyboardEvent for its internal event");
michael@0: 
michael@0:   if (keyEvent->IsAlt()) {
michael@0:     if (keyEvent->keyCode == NS_VK_UP || keyEvent->keyCode == NS_VK_DOWN) {
michael@0:       DropDownToggleKey(aKeyEvent);
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // now make sure there are options or we are wasting our time
michael@0:   nsRefPtr<dom::HTMLOptionsCollection> options = GetOptions();
michael@0:   NS_ENSURE_TRUE(options, NS_ERROR_FAILURE);
michael@0: 
michael@0:   uint32_t numOptions = options->Length();
michael@0: 
michael@0:   // this is the new index to set
michael@0:   int32_t newIndex = kNothingSelected;
michael@0: 
michael@0:   bool isControlOrMeta = (keyEvent->IsControl() || keyEvent->IsMeta());
michael@0:   // Don't try to handle multiple-select pgUp/pgDown in single-select lists.
michael@0:   if (isControlOrMeta && !GetMultiple() &&
michael@0:       (keyEvent->keyCode == NS_VK_PAGE_UP ||
michael@0:        keyEvent->keyCode == NS_VK_PAGE_DOWN)) {
michael@0:     return NS_OK;
michael@0:   }
michael@0:   if (isControlOrMeta && (keyEvent->keyCode == NS_VK_UP ||
michael@0:                           keyEvent->keyCode == NS_VK_LEFT ||
michael@0:                           keyEvent->keyCode == NS_VK_DOWN ||
michael@0:                           keyEvent->keyCode == NS_VK_RIGHT ||
michael@0:                           keyEvent->keyCode == NS_VK_HOME ||
michael@0:                           keyEvent->keyCode == NS_VK_END)) {
michael@0:     // Don't go into multiple-select mode unless this list can handle it.
michael@0:     isControlOrMeta = mControlSelectMode = GetMultiple();
michael@0:   } else if (keyEvent->keyCode != NS_VK_SPACE) {
michael@0:     mControlSelectMode = false;
michael@0:   }
michael@0: 
michael@0:   switch (keyEvent->keyCode) {
michael@0:     case NS_VK_UP:
michael@0:     case NS_VK_LEFT:
michael@0:       AdjustIndexForDisabledOpt(mEndSelectionIndex, newIndex,
michael@0:                                 static_cast<int32_t>(numOptions),
michael@0:                                 -1, -1);
michael@0:       break;
michael@0:     case NS_VK_DOWN:
michael@0:     case NS_VK_RIGHT:
michael@0:       AdjustIndexForDisabledOpt(mEndSelectionIndex, newIndex,
michael@0:                                 static_cast<int32_t>(numOptions),
michael@0:                                 1, 1);
michael@0:       break;
michael@0:     case NS_VK_RETURN:
michael@0:       if (IsInDropDownMode()) {
michael@0:         if (mComboboxFrame->IsDroppedDown()) {
michael@0:           // If the select element is a dropdown style, Enter key should be
michael@0:           // consumed while the dropdown is open for security.
michael@0:           aKeyEvent->PreventDefault();
michael@0: 
michael@0:           nsWeakFrame weakFrame(this);
michael@0:           ComboboxFinish(mEndSelectionIndex);
michael@0:           if (!weakFrame.IsAlive()) {
michael@0:             return NS_OK;
michael@0:           }
michael@0:         }
michael@0:         // XXX This is strange. On other browsers, "change" event is fired
michael@0:         //     immediately after the selected item is changed rather than
michael@0:         //     Enter key is pressed.
michael@0:         FireOnChange();
michael@0:         return NS_OK;
michael@0:       }
michael@0: 
michael@0:       // If this is single select listbox, Enter key doesn't cause anything.
michael@0:       if (!GetMultiple()) {
michael@0:         return NS_OK;
michael@0:       }
michael@0: 
michael@0:       newIndex = mEndSelectionIndex;
michael@0:       break;
michael@0:     case NS_VK_ESCAPE: {
michael@0:       // If the select element is a listbox style, Escape key causes nothing.
michael@0:       if (!IsInDropDownMode()) {
michael@0:         return NS_OK;
michael@0:       }
michael@0: 
michael@0:       AboutToRollup();
michael@0:       // If the select element is a dropdown style, Enter key should be
michael@0:       // consumed everytime since Escape key may be pressed accidentally after
michael@0:       // the dropdown is closed by Escepe key.
michael@0:       aKeyEvent->PreventDefault();
michael@0:       return NS_OK;
michael@0:     }
michael@0:     case NS_VK_PAGE_UP: {
michael@0:       int32_t itemsPerPage =
michael@0:         std::max(1, static_cast<int32_t>(mNumDisplayRows - 1));
michael@0:       AdjustIndexForDisabledOpt(mEndSelectionIndex, newIndex,
michael@0:                                 static_cast<int32_t>(numOptions),
michael@0:                                 -itemsPerPage, -1);
michael@0:       break;
michael@0:     }
michael@0:     case NS_VK_PAGE_DOWN: {
michael@0:       int32_t itemsPerPage =
michael@0:         std::max(1, static_cast<int32_t>(mNumDisplayRows - 1));
michael@0:       AdjustIndexForDisabledOpt(mEndSelectionIndex, newIndex,
michael@0:                                 static_cast<int32_t>(numOptions),
michael@0:                                 itemsPerPage, 1);
michael@0:       break;
michael@0:     }
michael@0:     case NS_VK_HOME:
michael@0:       AdjustIndexForDisabledOpt(0, newIndex,
michael@0:                                 static_cast<int32_t>(numOptions),
michael@0:                                 0, 1);
michael@0:       break;
michael@0:     case NS_VK_END:
michael@0:       AdjustIndexForDisabledOpt(static_cast<int32_t>(numOptions) - 1, newIndex,
michael@0:                                 static_cast<int32_t>(numOptions),
michael@0:                                 0, -1);
michael@0:       break;
michael@0: 
michael@0: #if defined(XP_WIN)
michael@0:     case NS_VK_F4:
michael@0:       if (!isControlOrMeta) {
michael@0:         DropDownToggleKey(aKeyEvent);
michael@0:       }
michael@0:       return NS_OK;
michael@0: #endif
michael@0: 
michael@0:     default: // printable key will be handled by keypress event.
michael@0:       incrementalSearchResetter.Cancel();
michael@0:       return NS_OK;
michael@0:   }
michael@0: 
michael@0:   aKeyEvent->PreventDefault();
michael@0: 
michael@0:   // Actually process the new index and let the selection code
michael@0:   // do the scrolling for us
michael@0:   PostHandleKeyEvent(newIndex, 0, keyEvent->IsShift(), isControlOrMeta);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsListControlFrame::KeyPress(nsIDOMEvent* aKeyEvent)
michael@0: {
michael@0:   MOZ_ASSERT(aKeyEvent, "aKeyEvent is null.");
michael@0: 
michael@0:   EventStates eventStates = mContent->AsElement()->State();
michael@0:   if (eventStates.HasState(NS_EVENT_STATE_DISABLED)) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   AutoIncrementalSearchResetter incrementalSearchResetter;
michael@0: 
michael@0:   const WidgetKeyboardEvent* keyEvent =
michael@0:     aKeyEvent->GetInternalNSEvent()->AsKeyboardEvent();
michael@0:   MOZ_ASSERT(keyEvent,
michael@0:     "DOM event must have WidgetKeyboardEvent for its internal event");
michael@0: 
michael@0:   // Select option with this as the first character
michael@0:   // XXX Not I18N compliant
michael@0: 
michael@0:   // Don't do incremental search if the key event has already consumed.
michael@0:   if (keyEvent->mFlags.mDefaultPrevented) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (keyEvent->IsAlt()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // With some keyboard layout, space key causes non-ASCII space.
michael@0:   // So, the check in keydown event handler isn't enough, we need to check it
michael@0:   // again with keypress event.
michael@0:   if (keyEvent->charCode != ' ') {
michael@0:     mControlSelectMode = false;
michael@0:   }
michael@0: 
michael@0:   bool isControlOrMeta = (keyEvent->IsControl() || keyEvent->IsMeta());
michael@0:   if (isControlOrMeta && keyEvent->charCode != ' ') {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // NOTE: If keyCode of keypress event is not 0, charCode is always 0.
michael@0:   //       Therefore, all non-printable keys are not handled after this block.
michael@0:   if (!keyEvent->charCode) {
michael@0:     // Backspace key will delete the last char in the string.  Otherwise,
michael@0:     // non-printable keypress should reset incremental search.
michael@0:     if (keyEvent->keyCode == NS_VK_BACK) {
michael@0:       incrementalSearchResetter.Cancel();
michael@0:       if (!GetIncrementalString().IsEmpty()) {
michael@0:         GetIncrementalString().Truncate(GetIncrementalString().Length() - 1);
michael@0:       }
michael@0:       aKeyEvent->PreventDefault();
michael@0:     } else {
michael@0:       // XXX When a select element has focus, even if the key causes nothing,
michael@0:       //     it might be better to call preventDefault() here because nobody
michael@0:       //     should expect one of other elements including chrome handles the
michael@0:       //     key event.
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   incrementalSearchResetter.Cancel();
michael@0: 
michael@0:   // We ate the key if we got this far.
michael@0:   aKeyEvent->PreventDefault();
michael@0: 
michael@0:   // XXX Why don't we check/modify timestamp first?
michael@0: 
michael@0:   // Incremental Search: if time elapsed is below
michael@0:   // INCREMENTAL_SEARCH_KEYPRESS_TIME, append this keystroke to the search
michael@0:   // string we will use to find options and start searching at the current
michael@0:   // keystroke.  Otherwise, Truncate the string if it's been a long time
michael@0:   // since our last keypress.
michael@0:   if (keyEvent->time - gLastKeyTime > INCREMENTAL_SEARCH_KEYPRESS_TIME) {
michael@0:     // If this is ' ' and we are at the beginning of the string, treat it as
michael@0:     // "select this option" (bug 191543)
michael@0:     if (keyEvent->charCode == ' ') {
michael@0:       // Actually process the new index and let the selection code
michael@0:       // do the scrolling for us
michael@0:       PostHandleKeyEvent(mEndSelectionIndex, keyEvent->charCode,
michael@0:                          keyEvent->IsShift(), isControlOrMeta);
michael@0: 
michael@0:       return NS_OK;
michael@0:     }
michael@0: 
michael@0:     GetIncrementalString().Truncate();
michael@0:   }
michael@0: 
michael@0:   gLastKeyTime = keyEvent->time;
michael@0: 
michael@0:   // Append this keystroke to the search string. 
michael@0:   char16_t uniChar = ToLowerCase(static_cast<char16_t>(keyEvent->charCode));
michael@0:   GetIncrementalString().Append(uniChar);
michael@0: 
michael@0:   // See bug 188199, if all letters in incremental string are same, just try to
michael@0:   // match the first one
michael@0:   nsAutoString incrementalString(GetIncrementalString());
michael@0:   uint32_t charIndex = 1, stringLength = incrementalString.Length();
michael@0:   while (charIndex < stringLength &&
michael@0:          incrementalString[charIndex] == incrementalString[charIndex - 1]) {
michael@0:     charIndex++;
michael@0:   }
michael@0:   if (charIndex == stringLength) {
michael@0:     incrementalString.Truncate(1);
michael@0:     stringLength = 1;
michael@0:   }
michael@0: 
michael@0:   // Determine where we're going to start reading the string
michael@0:   // If we have multiple characters to look for, we start looking *at* the
michael@0:   // current option.  If we have only one character to look for, we start
michael@0:   // looking *after* the current option.	
michael@0:   // Exception: if there is no option selected to start at, we always start
michael@0:   // *at* 0.
michael@0:   int32_t startIndex = GetSelectedIndex();
michael@0:   if (startIndex == kNothingSelected) {
michael@0:     startIndex = 0;
michael@0:   } else if (stringLength == 1) {
michael@0:     startIndex++;
michael@0:   }
michael@0: 
michael@0:   // now make sure there are options or we are wasting our time
michael@0:   nsRefPtr<dom::HTMLOptionsCollection> options = GetOptions();
michael@0:   NS_ENSURE_TRUE(options, NS_ERROR_FAILURE);
michael@0: 
michael@0:   uint32_t numOptions = options->Length();
michael@0: 
michael@0:   nsWeakFrame weakFrame(this);
michael@0:   for (uint32_t i = 0; i < numOptions; ++i) {
michael@0:     uint32_t index = (i + startIndex) % numOptions;
michael@0:     nsRefPtr<dom::HTMLOptionElement> optionElement =
michael@0:       options->ItemAsOption(index);
michael@0:     if (!optionElement || !optionElement->GetPrimaryFrame()) {
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     nsAutoString text;
michael@0:     if (NS_FAILED(optionElement->GetText(text)) ||
michael@0:         !StringBeginsWith(
michael@0:            nsContentUtils::TrimWhitespace<
michael@0:              nsContentUtils::IsHTMLWhitespaceOrNBSP>(text, false),
michael@0:            incrementalString, nsCaseInsensitiveStringComparator())) {
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     bool wasChanged = PerformSelection(index, keyEvent->IsShift(), isControlOrMeta);
michael@0:     if (!weakFrame.IsAlive()) {
michael@0:       return NS_OK;
michael@0:     }
michael@0:     if (!wasChanged) {
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     // If UpdateSelection() returns false, that means the frame is no longer
michael@0:     // alive. We should stop doing anything.
michael@0:     if (!UpdateSelection()) {
michael@0:       return NS_OK;
michael@0:     }
michael@0:     break;
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsListControlFrame::PostHandleKeyEvent(int32_t aNewIndex,
michael@0:                                        uint32_t aCharCode,
michael@0:                                        bool aIsShift,
michael@0:                                        bool aIsControlOrMeta)
michael@0: {
michael@0:   if (aNewIndex == kNothingSelected) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   // If you hold control, but not shift, no key will actually do anything
michael@0:   // except space.
michael@0:   nsWeakFrame weakFrame(this);
michael@0:   bool wasChanged = false;
michael@0:   if (aIsControlOrMeta && !aIsShift && aCharCode != ' ') {
michael@0:     mStartSelectionIndex = aNewIndex;
michael@0:     mEndSelectionIndex = aNewIndex;
michael@0:     InvalidateFocus();
michael@0:     ScrollToIndex(aNewIndex);
michael@0:     if (!weakFrame.IsAlive()) {
michael@0:       return;
michael@0:     }
michael@0: 
michael@0: #ifdef ACCESSIBILITY
michael@0:     FireMenuItemActiveEvent();
michael@0: #endif
michael@0:   } else if (mControlSelectMode && aCharCode == ' ') {
michael@0:     wasChanged = SingleSelection(aNewIndex, true);
michael@0:   } else {
michael@0:     wasChanged = PerformSelection(aNewIndex, aIsShift, aIsControlOrMeta);
michael@0:   }
michael@0:   if (wasChanged && weakFrame.IsAlive()) {
michael@0:     // dispatch event, update combobox, etc.
michael@0:     UpdateSelection();
michael@0:   }
michael@0: }
michael@0: 
michael@0: 
michael@0: /******************************************************************************
michael@0:  * nsListEventListener
michael@0:  *****************************************************************************/
michael@0: 
michael@0: NS_IMPL_ISUPPORTS(nsListEventListener, nsIDOMEventListener)
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsListEventListener::HandleEvent(nsIDOMEvent* aEvent)
michael@0: {
michael@0:   if (!mFrame)
michael@0:     return NS_OK;
michael@0: 
michael@0:   nsAutoString eventType;
michael@0:   aEvent->GetType(eventType);
michael@0:   if (eventType.EqualsLiteral("keydown"))
michael@0:     return mFrame->nsListControlFrame::KeyDown(aEvent);
michael@0:   if (eventType.EqualsLiteral("keypress"))
michael@0:     return mFrame->nsListControlFrame::KeyPress(aEvent);
michael@0:   if (eventType.EqualsLiteral("mousedown"))
michael@0:     return mFrame->nsListControlFrame::MouseDown(aEvent);
michael@0:   if (eventType.EqualsLiteral("mouseup"))
michael@0:     return mFrame->nsListControlFrame::MouseUp(aEvent);
michael@0:   if (eventType.EqualsLiteral("mousemove"))
michael@0:     return mFrame->nsListControlFrame::MouseMove(aEvent);
michael@0: 
michael@0:   NS_ABORT();
michael@0:   return NS_OK;
michael@0: }