Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
//
// Eric Vaughan
// Netscape Communications
//
// See documentation in associated header file
//
#include "nsSliderFrame.h"
#include "mozilla/ComputedStyle.h"
#include "nsPresContext.h"
#include "nsIContent.h"
#include "nsCOMPtr.h"
#include "nsNameSpaceManager.h"
#include "nsGkAtoms.h"
#include "nsHTMLParts.h"
#include "nsCSSRendering.h"
#include "nsScrollbarButtonFrame.h"
#include "nsIScrollbarMediator.h"
#include "nsISupportsImpl.h"
#include "nsScrollbarFrame.h"
#include "nsRepeatService.h"
#include "nsContentUtils.h"
#include "nsLayoutUtils.h"
#include "nsDisplayList.h"
#include "nsDeviceContext.h"
#include "nsRefreshDriver.h" // for nsAPostRefreshObserver
#include "mozilla/Assertions.h" // for MOZ_ASSERT
#include "mozilla/DisplayPortUtils.h"
#include "mozilla/LookAndFeel.h"
#include "mozilla/MouseEvents.h"
#include "mozilla/Preferences.h"
#include "mozilla/PresShell.h"
#include "mozilla/ScrollContainerFrame.h"
#include "mozilla/StaticPrefs_general.h"
#include "mozilla/StaticPrefs_layout.h"
#include "mozilla/SVGIntegrationUtils.h"
#include "mozilla/Telemetry.h"
#include "mozilla/dom/Document.h"
#include "mozilla/dom/Event.h"
#include "mozilla/layers/APZCCallbackHelper.h"
#include "mozilla/layers/AsyncDragMetrics.h"
#include "mozilla/layers/InputAPZContext.h"
#include "mozilla/layers/WebRenderLayerManager.h"
#include "mozilla/StaticPrefs_slider.h"
#include <algorithm>
using namespace mozilla;
using namespace mozilla::gfx;
using mozilla::dom::Document;
using mozilla::dom::Event;
using mozilla::layers::AsyncDragMetrics;
using mozilla::layers::InputAPZContext;
using mozilla::layers::ScrollbarData;
using mozilla::layers::ScrollDirection;
bool nsSliderFrame::gMiddlePref = false;
// Turn this on if you want to debug slider frames.
#undef DEBUG_SLIDER
nsIFrame* NS_NewSliderFrame(PresShell* aPresShell, ComputedStyle* aStyle) {
return new (aPresShell) nsSliderFrame(aStyle, aPresShell->GetPresContext());
}
NS_IMPL_FRAMEARENA_HELPERS(nsSliderFrame)
NS_QUERYFRAME_HEAD(nsSliderFrame)
NS_QUERYFRAME_ENTRY(nsSliderFrame)
NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
nsSliderFrame::nsSliderFrame(ComputedStyle* aStyle, nsPresContext* aPresContext)
: nsContainerFrame(aStyle, aPresContext, kClassID),
mRatio(0.0f),
mDragStart(0),
mThumbStart(0),
mCurPos(0),
mRepeatDirection(0),
mUserChanged(false),
mScrollingWithAPZ(false),
mSuppressionActive(false),
mThumbMinLength(0) {}
// stop timer
nsSliderFrame::~nsSliderFrame() {
if (mSuppressionActive) {
if (auto* presShell = PresShell()) {
presShell->SuppressDisplayport(false);
}
}
}
void nsSliderFrame::Init(nsIContent* aContent, nsContainerFrame* aParent,
nsIFrame* aPrevInFlow) {
nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
static bool gotPrefs = false;
if (!gotPrefs) {
gotPrefs = true;
gMiddlePref = Preferences::GetBool("middlemouse.scrollbarPosition");
}
mCurPos = GetCurrentPosition(aContent);
}
void nsSliderFrame::RemoveFrame(DestroyContext& aContext, ChildListID aListID,
nsIFrame* aOldFrame) {
nsContainerFrame::RemoveFrame(aContext, aListID, aOldFrame);
if (mFrames.IsEmpty()) {
RemoveListener();
}
}
void nsSliderFrame::InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame,
const nsLineList::iterator* aPrevFrameLine,
nsFrameList&& aFrameList) {
bool wasEmpty = mFrames.IsEmpty();
nsContainerFrame::InsertFrames(aListID, aPrevFrame, aPrevFrameLine,
std::move(aFrameList));
if (wasEmpty) {
AddListener();
}
}
void nsSliderFrame::AppendFrames(ChildListID aListID,
nsFrameList&& aFrameList) {
// If we have no children and on was added then make sure we add the
// listener
bool wasEmpty = mFrames.IsEmpty();
nsContainerFrame::AppendFrames(aListID, std::move(aFrameList));
if (wasEmpty) {
AddListener();
}
}
int32_t nsSliderFrame::GetCurrentPosition(nsIContent* content) {
return GetIntegerAttribute(content, nsGkAtoms::curpos, 0);
}
int32_t nsSliderFrame::GetMinPosition(nsIContent* content) {
return GetIntegerAttribute(content, nsGkAtoms::minpos, 0);
}
int32_t nsSliderFrame::GetMaxPosition(nsIContent* content) {
return GetIntegerAttribute(content, nsGkAtoms::maxpos, 100);
}
int32_t nsSliderFrame::GetIncrement(nsIContent* content) {
return GetIntegerAttribute(content, nsGkAtoms::increment, 1);
}
int32_t nsSliderFrame::GetPageIncrement(nsIContent* content) {
return GetIntegerAttribute(content, nsGkAtoms::pageincrement, 10);
}
int32_t nsSliderFrame::GetIntegerAttribute(nsIContent* content, nsAtom* atom,
int32_t defaultValue) {
nsAutoString value;
if (content->IsElement()) {
content->AsElement()->GetAttr(atom, value);
}
if (!value.IsEmpty()) {
nsresult error;
// convert it to an integer
defaultValue = value.ToInteger(&error);
}
return defaultValue;
}
nsresult nsSliderFrame::AttributeChanged(int32_t aNameSpaceID,
nsAtom* aAttribute, int32_t aModType) {
nsresult rv =
nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType);
// if the current position changes
if (aAttribute == nsGkAtoms::curpos) {
CurrentPositionChanged();
} else if (aAttribute == nsGkAtoms::minpos ||
aAttribute == nsGkAtoms::maxpos) {
// bounds check it.
nsScrollbarFrame* scrollbarBox = Scrollbar();
nsCOMPtr<nsIContent> scrollbar = scrollbarBox->GetContent();
int32_t current = GetCurrentPosition(scrollbar);
int32_t min = GetMinPosition(scrollbar);
int32_t max = GetMaxPosition(scrollbar);
if (current < min || current > max) {
int32_t direction = 0;
if (current < min || max < min) {
current = min;
direction = -1;
} else if (current > max) {
current = max;
direction = 1;
}
// set the new position and notify observers
nsIScrollbarMediator* mediator = scrollbarBox->GetScrollbarMediator();
scrollbarBox->SetIncrementToWhole(direction);
if (mediator) {
mediator->ScrollByWhole(scrollbarBox, direction,
ScrollSnapFlags::IntendedEndPosition);
}
// 'this' might be destroyed here
nsContentUtils::AddScriptRunner(new nsSetAttrRunnable(
scrollbar->AsElement(), nsGkAtoms::curpos, current));
}
}
if (aAttribute == nsGkAtoms::minpos || aAttribute == nsGkAtoms::maxpos ||
aAttribute == nsGkAtoms::pageincrement ||
aAttribute == nsGkAtoms::increment) {
PresShell()->FrameNeedsReflow(
this, IntrinsicDirty::FrameAncestorsAndDescendants, NS_FRAME_IS_DIRTY);
}
return rv;
}
namespace mozilla {
// Draw any tick marks that show the position of find in page results.
class nsDisplaySliderMarks final : public nsPaintedDisplayItem {
public:
nsDisplaySliderMarks(nsDisplayListBuilder* aBuilder, nsSliderFrame* aFrame)
: nsPaintedDisplayItem(aBuilder, aFrame) {
MOZ_COUNT_CTOR(nsDisplaySliderMarks);
}
MOZ_COUNTED_DTOR_OVERRIDE(nsDisplaySliderMarks)
NS_DISPLAY_DECL_NAME("SliderMarks", TYPE_SLIDER_MARKS)
void PaintMarks(nsDisplayListBuilder* aDisplayListBuilder,
wr::DisplayListBuilder* aBuilder, gfxContext* aCtx);
nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) const override {
*aSnap = false;
return mFrame->InkOverflowRectRelativeToSelf() + ToReferenceFrame();
}
bool CreateWebRenderCommands(
wr::DisplayListBuilder& aBuilder, wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc,
layers::RenderRootStateManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) override;
void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override;
};
// This is shared between the webrender and Paint() paths. For the former,
// aBuilder should be assigned and aCtx will be null. For the latter, aBuilder
// should be null and aCtx should be the gfxContext for painting.
void nsDisplaySliderMarks::PaintMarks(nsDisplayListBuilder* aDisplayListBuilder,
wr::DisplayListBuilder* aBuilder,
gfxContext* aCtx) {
DrawTarget* drawTarget = nullptr;
if (aCtx) {
drawTarget = aCtx->GetDrawTarget();
} else {
MOZ_ASSERT(aBuilder);
}
Document* doc = mFrame->GetContent()->GetUncomposedDoc();
if (!doc) {
return;
}
nsGlobalWindowInner* window =
nsGlobalWindowInner::Cast(doc->GetInnerWindow());
if (!window) {
return;
}
nsSliderFrame* sliderFrame = static_cast<nsSliderFrame*>(mFrame);
nsIFrame* scrollbarBox = sliderFrame->Scrollbar();
nsCOMPtr<nsIContent> scrollbar = scrollbarBox->GetContent();
int32_t minPos = sliderFrame->GetMinPosition(scrollbar);
int32_t maxPos = sliderFrame->GetMaxPosition(scrollbar);
// Use the text highlight color for the tick marks.
nscolor highlightColor =
LookAndFeel::Color(LookAndFeel::ColorID::TextHighlightBackground, mFrame);
DeviceColor fillColor = ToDeviceColor(highlightColor);
fillColor.a = 0.3; // make the mark mostly transparent
int32_t appUnitsPerDevPixel =
sliderFrame->PresContext()->AppUnitsPerDevPixel();
nsRect sliderRect = sliderFrame->GetRect();
nsPoint refPoint = aDisplayListBuilder->ToReferenceFrame(mFrame);
// Increase the height of the tick mark rectangle by one pixel. If the
// desktop scale is greater than 1, it should be increased more.
// The tick marks should be drawn ignoring any page zoom that is applied.
float increasePixels = sliderFrame->PresContext()
->DeviceContext()
->GetDesktopToDeviceScale()
.scale;
const bool isHorizontal = sliderFrame->Scrollbar()->IsHorizontal();
float increasePixelsX = isHorizontal ? increasePixels : 0;
float increasePixelsY = isHorizontal ? 0 : increasePixels;
nsSize initialSize =
isHorizontal ? nsSize(0, sliderRect.height) : nsSize(sliderRect.width, 0);
nsTArray<uint32_t>& marks = window->GetScrollMarks();
for (uint32_t m = 0; m < marks.Length(); m++) {
uint32_t markValue = marks[m];
if (markValue > (uint32_t)maxPos) {
markValue = maxPos;
}
if (markValue < (uint32_t)minPos) {
markValue = minPos;
}
// The values in the marks array range up to the window's
// scrollMax{X,Y} - scrollMin{X,Y} (the same as the slider's maxpos).
// Scale the values to fit within the slider's width or height.
nsRect markRect(refPoint, initialSize);
if (isHorizontal) {
markRect.x +=
(nscoord)((double)markValue / (maxPos - minPos) * sliderRect.width);
} else {
markRect.y +=
(nscoord)((double)markValue / (maxPos - minPos) * sliderRect.height);
}
if (drawTarget) {
Rect devPixelRect =
NSRectToSnappedRect(markRect, appUnitsPerDevPixel, *drawTarget);
devPixelRect.Inflate(increasePixelsX, increasePixelsY);
drawTarget->FillRect(devPixelRect, ColorPattern(fillColor));
} else {
LayoutDeviceIntRect dRect = LayoutDeviceIntRect::FromAppUnitsToNearest(
markRect, appUnitsPerDevPixel);
dRect.Inflate(increasePixelsX, increasePixelsY);
wr::LayoutRect layoutRect = wr::ToLayoutRect(dRect);
aBuilder->PushRect(layoutRect, layoutRect, BackfaceIsHidden(), false,
false, wr::ToColorF(fillColor));
}
}
}
bool nsDisplaySliderMarks::CreateWebRenderCommands(
wr::DisplayListBuilder& aBuilder, wr::IpcResourceUpdateQueue& aResources,
const StackingContextHelper& aSc, layers::RenderRootStateManager* aManager,
nsDisplayListBuilder* aDisplayListBuilder) {
PaintMarks(aDisplayListBuilder, &aBuilder, nullptr);
return true;
}
void nsDisplaySliderMarks::Paint(nsDisplayListBuilder* aBuilder,
gfxContext* aCtx) {
PaintMarks(aBuilder, nullptr, aCtx);
}
} // namespace mozilla
void nsSliderFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsDisplayListSet& aLists) {
if (aBuilder->IsForEventDelivery() && IsDraggingThumb()) {
// This is EVIL, we shouldn't be messing with event delivery just to get
// thumb mouse drag events to arrive at the slider!
aLists.Outlines()->AppendNewToTop<nsDisplayEventReceiver>(aBuilder, this);
return;
}
DisplayBorderBackgroundOutline(aBuilder, aLists);
if (nsIFrame* thumb = mFrames.FirstChild()) {
BuildDisplayListForThumb(aBuilder, thumb, aLists);
}
// If this is an scrollbar for the root frame, draw any markers.
// Markers are not drawn for other scrollbars.
// XXX seems like this should be done in nsScrollbarFrame instead perhaps?
if (!aBuilder->IsForEventDelivery()) {
nsScrollbarFrame* scrollbar = Scrollbar();
if (ScrollContainerFrame* scrollContainerFrame =
do_QueryFrame(scrollbar->GetParent())) {
if (scrollContainerFrame->IsRootScrollFrameOfDocument()) {
nsGlobalWindowInner* window = nsGlobalWindowInner::Cast(
PresContext()->Document()->GetInnerWindow());
if (window &&
window->GetScrollMarksOnHScrollbar() == scrollbar->IsHorizontal() &&
window->GetScrollMarks().Length() > 0) {
aLists.Content()->AppendNewToTop<nsDisplaySliderMarks>(aBuilder,
this);
}
}
}
}
}
static bool UsesCustomScrollbarMediator(nsIFrame* scrollbarBox) {
if (nsScrollbarFrame* scrollbarFrame = do_QueryFrame(scrollbarBox)) {
if (nsIScrollbarMediator* mediator =
scrollbarFrame->GetScrollbarMediator()) {
// Note we can't queryframe from nsIScrollbarMediator to
// ScrollContainerFrame directly due to an optimization in the queryframe
// implementation for ScrollContainerFrame.
nsIFrame* mediatorAsFrame = do_QueryFrame(mediator);
ScrollContainerFrame* scrollContainerFrame =
do_QueryFrame(mediatorAsFrame);
// The scrollbar mediator is not the scroll container frame.
// That means this scroll container frame has a custom scrollbar mediator.
if (!scrollContainerFrame) {
return true;
}
}
}
return false;
}
void nsSliderFrame::BuildDisplayListForThumb(nsDisplayListBuilder* aBuilder,
nsIFrame* aThumb,
const nsDisplayListSet& aLists) {
nsRect thumbRect(aThumb->GetRect());
nsRect sliderTrack = GetRect();
if (sliderTrack.width < thumbRect.width ||
sliderTrack.height < thumbRect.height) {
return;
}
// If this scrollbar is the scrollbar of an actively scrolled scroll frame,
// layerize the scrollbar thumb, wrap it in its own ContainerLayer and
// attach scrolling information to it.
// We do this here and not in the thumb's BuildDisplayList so that the event
// region that gets created for the thumb is included in the nsDisplayOwnLayer
// contents.
const layers::ScrollableLayerGuid::ViewID scrollTargetId =
aBuilder->GetCurrentScrollbarTarget();
const bool thumbGetsLayer =
scrollTargetId != layers::ScrollableLayerGuid::NULL_SCROLL_ID;
if (thumbGetsLayer) {
const Maybe<ScrollDirection> scrollDirection =
aBuilder->GetCurrentScrollbarDirection();
MOZ_ASSERT(scrollDirection.isSome());
const bool isHorizontal = *scrollDirection == ScrollDirection::eHorizontal;
const OuterCSSCoord thumbLength = OuterCSSPixel::FromAppUnits(
isHorizontal ? thumbRect.width : thumbRect.height);
const OuterCSSCoord minThumbLength =
OuterCSSPixel::FromAppUnits(mThumbMinLength);
nsIFrame* scrollbarBox = Scrollbar();
bool isAsyncDraggable = !UsesCustomScrollbarMediator(scrollbarBox);
nsPoint scrollPortOrigin;
if (ScrollContainerFrame* scrollContainerFrame =
do_QueryFrame(scrollbarBox->GetParent())) {
scrollPortOrigin = scrollContainerFrame->GetScrollPortRect().TopLeft();
} else {
isAsyncDraggable = false;
}
// This rect is the range in which the scroll thumb can slide in.
sliderTrack = sliderTrack + scrollbarBox->GetPosition() - scrollPortOrigin;
const OuterCSSCoord sliderTrackStart = OuterCSSPixel::FromAppUnits(
isHorizontal ? sliderTrack.x : sliderTrack.y);
const OuterCSSCoord sliderTrackLength = OuterCSSPixel::FromAppUnits(
isHorizontal ? sliderTrack.width : sliderTrack.height);
const OuterCSSCoord thumbStart =
OuterCSSPixel::FromAppUnits(isHorizontal ? thumbRect.x : thumbRect.y);
const nsRect overflow = aThumb->InkOverflowRectRelativeToParent();
nsSize refSize = aBuilder->RootReferenceFrame()->GetSize();
nsRect dirty = aBuilder->GetVisibleRect().Intersect(thumbRect);
dirty = nsLayoutUtils::ComputePartialPrerenderArea(
aThumb, aBuilder->GetVisibleRect(), overflow, refSize);
nsDisplayListBuilder::AutoBuildingDisplayList buildingDisplayList(
aBuilder, this, dirty, dirty);
// Clip the thumb layer to the slider track. This is necessary to ensure
// FrameLayerBuilder is able to merge content before and after the
// scrollframe into the same layer (otherwise it thinks the thumb could
// potentially move anywhere within the existing clip).
DisplayListClipState::AutoSaveRestore thumbClipState(aBuilder);
thumbClipState.ClipContainingBlockDescendants(
GetRectRelativeToSelf() + aBuilder->ToReferenceFrame(this));
// Have the thumb's container layer capture the current clip, so
// it doesn't apply to the thumb's contents. This allows the contents
// to be fully rendered even if they're partially or fully offscreen,
// so async scrolling can still bring it into view.
DisplayListClipState::AutoSaveRestore thumbContentsClipState(aBuilder);
thumbContentsClipState.Clear();
nsDisplayListBuilder::AutoContainerASRTracker contASRTracker(aBuilder);
nsDisplayListCollection tempLists(aBuilder);
BuildDisplayListForChild(aBuilder, aThumb, tempLists);
// This is a bit of a hack. Collect up all descendant display items
// and merge them into a single Content() list.
nsDisplayList masterList(aBuilder);
masterList.AppendToTop(tempLists.BorderBackground());
masterList.AppendToTop(tempLists.BlockBorderBackgrounds());
masterList.AppendToTop(tempLists.Floats());
masterList.AppendToTop(tempLists.Content());
masterList.AppendToTop(tempLists.PositionedDescendants());
masterList.AppendToTop(tempLists.Outlines());
// Restore the saved clip so it applies to the thumb container layer.
thumbContentsClipState.Restore();
// Wrap the list to make it its own layer.
const ActiveScrolledRoot* ownLayerASR = contASRTracker.GetContainerASR();
aLists.Content()->AppendNewToTopWithIndex<nsDisplayOwnLayer>(
aBuilder, this,
/* aIndex = */ nsDisplayOwnLayer::OwnLayerForScrollThumb, &masterList,
ownLayerASR, nsDisplayOwnLayerFlags::None,
ScrollbarData::CreateForThumb(*scrollDirection, GetThumbRatio(),
thumbStart, thumbLength, minThumbLength,
isAsyncDraggable, sliderTrackStart,
sliderTrackLength, scrollTargetId),
true, false);
return;
}
BuildDisplayListForChild(aBuilder, aThumb, aLists);
}
void nsSliderFrame::Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) {
MarkInReflow();
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
NS_ASSERTION(aReflowInput.AvailableWidth() != NS_UNCONSTRAINEDSIZE,
"Bogus avail width");
NS_ASSERTION(aReflowInput.AvailableHeight() != NS_UNCONSTRAINEDSIZE,
"Bogus avail height");
const auto wm = GetWritingMode();
// We always take all the space we're given.
aDesiredSize.SetSize(wm, aReflowInput.ComputedSize(wm));
aDesiredSize.SetOverflowAreasToDesiredBounds();
// Get the thumb, should be our only child.
nsIFrame* thumbBox = mFrames.FirstChild();
if (NS_WARN_IF(!thumbBox)) {
return;
}
nsScrollbarFrame* scrollbarBox = Scrollbar();
nsIContent* scrollbar = scrollbarBox->GetContent();
const bool horizontal = scrollbarBox->IsHorizontal();
nsSize availSize = aDesiredSize.PhysicalSize();
ReflowInput thumbRI(aPresContext, aReflowInput, thumbBox,
aReflowInput.AvailableSize(wm));
// Get the thumb's pref size.
nsSize thumbSize = thumbRI.ComputedMinSize(wm).GetPhysicalSize(wm);
if (horizontal) {
thumbSize.height = availSize.height;
} else {
thumbSize.width = availSize.width;
}
int32_t curPos = GetCurrentPosition(scrollbar);
int32_t minPos = GetMinPosition(scrollbar);
int32_t maxPos = GetMaxPosition(scrollbar);
int32_t pageIncrement = GetPageIncrement(scrollbar);
maxPos = std::max(minPos, maxPos);
curPos = std::clamp(curPos, minPos, maxPos);
// If modifying the logic here, be sure to modify the corresponding
// compositor-side calculation in ScrollThumbUtils::ApplyTransformForAxis().
nscoord& availableLength = horizontal ? availSize.width : availSize.height;
nscoord& thumbLength = horizontal ? thumbSize.width : thumbSize.height;
mThumbMinLength = thumbLength;
if ((pageIncrement + maxPos - minPos) > 0) {
float ratio = float(pageIncrement) / float(maxPos - minPos + pageIncrement);
thumbLength =
std::max(thumbLength, NSToCoordRound(availableLength * ratio));
}
// Round the thumb's length to device pixels.
nsPresContext* presContext = PresContext();
thumbLength = presContext->DevPixelsToAppUnits(
presContext->AppUnitsToDevPixels(thumbLength));
// mRatio translates the thumb position in app units to the value.
mRatio = (minPos != maxPos)
? float(availableLength - thumbLength) / float(maxPos - minPos)
: 1;
// in reverse mode, curpos is reversed such that lower values are to the
// right or bottom and increase leftwards or upwards. In this case, use the
// offset from the end instead of the beginning.
bool reverse = mContent->AsElement()->AttrValueIs(
kNameSpaceID_None, nsGkAtoms::dir, nsGkAtoms::reverse, eCaseMatters);
nscoord pos = reverse ? (maxPos - curPos) : (curPos - minPos);
// set the thumb's coord to be the current pos * the ratio.
nsPoint thumbPos;
if (horizontal) {
thumbPos.x = NSToCoordRound(pos * mRatio);
} else {
thumbPos.y = NSToCoordRound(pos * mRatio);
}
// Same to `snappedThumbLocation` in `nsSliderFrame::CurrentPositionChanged`,
// to avoid putting the scroll thumb at subpixel positions which cause
// needless invalidations
nscoord appUnitsPerPixel = PresContext()->AppUnitsPerDevPixel();
thumbPos =
ToAppUnits(thumbPos.ToNearestPixels(appUnitsPerPixel), appUnitsPerPixel);
const LogicalPoint logicalPos(wm, thumbPos, availSize);
// TODO: It seems like a lot of this stuff should really belong in the thumb's
// reflow code rather than here, but since we rely on the frame tree structure
// heavily this matches the previous code more closely for now.
ReflowOutput thumbDesiredSize(wm);
const auto flags = ReflowChildFlags::Default;
nsReflowStatus status;
thumbRI.SetComputedISize(thumbSize.width);
thumbRI.SetComputedBSize(thumbSize.height);
ReflowChild(thumbBox, aPresContext, thumbDesiredSize, thumbRI, wm, logicalPos,
availSize, flags, status);
FinishReflowChild(thumbBox, aPresContext, thumbDesiredSize, &thumbRI, wm,
logicalPos, availSize, flags);
}
nsresult nsSliderFrame::HandleEvent(nsPresContext* aPresContext,
WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus) {
NS_ENSURE_ARG_POINTER(aEventStatus);
if (mAPZDragInitiated &&
*mAPZDragInitiated == InputAPZContext::GetInputBlockId() &&
aEvent->mMessage == eMouseDown) {
// If we get the mousedown after the APZ notification, then immediately
// switch into the state corresponding to an APZ thumb-drag. Note that
// we can't just do this in AsyncScrollbarDragInitiated() directly because
// the handling for this mousedown event in the presShell will reset the
// capturing content which makes isDraggingThumb() return false. We check
// the input block here to make sure that we correctly handle any ordering
// of {eMouseDown arriving, AsyncScrollbarDragInitiated() being called}.
mAPZDragInitiated = Nothing();
DragThumb(true);
mScrollingWithAPZ = true;
return NS_OK;
}
// If a web page calls event.preventDefault() we still want to
if (!mContent->IsInNativeAnonymousSubtree() &&
nsEventStatus_eConsumeNoDefault == *aEventStatus) {
return NS_OK;
}
if (mDragInProgress && !IsDraggingThumb()) {
StopDrag();
return NS_OK;
}
nsScrollbarFrame* scrollbarBox = Scrollbar();
nsCOMPtr<nsIContent> scrollbar = scrollbarBox->GetContent();
bool isHorizontal = scrollbarBox->IsHorizontal();
if (IsDraggingThumb()) {
switch (aEvent->mMessage) {
case eTouchMove:
case eMouseMove: {
if (mScrollingWithAPZ) {
break;
}
nsPoint eventPoint;
if (!GetEventPoint(aEvent, eventPoint)) {
break;
}
if (mRepeatDirection) {
// On Linux the destination point is determined by the initial click
// on the scrollbar track and doesn't change until the mouse button
// is released.
#ifndef MOZ_WIDGET_GTK
// On the other platforms we need to update the destination point now.
mDestinationPoint = eventPoint;
StopRepeat();
StartRepeat();
#endif
break;
}
nscoord pos = isHorizontal ? eventPoint.x : eventPoint.y;
nsIFrame* thumbFrame = mFrames.FirstChild();
if (!thumbFrame) {
return NS_OK;
}
// take our current position and subtract the start location
pos -= mDragStart;
bool isMouseOutsideThumb = false;
const int32_t snapMultiplier = StaticPrefs::slider_snapMultiplier();
if (snapMultiplier) {
nsSize thumbSize = thumbFrame->GetSize();
if (isHorizontal) {
// horizontal scrollbar - check if mouse is above or below thumb
// XXXbz what about looking at the .y of the thumb's rect? Is that
// always zero here?
if (eventPoint.y < -snapMultiplier * thumbSize.height ||
eventPoint.y >
thumbSize.height + snapMultiplier * thumbSize.height) {
isMouseOutsideThumb = true;
}
} else {
// vertical scrollbar - check if mouse is left or right of thumb
if (eventPoint.x < -snapMultiplier * thumbSize.width ||
eventPoint.x >
thumbSize.width + snapMultiplier * thumbSize.width) {
isMouseOutsideThumb = true;
}
}
}
if (aEvent->mClass == eTouchEventClass) {
*aEventStatus = nsEventStatus_eConsumeNoDefault;
}
if (isMouseOutsideThumb) {
SetCurrentThumbPosition(scrollbar, mThumbStart, false, false);
return NS_OK;
}
// set it
SetCurrentThumbPosition(scrollbar, pos, false, true); // with snapping
} break;
case eTouchEnd:
case eMouseUp:
if (ShouldScrollForEvent(aEvent)) {
StopDrag();
// we MUST call nsFrame HandleEvent for mouse ups to maintain the
// selection state and capture state.
return nsIFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
}
break;
default:
break;
}
// return nsIFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
return NS_OK;
}
if (ShouldScrollToClickForEvent(aEvent)) {
nsPoint eventPoint;
if (!GetEventPoint(aEvent, eventPoint)) {
return NS_OK;
}
nscoord pos = isHorizontal ? eventPoint.x : eventPoint.y;
// adjust so that the middle of the thumb is placed under the click
nsIFrame* thumbFrame = mFrames.FirstChild();
if (!thumbFrame) {
return NS_OK;
}
nsSize thumbSize = thumbFrame->GetSize();
nscoord thumbLength = isHorizontal ? thumbSize.width : thumbSize.height;
// set it
AutoWeakFrame weakFrame(this);
// should aMaySnap be true here?
SetCurrentThumbPosition(scrollbar, pos - thumbLength / 2, false, false);
NS_ENSURE_TRUE(weakFrame.IsAlive(), NS_OK);
DragThumb(true);
if (aEvent->mClass == eTouchEventClass) {
*aEventStatus = nsEventStatus_eConsumeNoDefault;
}
SetupDrag(aEvent, thumbFrame, pos, isHorizontal);
}
#ifdef MOZ_WIDGET_GTK
else if (ShouldScrollForEvent(aEvent) && aEvent->mClass == eMouseEventClass &&
aEvent->AsMouseEvent()->mButton == MouseButton::eSecondary) {
// HandlePress and HandleRelease are usually called via
// nsIFrame::HandleEvent, but only for the left mouse button.
if (aEvent->mMessage == eMouseDown) {
HandlePress(aPresContext, aEvent, aEventStatus);
} else if (aEvent->mMessage == eMouseUp) {
HandleRelease(aPresContext, aEvent, aEventStatus);
}
return NS_OK;
}
#endif
// XXX hack until handle release is actually called in nsframe.
// if (aEvent->mMessage == eMouseOut ||
// aEvent->mMessage == NS_MOUSE_RIGHT_BUTTON_UP ||
// aEvent->mMessage == NS_MOUSE_LEFT_BUTTON_UP) {
// HandleRelease(aPresContext, aEvent, aEventStatus);
// }
if (aEvent->mMessage == eMouseOut && mRepeatDirection) {
HandleRelease(aPresContext, aEvent, aEventStatus);
}
return nsIFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
}
// Helper function to collect the "scroll to click" metric. Beware of
// caching this, users expect to be able to change the system preference
// and see the browser change its behavior immediately.
bool nsSliderFrame::GetScrollToClick() {
return LookAndFeel::GetInt(LookAndFeel::IntID::ScrollToClick, false);
}
nsScrollbarFrame* nsSliderFrame::Scrollbar() {
MOZ_ASSERT(GetParent());
MOZ_DIAGNOSTIC_ASSERT(
static_cast<nsScrollbarFrame*>(do_QueryFrame(GetParent())));
return static_cast<nsScrollbarFrame*>(GetParent());
}
void nsSliderFrame::PageUpDown(nscoord change) {
// on a page up or down get our page increment. We get this by getting the
// scrollbar we are in and asking it for the current position and the page
// increment. If we are not in a scrollbar we will get the values from our own
// node.
nsIFrame* scrollbarBox = Scrollbar();
nsCOMPtr<nsIContent> scrollbar = scrollbarBox->GetContent();
nscoord pageIncrement = GetPageIncrement(scrollbar);
int32_t curpos = GetCurrentPosition(scrollbar);
int32_t minpos = GetMinPosition(scrollbar);
int32_t maxpos = GetMaxPosition(scrollbar);
// get the new position and make sure it is in bounds
int32_t newpos = curpos + change * pageIncrement;
if (newpos < minpos || maxpos < minpos) {
newpos = minpos;
} else if (newpos > maxpos) {
newpos = maxpos;
}
SetCurrentPositionInternal(scrollbar, newpos, true);
}
// called when the current position changed and we need to update the thumb's
// location
void nsSliderFrame::CurrentPositionChanged() {
nsScrollbarFrame* scrollbarBox = Scrollbar();
nsCOMPtr<nsIContent> scrollbar = scrollbarBox->GetContent();
// get the current position
int32_t curPos = GetCurrentPosition(scrollbar);
// do nothing if the position did not change
if (mCurPos == curPos) {
return;
}
// get our current min and max position from our content node
int32_t minPos = GetMinPosition(scrollbar);
int32_t maxPos = GetMaxPosition(scrollbar);
maxPos = std::max(minPos, maxPos);
curPos = std::clamp(curPos, minPos, maxPos);
// get the thumb's rect
nsIFrame* thumbFrame = mFrames.FirstChild();
if (!thumbFrame) {
return;
}
bool reverse = mContent->AsElement()->AttrValueIs(
kNameSpaceID_None, nsGkAtoms::dir, nsGkAtoms::reverse, eCaseMatters);
nscoord pos = reverse ? (maxPos - curPos) : (curPos - minPos);
const bool horizontal = Scrollbar()->IsHorizontal();
// figure out the new rect
nsRect thumbRect = thumbFrame->GetRect();
nsRect newThumbRect(thumbRect);
if (horizontal) {
newThumbRect.x = NSToCoordRound(pos * mRatio);
} else {
newThumbRect.y = NSToCoordRound(pos * mRatio);
}
// avoid putting the scroll thumb at subpixel positions which cause needless
// invalidations
nscoord appUnitsPerPixel = PresContext()->AppUnitsPerDevPixel();
nsPoint snappedThumbLocation =
ToAppUnits(newThumbRect.TopLeft().ToNearestPixels(appUnitsPerPixel),
appUnitsPerPixel);
if (horizontal) {
newThumbRect.x = snappedThumbLocation.x;
} else {
newThumbRect.y = snappedThumbLocation.y;
}
// set the rect
// XXX This out-of-band update of the frame tree is rather fishy!
thumbFrame->SetRect(newThumbRect);
// When the thumb changes position, the mThumbStart value stored in
// ScrollbarData for the purpose of telling APZ about the thumb
// position painted by the main thread is invalidated. The ScrollbarData
// is stored on the nsDisplayOwnLayer item built by *this* frame, so
// we need to mark this frame as needing its fisplay item rebuilt.
MarkNeedsDisplayItemRebuild();
// Request a repaint of the scrollbar
nsIScrollbarMediator* mediator = scrollbarBox->GetScrollbarMediator();
if (!mediator || !mediator->ShouldSuppressScrollbarRepaints()) {
SchedulePaint();
}
mCurPos = curPos;
}
static void UpdateAttribute(dom::Element* aScrollbar, nscoord aNewPos,
bool aNotify, bool aIsSmooth) {
nsAutoString str;
str.AppendInt(aNewPos);
if (aIsSmooth) {
aScrollbar->SetAttr(kNameSpaceID_None, nsGkAtoms::smooth, u"true"_ns,
false);
}
aScrollbar->SetAttr(kNameSpaceID_None, nsGkAtoms::curpos, str, aNotify);
if (aIsSmooth) {
aScrollbar->UnsetAttr(kNameSpaceID_None, nsGkAtoms::smooth, false);
}
}
// Use this function when you want to set the scroll position via the position
// of the scrollbar thumb, e.g. when dragging the slider. This function scrolls
// the content in such a way that thumbRect.x/.y becomes aNewThumbPos.
void nsSliderFrame::SetCurrentThumbPosition(nsIContent* aScrollbar,
nscoord aNewThumbPos,
bool aIsSmooth, bool aMaySnap) {
int32_t newPos = NSToIntRound(aNewThumbPos / mRatio);
if (aMaySnap &&
mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::snap,
nsGkAtoms::_true, eCaseMatters)) {
// If snap="true", then the slider may only be set to min + (increment * x).
// Otherwise, the slider may be set to any positive integer.
int32_t increment = GetIncrement(aScrollbar);
newPos = NSToIntRound(newPos / float(increment)) * increment;
}
SetCurrentPosition(aScrollbar, newPos, aIsSmooth);
}
// Use this function when you know the target scroll position of the scrolled
// content. aNewPos should be passed to this function as a position as if the
// minpos is 0. That is, the minpos will be added to the position by this
// function. In a reverse direction slider, the newpos should be the distance
// from the end.
void nsSliderFrame::SetCurrentPosition(nsIContent* aScrollbar, int32_t aNewPos,
bool aIsSmooth) {
// get min and max position from our content node
int32_t minpos = GetMinPosition(aScrollbar);
int32_t maxpos = GetMaxPosition(aScrollbar);
// in reverse direction sliders, flip the value so that it goes from
// right to left, or bottom to top.
if (mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::dir,
nsGkAtoms::reverse, eCaseMatters)) {
aNewPos = maxpos - aNewPos;
} else {
aNewPos += minpos;
}
// get the new position and make sure it is in bounds
if (aNewPos < minpos || maxpos < minpos) {
aNewPos = minpos;
} else if (aNewPos > maxpos) {
aNewPos = maxpos;
}
SetCurrentPositionInternal(aScrollbar, aNewPos, aIsSmooth);
}
void nsSliderFrame::SetCurrentPositionInternal(nsIContent* aScrollbar,
int32_t aNewPos,
bool aIsSmooth) {
nsCOMPtr<nsIContent> scrollbar = aScrollbar;
nsScrollbarFrame* scrollbarBox = Scrollbar();
AutoWeakFrame weakFrame(this);
mUserChanged = true;
// See if we have a mediator.
if (nsIScrollbarMediator* mediator = scrollbarBox->GetScrollbarMediator()) {
nscoord oldPos =
nsPresContext::CSSPixelsToAppUnits(GetCurrentPosition(scrollbar));
nscoord newPos = nsPresContext::CSSPixelsToAppUnits(aNewPos);
mediator->ThumbMoved(scrollbarBox, oldPos, newPos);
if (!weakFrame.IsAlive()) {
return;
}
UpdateAttribute(scrollbar->AsElement(), aNewPos, /* aNotify */ false,
aIsSmooth);
CurrentPositionChanged();
mUserChanged = false;
return;
}
UpdateAttribute(scrollbar->AsElement(), aNewPos, true, aIsSmooth);
if (!weakFrame.IsAlive()) {
return;
}
mUserChanged = false;
#ifdef DEBUG_SLIDER
printf("Current Pos=%d\n", aNewPos);
#endif
}
void nsSliderFrame::SetInitialChildList(ChildListID aListID,
nsFrameList&& aChildList) {
nsContainerFrame::SetInitialChildList(aListID, std::move(aChildList));
if (aListID == FrameChildListID::Principal) {
AddListener();
}
}
nsresult nsSliderMediator::HandleEvent(dom::Event* aEvent) {
// Only process the event if the thumb is not being dragged.
if (mSlider && !mSlider->IsDraggingThumb()) {
return mSlider->StartDrag(aEvent);
}
return NS_OK;
}
static bool ScrollFrameWillBuildScrollInfoLayer(nsIFrame* aScrollFrame) {
/*
* Note: if changing the conditions in this function, make a corresponding
* change to nsDisplayListBuilder::ShouldBuildScrollInfoItemsForHoisting()
* in nsDisplayList.cpp.
*/
nsIFrame* current = aScrollFrame;
while (current) {
if (SVGIntegrationUtils::UsesSVGEffectsNotSupportedInCompositor(current)) {
return true;
}
current = nsLayoutUtils::GetParentOrPlaceholderForCrossDoc(current);
}
return false;
}
ScrollContainerFrame* nsSliderFrame::GetScrollContainerFrame() {
return do_QueryFrame(Scrollbar()->GetParent());
}
void nsSliderFrame::StartAPZDrag(WidgetGUIEvent* aEvent) {
if (!aEvent->mFlags.mHandledByAPZ) {
return;
}
if (!gfxPlatform::GetPlatform()->SupportsApzDragInput()) {
return;
}
if (aEvent->AsMouseEvent() &&
aEvent->AsMouseEvent()->mButton != MouseButton::ePrimary) {
return;
}
nsIFrame* scrollbarBox = Scrollbar();
nsContainerFrame* scrollFrame = scrollbarBox->GetParent();
if (!scrollFrame) {
return;
}
nsIContent* scrollableContent = scrollFrame->GetContent();
if (!scrollableContent) {
return;
}
// APZ dragging requires the scrollbar to be layerized, which doesn't
// happen for scroll info layers.
if (ScrollFrameWillBuildScrollInfoLayer(scrollFrame)) {
return;
}
// Custom scrollbar mediators are not supported in the APZ codepath.
if (UsesCustomScrollbarMediator(scrollbarBox)) {
return;
}
bool isHorizontal = Scrollbar()->IsHorizontal();
layers::ScrollableLayerGuid::ViewID scrollTargetId;
bool hasID = nsLayoutUtils::FindIDFor(scrollableContent, &scrollTargetId);
bool hasAPZView =
hasID && scrollTargetId != layers::ScrollableLayerGuid::NULL_SCROLL_ID;
if (!hasAPZView) {
return;
}
if (!DisplayPortUtils::HasNonMinimalDisplayPort(scrollableContent)) {
return;
}
auto* presShell = PresShell();
uint64_t inputblockId = InputAPZContext::GetInputBlockId();
uint32_t presShellId = presShell->GetPresShellId();
AsyncDragMetrics dragMetrics(
scrollTargetId, presShellId, inputblockId,
OuterCSSPixel::FromAppUnits(mDragStart),
isHorizontal ? ScrollDirection::eHorizontal : ScrollDirection::eVertical);
// It's important to set this before calling
// nsIWidget::StartAsyncScrollbarDrag(), because in some configurations, that
// can call AsyncScrollbarDragRejected() synchronously, which clears the flag
// (and we want it to stay cleared in that case).
mScrollingWithAPZ = true;
// When we start an APZ drag, we wont get mouse events for the drag.
// APZ will consume them all and only notify us of the new scroll position.
bool waitForRefresh = InputAPZContext::HavePendingLayerization();
nsIWidget* widget = this->GetNearestWidget();
if (waitForRefresh) {
waitForRefresh = false;
if (nsPresContext* presContext = presShell->GetPresContext()) {
presContext->RegisterManagedPostRefreshObserver(
new ManagedPostRefreshObserver(
presContext, [widget = RefPtr<nsIWidget>(widget),
dragMetrics](bool aWasCanceled) {
if (!aWasCanceled) {
widget->StartAsyncScrollbarDrag(dragMetrics);
}
return ManagedPostRefreshObserver::Unregister::Yes;
}));
waitForRefresh = true;
}
}
if (!waitForRefresh) {
widget->StartAsyncScrollbarDrag(dragMetrics);
}
}
nsresult nsSliderFrame::StartDrag(Event* aEvent) {
#ifdef DEBUG_SLIDER
printf("Begin dragging\n");
#endif
if (mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
nsGkAtoms::_true, eCaseMatters)) {
return NS_OK;
}
WidgetGUIEvent* event = aEvent->WidgetEventPtr()->AsGUIEvent();
if (!ShouldScrollForEvent(event)) {
return NS_OK;
}
nsPoint pt;
if (!GetEventPoint(event, pt)) {
return NS_OK;
}
bool isHorizontal = Scrollbar()->IsHorizontal();
nscoord pos = isHorizontal ? pt.x : pt.y;
// If we should scroll-to-click, first place the middle of the slider thumb
// under the mouse.
nsCOMPtr<nsIContent> scrollbar;
nscoord newpos = pos;
bool scrollToClick = ShouldScrollToClickForEvent(event);
if (scrollToClick) {
// adjust so that the middle of the thumb is placed under the click
nsIFrame* thumbFrame = mFrames.FirstChild();
if (!thumbFrame) {
return NS_OK;
}
nsSize thumbSize = thumbFrame->GetSize();
nscoord thumbLength = isHorizontal ? thumbSize.width : thumbSize.height;
newpos -= (thumbLength / 2);
scrollbar = Scrollbar()->GetContent();
}
DragThumb(true);
if (scrollToClick) {
// should aMaySnap be true here?
SetCurrentThumbPosition(scrollbar, newpos, false, false);
}
nsIFrame* thumbFrame = mFrames.FirstChild();
if (!thumbFrame) {
return NS_OK;
}
SetupDrag(event, thumbFrame, pos, isHorizontal);
return NS_OK;
}
nsresult nsSliderFrame::StopDrag() {
AddListener();
DragThumb(false);
mScrollingWithAPZ = false;
UnsuppressDisplayport();
if (mRepeatDirection) {
StopRepeat();
mRepeatDirection = 0;
}
return NS_OK;
}
void nsSliderFrame::DragThumb(bool aGrabMouseEvents) {
if (mDragInProgress != aGrabMouseEvents) {
Scrollbar()->ActivityChanged(aGrabMouseEvents);
}
mDragInProgress = aGrabMouseEvents;
if (aGrabMouseEvents) {
PresShell::SetCapturingContent(
GetContent(),
CaptureFlags::IgnoreAllowedState | CaptureFlags::PreventDragStart);
} else {
PresShell::ReleaseCapturingContent();
}
}
bool nsSliderFrame::IsDraggingThumb() const {
return PresShell::GetCapturingContent() == GetContent();
}
void nsSliderFrame::AddListener() {
if (!mMediator) {
mMediator = new nsSliderMediator(this);
}
nsIFrame* thumbFrame = mFrames.FirstChild();
if (!thumbFrame) {
return;
}
thumbFrame->GetContent()->AddSystemEventListener(u"mousedown"_ns, mMediator,
false, false);
thumbFrame->GetContent()->AddSystemEventListener(u"touchstart"_ns, mMediator,
false, false);
}
void nsSliderFrame::RemoveListener() {
NS_ASSERTION(mMediator, "No listener was ever added!!");
nsIFrame* thumbFrame = mFrames.FirstChild();
if (!thumbFrame) {
return;
}
thumbFrame->GetContent()->RemoveSystemEventListener(u"mousedown"_ns,
mMediator, false);
thumbFrame->GetContent()->RemoveSystemEventListener(u"touchstart"_ns,
mMediator, false);
}
bool nsSliderFrame::ShouldScrollForEvent(WidgetGUIEvent* aEvent) {
switch (aEvent->mMessage) {
case eTouchStart:
case eTouchEnd:
return true;
case eMouseDown:
case eMouseUp: {
uint16_t button = aEvent->AsMouseEvent()->mButton;
#ifdef MOZ_WIDGET_GTK
return (button == MouseButton::ePrimary) ||
(button == MouseButton::eSecondary && GetScrollToClick()) ||
(button == MouseButton::eMiddle && gMiddlePref &&
!GetScrollToClick());
#else
return (button == MouseButton::ePrimary) ||
(button == MouseButton::eMiddle && gMiddlePref);
#endif
}
default:
return false;
}
}
bool nsSliderFrame::ShouldScrollToClickForEvent(WidgetGUIEvent* aEvent) {
if (!ShouldScrollForEvent(aEvent)) {
return false;
}
if (aEvent->mMessage != eMouseDown && aEvent->mMessage != eTouchStart) {
return false;
}
#if defined(XP_MACOSX) || defined(MOZ_WIDGET_GTK)
// On Mac and Linux, clicking the scrollbar thumb should never scroll to
// click.
if (IsEventOverThumb(aEvent)) {
return false;
}
#endif
if (aEvent->mMessage == eTouchStart) {
return GetScrollToClick();
}
WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
if (mouseEvent->mButton == MouseButton::ePrimary) {
#ifdef XP_MACOSX
bool invertPref = mouseEvent->IsAlt();
#else
bool invertPref = mouseEvent->IsShift();
#endif
return GetScrollToClick() != invertPref;
}
#ifdef MOZ_WIDGET_GTK
if (mouseEvent->mButton == MouseButton::eSecondary) {
return !GetScrollToClick();
}
#endif
return true;
}
bool nsSliderFrame::IsEventOverThumb(WidgetGUIEvent* aEvent) {
nsIFrame* thumbFrame = mFrames.FirstChild();
if (!thumbFrame) {
return false;
}
nsPoint eventPoint;
if (!GetEventPoint(aEvent, eventPoint)) {
return false;
}
const nsRect thumbRect = thumbFrame->GetRect();
const bool isHorizontal = Scrollbar()->IsHorizontal();
nscoord eventPos = isHorizontal ? eventPoint.x : eventPoint.y;
nscoord thumbStart = isHorizontal ? thumbRect.x : thumbRect.y;
nscoord thumbEnd = isHorizontal ? thumbRect.XMost() : thumbRect.YMost();
return eventPos >= thumbStart && eventPos < thumbEnd;
}
NS_IMETHODIMP
nsSliderFrame::HandlePress(nsPresContext* aPresContext, WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus) {
if (!ShouldScrollForEvent(aEvent) || ShouldScrollToClickForEvent(aEvent)) {
return NS_OK;
}
if (IsEventOverThumb(aEvent)) {
return NS_OK;
}
nsIFrame* thumbFrame = mFrames.FirstChild();
if (!thumbFrame) { // display:none?
return NS_OK;
}
if (mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
nsGkAtoms::_true, eCaseMatters)) {
return NS_OK;
}
nsRect thumbRect = thumbFrame->GetRect();
nscoord change = 1;
nsPoint eventPoint;
if (!GetEventPoint(aEvent, eventPoint)) {
return NS_OK;
}
if (Scrollbar()->IsHorizontal() ? eventPoint.x < thumbRect.x
: eventPoint.y < thumbRect.y) {
change = -1;
}
mRepeatDirection = change;
DragThumb(true);
if (StaticPrefs::layout_scrollbars_click_and_hold_track_continue_to_end()) {
// Set the destination point to the very end of the scrollbar so that
// scrolling doesn't stop halfway through.
if (change > 0) {
mDestinationPoint = nsPoint(GetRect().width, GetRect().height);
} else {
mDestinationPoint = nsPoint(0, 0);
}
} else {
mDestinationPoint = eventPoint;
}
StartRepeat();
PageScroll(false);
return NS_OK;
}
NS_IMETHODIMP
nsSliderFrame::HandleRelease(nsPresContext* aPresContext,
WidgetGUIEvent* aEvent,
nsEventStatus* aEventStatus) {
StopRepeat();
nsScrollbarFrame* sb = Scrollbar();
if (nsIScrollbarMediator* m = sb->GetScrollbarMediator()) {
m->ScrollbarReleased(sb);
}
return NS_OK;
}
void nsSliderFrame::Destroy(DestroyContext& aContext) {
// tell our mediator if we have one we are gone.
if (mMediator) {
mMediator->SetSlider(nullptr);
mMediator = nullptr;
}
StopRepeat();
// call base class Destroy()
nsContainerFrame::Destroy(aContext);
}
void nsSliderFrame::Notify() {
bool stop = false;
nsIFrame* thumbFrame = mFrames.FirstChild();
if (!thumbFrame) {
StopRepeat();
return;
}
nsRect thumbRect = thumbFrame->GetRect();
const bool isHorizontal = Scrollbar()->IsHorizontal();
// See if the thumb has moved past our destination point.
// if it has we want to stop.
if (isHorizontal) {
if (mRepeatDirection < 0) {
if (thumbRect.x < mDestinationPoint.x) {
stop = true;
}
} else {
if (thumbRect.x + thumbRect.width > mDestinationPoint.x) {
stop = true;
}
}
} else {
if (mRepeatDirection < 0) {
if (thumbRect.y < mDestinationPoint.y) {
stop = true;
}
} else {
if (thumbRect.y + thumbRect.height > mDestinationPoint.y) {
stop = true;
}
}
}
if (stop) {
StopRepeat();
} else {
PageScroll(true);
}
}
void nsSliderFrame::PageScroll(bool aClickAndHold) {
int32_t changeDirection = mRepeatDirection;
if (mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::dir,
nsGkAtoms::reverse, eCaseMatters)) {
changeDirection = -changeDirection;
}
nsScrollbarFrame* sb = Scrollbar();
ScrollContainerFrame* sf = GetScrollContainerFrame();
const ScrollSnapFlags scrollSnapFlags =
ScrollSnapFlags::IntendedDirection | ScrollSnapFlags::IntendedEndPosition;
// If our nsIScrollbarMediator implementation is a ScrollContainerFrame,
// use ScrollTo() to ensure we do not scroll past the intended
// destination. Otherwise, the combination of smooth scrolling and
// ScrollBy() semantics (which adds the delta to the current destination
// if there is a smooth scroll in progress) can lead to scrolling too far
// Only do this when the page scroll is triggered by the repeat timer
// when the mouse is being held down. For multiple clicks in
// succession, we want to make sure we scroll by a full page for
// each click, so we use ScrollByPage().
if (aClickAndHold && sf) {
const bool isHorizontal = sb->IsHorizontal();
nsIFrame* thumbFrame = mFrames.FirstChild();
if (!thumbFrame) {
return;
}
nsRect thumbRect = thumbFrame->GetRect();
nscoord maxDistanceAlongTrack;
if (isHorizontal) {
maxDistanceAlongTrack =
mDestinationPoint.x - thumbRect.x - thumbRect.width / 2;
} else {
maxDistanceAlongTrack =
mDestinationPoint.y - thumbRect.y - thumbRect.height / 2;
}
// Convert distance along scrollbar track to amount of scrolled content.
nscoord maxDistanceToScroll = maxDistanceAlongTrack / GetThumbRatio();
nsIContent* content = sb->GetContent();
const CSSIntCoord pageLength = GetPageIncrement(content);
nsPoint pos = sf->GetScrollPosition();
if (mCurrentClickHoldDestination) {
// We may not have arrived at the destination of the scroll from the
// previous repeat timer tick, some of that scroll may still be pending.
nsPoint pendingScroll =
*mCurrentClickHoldDestination - sf->GetScrollPosition();
// Scroll by one page relative to the previous destination, so that we
// scroll at a rate of a full page per repeat timer tick.
pos += pendingScroll;
// Make a corresponding adjustment to the maxium distance we can scroll,
// so we successfully avoid overshoot.
maxDistanceToScroll -= (isHorizontal ? pendingScroll.x : pendingScroll.y);
}
nscoord distanceToScroll =
std::min(abs(maxDistanceToScroll),
CSSPixel::ToAppUnits(CSSCoord(pageLength))) *
changeDirection;
if (isHorizontal) {
pos.x += distanceToScroll;
} else {
pos.y += distanceToScroll;
}
mCurrentClickHoldDestination = Some(pos);
sf->ScrollTo(pos,
nsLayoutUtils::IsSmoothScrollingEnabled() &&
StaticPrefs::general_smoothScroll_pages()
? ScrollMode::Smooth
: ScrollMode::Instant,
nullptr, scrollSnapFlags);
return;
}
sb->SetIncrementToPage(changeDirection);
if (nsIScrollbarMediator* m = sb->GetScrollbarMediator()) {
m->ScrollByPage(sb, changeDirection, scrollSnapFlags);
return;
}
PageUpDown(changeDirection);
}
void nsSliderFrame::SetupDrag(WidgetGUIEvent* aEvent, nsIFrame* aThumbFrame,
nscoord aPos, bool aIsHorizontal) {
if (aIsHorizontal) {
mThumbStart = aThumbFrame->GetPosition().x;
} else {
mThumbStart = aThumbFrame->GetPosition().y;
}
mDragStart = aPos - mThumbStart;
mScrollingWithAPZ = false;
StartAPZDrag(aEvent); // sets mScrollingWithAPZ=true if appropriate
#ifdef DEBUG_SLIDER
printf("Pressed mDragStart=%d\n", mDragStart);
#endif
if (!mScrollingWithAPZ) {
SuppressDisplayport();
}
}
float nsSliderFrame::GetThumbRatio() const {
// mRatio is in thumb app units per scrolled css pixels. Convert it to a
// ratio of the thumb's CSS pixels per scrolled CSS pixels. (Note the thumb
// is in the scrollframe's parent's space whereas the scrolled CSS pixels
// are in the scrollframe's space).
return mRatio / AppUnitsPerCSSPixel();
}
void nsSliderFrame::AsyncScrollbarDragInitiated(uint64_t aDragBlockId) {
mAPZDragInitiated = Some(aDragBlockId);
}
void nsSliderFrame::AsyncScrollbarDragRejected() {
mScrollingWithAPZ = false;
// Only suppress the displayport if we're still dragging the thumb.
// Otherwise, no one will unsuppress it.
if (IsDraggingThumb()) {
SuppressDisplayport();
}
}
void nsSliderFrame::SuppressDisplayport() {
if (!mSuppressionActive) {
PresShell()->SuppressDisplayport(true);
mSuppressionActive = true;
}
}
void nsSliderFrame::UnsuppressDisplayport() {
if (mSuppressionActive) {
PresShell()->SuppressDisplayport(false);
mSuppressionActive = false;
}
}
bool nsSliderFrame::OnlySystemGroupDispatch(EventMessage aMessage) const {
// If we are in a native anonymous subtree, do not dispatch mouse-move or
// pointer-move events targeted at this slider frame to web content. This
// matches the behaviour of other browsers.
return (aMessage == eMouseMove || aMessage == ePointerMove) &&
IsDraggingThumb() && GetContent()->IsInNativeAnonymousSubtree();
}
bool nsSliderFrame::GetEventPoint(WidgetGUIEvent* aEvent, nsPoint& aPoint) {
LayoutDeviceIntPoint refPoint;
if (!GetEventPoint(aEvent, refPoint)) {
return false;
}
aPoint = nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, refPoint,
RelativeTo{this});
return true;
}
bool nsSliderFrame::GetEventPoint(WidgetGUIEvent* aEvent,
LayoutDeviceIntPoint& aPoint) {
NS_ENSURE_TRUE(aEvent, false);
WidgetTouchEvent* touchEvent = aEvent->AsTouchEvent();
if (touchEvent) {
// return false if there is more than one touch on the page, or if
// we can't find a touch point
if (touchEvent->mTouches.Length() != 1) {
return false;
}
dom::Touch* touch = touchEvent->mTouches.SafeElementAt(0);
if (!touch) {
return false;
}
aPoint = touch->mRefPoint;
} else {
aPoint = aEvent->mRefPoint;
}
return true;
}
NS_IMPL_ISUPPORTS(nsSliderMediator, nsIDOMEventListener)