author Brian Hackett <>
Wed, 14 Nov 2018 16:09:58 -1000
changeset 446931 1c7fc8389e012c987347efefca6b35f3948b742a
parent 422747 2792dcc6b2eb6e5a7dd6dcfeff07490a2ec187a6
child 448947 6f3709b3878117466168c40affa7bca0b60cf75b
permissions -rw-r--r--
Bug 1507359 Part 2 - Bindings and internal changes to allow ReplayDebugger to control child pausing/resuming, r=mccr8.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at */

#ifndef ScrollbarActivity_h___
#define ScrollbarActivity_h___

#include "mozilla/Attributes.h"
#include "nsCOMPtr.h"
#include "nsIDOMEventListener.h"
#include "mozilla/TimeStamp.h"
#include "nsRefreshDriver.h"

class nsIContent;
class nsIScrollbarMediator;
class nsITimer;

namespace mozilla {

namespace dom {
class Element;
class EventTarget;
} // namespace dom

namespace layout {

 * ScrollbarActivity
 * This class manages scrollbar behavior that imitates the native Mac OS X
 * Lion overlay scrollbar behavior: Scrollbars are only shown while "scrollbar
 * activity" occurs, and they're hidden with a fade animation after a short
 * delay.
 * Scrollbar activity has these states:
 *  - inactive:
 *      Scrollbars are hidden.
 *  - ongoing activity:
 *      Scrollbars are visible and being operated on in some way, for example
 *      because they're hovered or pressed.
 *  - active, but waiting for fade out
 *      Scrollbars are still completely visible but are about to fade away.
 *  - fading out
 *      Scrollbars are subject to a fade-out animation.
 * Initial scrollbar activity needs to be reported by the scrollbar holder that
 * owns the ScrollbarActivity instance. This needs to happen via a call to
 * ActivityOccurred(), for example when the current scroll position or the size
 * of the scroll area changes.
 * As soon as scrollbars are visible, the ScrollbarActivity class manages the
 * rest of the activity behavior: It ensures that mouse motions inside the
 * scroll area keep the scrollbars visible, and that scrollbars don't fade away
 * while they're being hovered / dragged. It also sets a sticky hover attribute
 * on the most recently hovered scrollbar.
 * ScrollbarActivity falls into hibernation after the scrollbars have faded
 * out. It only starts acting after the next call to ActivityOccurred() /
 * ActivityStarted().

class ScrollbarActivity final : public nsIDOMEventListener,
                                public nsARefreshObserver
  explicit ScrollbarActivity(nsIScrollbarMediator* aScrollableFrame)
   : mScrollableFrame(aScrollableFrame)
   , mNestedActivityCounter(0)
   , mIsActive(false)
   , mIsFading(false)
   , mListeningForScrollbarEvents(false)
   , mListeningForScrollAreaEvents(false)
   , mHScrollbarHovered(false)
   , mVScrollbarHovered(false)
   , mDisplayOnMouseMove(false)
   , mScrollbarFadeBeginDelay(0)
   , mScrollbarFadeDuration(0)


  void Destroy();

  void ActivityOccurred();
  void ActivityStarted();
  void ActivityStopped();

  virtual void WillRefresh(TimeStamp aTime) override;

  static void FadeBeginTimerFired(nsITimer* aTimer, void* aSelf) {
    RefPtr<ScrollbarActivity> scrollbarActivity(

  virtual ~ScrollbarActivity() {}

  bool IsActivityOngoing()
  { return mNestedActivityCounter > 0; }
  bool IsStillFading(TimeStamp aTime);
  void QueryLookAndFeelVals();

  void HandleEventForScrollbar(const nsAString& aType,
                               nsIContent* aTarget,
                               dom::Element* aScrollbar,
                               bool* aStoredHoverState);

  void SetIsActive(bool aNewActive);
  bool SetIsFading(bool aNewFading); // returns false if 'this' was destroyed

  void BeginFade();
  void EndFade();

  void StartFadeBeginTimer();
  void CancelFadeBeginTimer();

  void StartListeningForScrollbarEvents();
  void StartListeningForScrollAreaEvents();
  void StopListeningForScrollbarEvents();
  void StopListeningForScrollAreaEvents();
  void AddScrollbarEventListeners(dom::EventTarget* aScrollbar);
  void RemoveScrollbarEventListeners(dom::EventTarget* aScrollbar);

  void RegisterWithRefreshDriver();
  void UnregisterFromRefreshDriver();

  bool UpdateOpacity(TimeStamp aTime); // returns false if 'this' was destroyed
  void HoveredScrollbar(dom::Element* aScrollbar);

  nsRefreshDriver* GetRefreshDriver();
  dom::Element* GetScrollbarContent(bool aVertical);
  dom::Element* GetHorizontalScrollbar() { return GetScrollbarContent(false); }
  dom::Element* GetVerticalScrollbar() { return GetScrollbarContent(true); }

  const TimeDuration FadeDuration() {
    return TimeDuration::FromMilliseconds(mScrollbarFadeDuration);

  nsIScrollbarMediator* mScrollableFrame;
  TimeStamp mFadeBeginTime;
  nsCOMPtr<nsITimer> mFadeBeginTimer;
  nsCOMPtr<dom::EventTarget> mHorizontalScrollbar; // null while inactive
  nsCOMPtr<dom::EventTarget> mVerticalScrollbar;   // null while inactive
  int mNestedActivityCounter;
  bool mIsActive;
  bool mIsFading;
  bool mListeningForScrollbarEvents;
  bool mListeningForScrollAreaEvents;
  bool mHScrollbarHovered;
  bool mVScrollbarHovered;

  // LookAndFeel values we load on creation
  bool mDisplayOnMouseMove;
  int mScrollbarFadeBeginDelay;
  int mScrollbarFadeDuration;

} // namespace layout
} // namespace mozilla

#endif /* ScrollbarActivity_h___ */