IntSize ScrollbarThemeChromiumWin::buttonSize(ScrollbarThemeClient* scrollbar)
{
// Our desired rect is essentially thickness by thickness.
// Our actual rect will shrink to half the available space when we have < 2
// times thickness pixels left. This allows the scrollbar to scale down
// and function even at tiny sizes.
int thickness = scrollbarThickness(scrollbar->controlSize());
// In layout test mode, we force the button "girth" (i.e., the length of
// the button along the axis of the scrollbar) to be a fixed size.
// FIXME: This is retarded! scrollbarThickness is already fixed in layout
// test mode so that should be enough to result in repeatable results, but
// preserving this hack avoids having to rebaseline pixel tests.
const int kLayoutTestModeGirth = 17;
int girth = isRunningLayoutTest() ? kLayoutTestModeGirth : thickness;
if (scrollbar->orientation() == HorizontalScrollbar) {
int width = scrollbar->width() < 2 * girth ? scrollbar->width() / 2 : girth;
return IntSize(width, thickness);
}
int height = scrollbar->height() < 2 * girth ? scrollbar->height() / 2 : girth;
return IntSize(thickness, height);
}
void LayoutTextControl::computeLogicalHeight(
LayoutUnit logicalHeight,
LayoutUnit logicalTop,
LogicalExtentComputedValues& computedValues) const {
HTMLElement* innerEditor = innerEditorElement();
ASSERT(innerEditor);
if (LayoutBox* innerEditorBox = innerEditor->layoutBox()) {
LayoutUnit nonContentHeight = innerEditorBox->borderAndPaddingHeight() +
innerEditorBox->marginHeight();
logicalHeight = computeControlLogicalHeight(
innerEditorBox->lineHeight(true, HorizontalLine,
PositionOfInteriorLineBoxes),
nonContentHeight);
// We are able to have a horizontal scrollbar if the overflow style is
// scroll, or if its auto and there's no word wrap.
if (style()->overflowInlineDirection() == OverflowScroll ||
(style()->overflowInlineDirection() == OverflowAuto &&
innerEditor->layoutObject()->style()->overflowWrap() ==
NormalOverflowWrap))
logicalHeight += scrollbarThickness();
// FIXME: The logical height of the inner text box should have been added
// before calling computeLogicalHeight to avoid this hack.
setIntrinsicContentLogicalHeight(logicalHeight);
logicalHeight += borderAndPaddingHeight();
}
LayoutBox::computeLogicalHeight(logicalHeight, logicalTop, computedValues);
}
IntRect ScrollbarThemeGtk::trackRect(Scrollbar* scrollbar, bool)
{
// The padding along the thumb movement axis (from outside to in)
// is the size of trough border plus the size of the stepper (button)
// plus the size of stepper spacing (the space between the stepper and
// the place where the thumb stops). There is often no stepper spacing.
int movementAxisPadding = m_troughBorderWidth + m_stepperSize + m_stepperSpacing;
// The fatness of the scrollbar on the non-movement axis.
int thickness = scrollbarThickness(scrollbar->controlSize());
int alternateButtonOffset = 0;
int alternateButtonWidth = 0;
if (m_hasForwardButtonStartPart) {
alternateButtonOffset += m_stepperSize;
alternateButtonWidth += m_stepperSize;
}
if (m_hasBackButtonEndPart)
alternateButtonWidth += m_stepperSize;
if (scrollbar->orientation() == HorizontalScrollbar) {
// Once the scrollbar becomes smaller than the natural size of the
// two buttons, the track disappears.
if (scrollbar->width() < 2 * thickness)
return IntRect();
return IntRect(scrollbar->x() + movementAxisPadding + alternateButtonOffset, scrollbar->y(),
scrollbar->width() - (2 * movementAxisPadding) - alternateButtonWidth, thickness);
}
if (scrollbar->height() < 2 * thickness)
return IntRect();
return IntRect(scrollbar->x(), scrollbar->y() + movementAxisPadding + alternateButtonOffset,
thickness, scrollbar->height() - (2 * movementAxisPadding) - alternateButtonWidth);
}
IntRect ScrollbarThemeHaiku::trackRect(Scrollbar* scrollbar, bool)
{
int thickness = scrollbarThickness();
if (scrollbar->orientation() == HorizontalScrollbar) {
if (scrollbar->width() < 2 * thickness)
return IntRect();
return IntRect(scrollbar->x() + thickness, scrollbar->y(), scrollbar->width() - 2 * thickness, thickness);
}
if (scrollbar->height() < 2 * thickness)
return IntRect();
return IntRect(scrollbar->x(), scrollbar->y() + thickness, thickness, scrollbar->height() - 2 * thickness);
}
IntRect ScrollbarThemeHaiku::forwardButtonRect(Scrollbar* scrollbar, ScrollbarPart part, bool)
{
if (part == BackButtonStartPart)
return IntRect();
int thickness = scrollbarThickness();
if (scrollbar->orientation() == HorizontalScrollbar) {
int width = buttonWidth(scrollbar->width(), thickness);
return IntRect(scrollbar->x() + scrollbar->width() - width, scrollbar->y(), width, thickness);
}
int height = buttonWidth(scrollbar->height(), thickness);
return IntRect(scrollbar->x(), scrollbar->y() + scrollbar->height() - height, thickness, height);
}
void RenderTextControl::computeLogicalHeight()
{
HTMLElement* innerText = innerTextElement();
ASSERT(innerText);
RenderBox* innerTextBox = innerText->renderBox();
LayoutUnit nonContentHeight = innerTextBox->borderAndPaddingHeight() + innerTextBox->marginHeight();
setHeight(computeControlHeight(innerTextBox->lineHeight(true, HorizontalLine, PositionOfInteriorLineBoxes), nonContentHeight) + borderAndPaddingHeight());
// We are able to have a horizontal scrollbar if the overflow style is scroll, or if its auto and there's no word wrap.
if (style()->overflowX() == OSCROLL || (style()->overflowX() == OAUTO && innerText->renderer()->style()->wordWrap() == NormalWordWrap))
setHeight(height() + scrollbarThickness());
RenderBlock::computeLogicalHeight();
}
IntRect ScrollbarThemeHaiku::backButtonRect(Scrollbar* scrollbar, ScrollbarPart part, bool)
{
if (part == BackButtonEndPart)
return IntRect();
int thickness = scrollbarThickness();
IntPoint buttonOrigin(scrollbar->x(), scrollbar->y());
IntSize buttonSize = scrollbar->orientation() == HorizontalScrollbar
? IntSize(buttonWidth(scrollbar->width(), thickness), thickness)
: IntSize(thickness, buttonWidth(scrollbar->height(), thickness));
IntRect buttonRect(buttonOrigin, buttonSize);
return buttonRect;
}
IntRect ScrollbarThemeChromium::trackRect(ScrollbarThemeClient* scrollbar, bool)
{
IntSize bs = buttonSize(scrollbar);
int thickness = scrollbarThickness(scrollbar->controlSize());
if (scrollbar->orientation() == HorizontalScrollbar) {
// Once the scrollbar becomes smaller than the size of the
// two buttons with a 1 pixel gap, the track disappears.
if (scrollbar->width() <= 2 * bs.width() + 1)
return IntRect();
return IntRect(scrollbar->x() + bs.width(), scrollbar->y(), scrollbar->width() - 2 * bs.width(), thickness);
}
if (scrollbar->height() <= 2 * bs.height() + 1)
return IntRect();
return IntRect(scrollbar->x(), scrollbar->y() + bs.height(), thickness, scrollbar->height() - 2 * bs.height());
}
void RenderTextControl::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
{
HTMLElement* innerText = innerTextElement();
ASSERT(innerText);
if (RenderBox* innerTextBox = innerText->renderBox()) {
LayoutUnit nonContentHeight = innerTextBox->borderAndPaddingHeight() + innerTextBox->marginHeight();
logicalHeight = computeControlHeight(innerTextBox->lineHeight(true, HorizontalLine, PositionOfInteriorLineBoxes), nonContentHeight) + borderAndPaddingHeight();
// We are able to have a horizontal scrollbar if the overflow style is scroll, or if its auto and there's no word wrap.
if (style()->overflowX() == OSCROLL || (style()->overflowX() == OAUTO && innerText->renderer()->style()->overflowWrap() == NormalOverflowWrap))
logicalHeight += scrollbarThickness();
}
RenderBox::computeLogicalHeight(logicalHeight, logicalTop, computedValues);
}
IntRect ScrollbarThemeBal::backButtonRect(Scrollbar* scrollbar, ScrollbarPart part, bool)
{
if (part == BackButtonEndPart)
return IntRect();
// Our desired rect is essentially 17x17.
// Our actual rect will shrink to half the available space when
// we have < 34 pixels left. This allows the scrollbar
// to scale down and function even at tiny sizes.
int thickness = scrollbarThickness();
if (scrollbar->orientation() == HorizontalScrollbar)
return IntRect(scrollbar->x(), scrollbar->y(),
scrollbar->width() < 2 * thickness ? scrollbar->width() / 2 : thickness, thickness);
return IntRect(scrollbar->x(), scrollbar->y(),
thickness, scrollbar->height() < 2 * thickness ? scrollbar->height() / 2 : thickness);
}
bool ScrollbarThemeChromiumWin::shouldSnapBackToDragOrigin(ScrollbarThemeClient* scrollbar, const PlatformMouseEvent& evt)
{
// Find the rect within which we shouldn't snap, by expanding the track rect
// in both dimensions.
IntRect rect = trackRect(scrollbar);
const bool horz = scrollbar->orientation() == HorizontalScrollbar;
const int thickness = scrollbarThickness(scrollbar->controlSize());
rect.inflateX((horz ? kOffEndMultiplier : kOffSideMultiplier) * thickness);
rect.inflateY((horz ? kOffSideMultiplier : kOffEndMultiplier) * thickness);
// Convert the event to local coordinates.
IntPoint mousePosition = scrollbar->convertFromContainingWindow(evt.position());
mousePosition.move(scrollbar->x(), scrollbar->y());
// We should snap iff the event is outside our calculated rect.
return !rect.contains(mousePosition);
}
IntRect ScrollbarThemeChromium::trackRect(Scrollbar* scrollbar, bool)
{
IntSize bs = buttonSize(scrollbar);
// The buttons at the top and bottom of the scrollbar are square, so the
// thickness of the scrollbar is also their height.
int thickness = scrollbarThickness(scrollbar->controlSize());
if (scrollbar->orientation() == HorizontalScrollbar) {
// Once the scrollbar becomes smaller than the natural size of the
// two buttons, the track disappears.
if (scrollbar->width() < 2 * thickness)
return IntRect();
return IntRect(scrollbar->x() + bs.width(), scrollbar->y(), scrollbar->width() - 2 * bs.width(), thickness);
}
if (scrollbar->height() < 2 * thickness)
return IntRect();
return IntRect(scrollbar->x(), scrollbar->y() + bs.height(), thickness, scrollbar->height() - 2 * bs.height());
}
IntRect ScrollbarThemeGtk::trackRect(ScrollbarThemeClient* scrollbar, bool)
{
#ifndef GTK_API_VERSION_2
// The padding along the thumb movement axis includes the trough border
// plus the size of stepper spacing (the space between the stepper and
// the place where the thumb stops). There is often no stepper spacing.
int movementAxisPadding = m_troughBorderWidth + m_stepperSpacing;
// The fatness of the scrollbar on the non-movement axis.
int thickness = scrollbarThickness(scrollbar->controlSize());
int startButtonsOffset = 0;
int buttonsWidth = 0;
if (m_hasForwardButtonStartPart) {
startButtonsOffset += m_stepperSize;
buttonsWidth += m_stepperSize;
}
if (m_hasBackButtonStartPart) {
startButtonsOffset += m_stepperSize;
buttonsWidth += m_stepperSize;
}
if (m_hasBackButtonEndPart)
buttonsWidth += m_stepperSize;
if (m_hasForwardButtonEndPart)
buttonsWidth += m_stepperSize;
if (scrollbar->orientation() == HorizontalScrollbar) {
// Once the scrollbar becomes smaller than the natural size of the
// two buttons, the track disappears.
if (scrollbar->width() < 2 * thickness)
return IntRect();
return IntRect(scrollbar->x() + movementAxisPadding + startButtonsOffset, scrollbar->y(),
scrollbar->width() - (2 * movementAxisPadding) - buttonsWidth, thickness);
}
if (scrollbar->height() < 2 * thickness)
return IntRect();
return IntRect(scrollbar->x(), scrollbar->y() + movementAxisPadding + startButtonsOffset,
thickness, scrollbar->height() - (2 * movementAxisPadding) - buttonsWidth);
#else
UNUSED_PARAM(scrollbar);
return IntRect();
#endif
}
void ScrollbarThemeGtk::updateScrollbarsFrameThickness()
{
if (scrollbarMap().isEmpty())
return;
// Update the thickness of every interior frame scrollbar widget. The
// platform-independent scrollbar them code isn't yet smart enough to get
// this information when it paints.
for (const auto& scrollbar : scrollbarMap()) {
// Top-level scrollbar i.e. scrollbars who have a parent ScrollView
// with no parent are native, and thus do not need to be resized.
if (!scrollbar->parent() || !scrollbar->parent()->parent())
return;
int thickness = scrollbarThickness(scrollbar->controlSize());
if (scrollbar->orientation() == HorizontalScrollbar)
scrollbar->setFrameRect(IntRect(0, scrollbar->parent()->height() - thickness, scrollbar->width(), thickness));
else
scrollbar->setFrameRect(IntRect(scrollbar->parent()->width() - thickness, 0, thickness, scrollbar->height()));
}
}
void RenderTextControl::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
{
HTMLElement* innerEditor = innerEditorElement();
ASSERT(innerEditor);
if (RenderBox* innerEditorBox = innerEditor->renderBox()) {
LayoutUnit nonContentHeight = innerEditorBox->borderAndPaddingHeight() + innerEditorBox->marginHeight();
logicalHeight = computeControlLogicalHeight(innerEditorBox->lineHeight(true, HorizontalLine, PositionOfInteriorLineBoxes), nonContentHeight);
// We are able to have a horizontal scrollbar if the overflow style is scroll, or if its auto and there's no word wrap.
if ((isHorizontalWritingMode() && (style()->overflowX() == OSCROLL || (style()->overflowX() == OAUTO && innerEditor->renderer()->style()->overflowWrap() == NormalOverflowWrap)))
|| (!isHorizontalWritingMode() && (style()->overflowY() == OSCROLL || (style()->overflowY() == OAUTO && innerEditor->renderer()->style()->overflowWrap() == NormalOverflowWrap))))
logicalHeight += scrollbarThickness();
// FIXME: The logical height of the inner text box should have been added before calling computeLogicalHeight to
// avoid this hack.
updateIntrinsicContentLogicalHeight(logicalHeight);
logicalHeight += borderAndPaddingHeight();
}
RenderBox::computeLogicalHeight(logicalHeight, logicalTop, computedValues);
}
IntRect ScrollbarThemeWx::trackRect(Scrollbar* scrollbar, bool)
{
IntSize bs = buttonSize(scrollbar);
int trackStart = 0;
if (scrollbar->orientation() == HorizontalScrollbar)
trackStart = bs.width();
else
trackStart = bs.height();
#if __WXMAC__
trackStart = 0;
#endif
int thickness = scrollbarThickness(scrollbar->controlSize());
if (scrollbar->orientation() == HorizontalScrollbar) {
if (scrollbar->width() < 2 * thickness)
return IntRect();
return IntRect(scrollbar->x() + trackStart, scrollbar->y(), scrollbar->width() - 2 * bs.width(), thickness);
}
if (scrollbar->height() < 2 * thickness)
return IntRect();
return IntRect(scrollbar->x(), scrollbar->y() + trackStart, thickness, scrollbar->height() - 2 * bs.height());
}
void ScrollbarThemeGtk::updateThemeProperties()
{
MozGtkScrollbarMetrics metrics;
moz_gtk_get_scrollbar_metrics(&metrics);
m_thumbFatness = metrics.slider_width;
m_troughBorderWidth = metrics.trough_border;
m_stepperSize = metrics.stepper_size;
m_stepperSpacing = metrics.stepper_spacing;
m_minThumbLength = metrics.min_slider_size;
m_troughUnderSteppers = metrics.trough_under_steppers;
m_hasForwardButtonStartPart = metrics.has_secondary_forward_stepper;
m_hasBackButtonEndPart = metrics.has_secondary_backward_stepper;
if (!gScrollbars)
return;
// Update the thickness of every interior frame scrollbar widget. The
// platform-independent scrollbar them code isn't yet smart enough to get
// this information when it paints.
HashSet<Scrollbar*>::iterator end = gScrollbars->end();
for (HashSet<Scrollbar*>::iterator it = gScrollbars->begin(); it != end; ++it) {
Scrollbar* scrollbar = (*it);
// Top-level scrollbar i.e. scrollbars who have a parent ScrollView
// with no parent are native, and thus do not need to be resized.
if (!scrollbar->parent() || !scrollbar->parent()->parent())
return;
int thickness = scrollbarThickness(scrollbar->controlSize());
if (scrollbar->orientation() == HorizontalScrollbar)
scrollbar->setFrameRect(IntRect(0, scrollbar->parent()->height() - thickness, scrollbar->width(), thickness));
else
scrollbar->setFrameRect(IntRect(scrollbar->parent()->width() - thickness, 0, thickness, scrollbar->height()));
}
}
Scrollbar::Scrollbar(ScrollableArea* scrollableArea, ScrollbarOrientation orientation)
: m_scrollableArea(scrollableArea)
, m_orientation(orientation)
, m_visibleSize(0)
, m_totalSize(0)
, m_currentPos(0)
, m_dragOrigin(0)
, m_hoveredPart(NoPart)
, m_pressedPart(NoPart)
, m_pressedPos(0)
, m_scrollPos(0)
, m_documentDragPos(0)
, m_enabled(true)
, m_scrollTimer(this, &Scrollbar::autoscrollTimerFired)
, m_overlapsResizer(false)
{
// FIXME: This is ugly and would not be necessary if we fix cross-platform code to actually query for
// scrollbar thickness and use it when sizing scrollbars (rather than leaving one dimension of the scrollbar
// alone when sizing).
int thickness = scrollbarThickness();
Widget::setFrameRect(IntRect(0, 0, thickness, thickness));
m_currentPos = scrollableAreaCurrentPos();
}
int RenderTextControlMultiLine::preferredContentWidth(float charWidth) const
{
int factor = static_cast<HTMLTextAreaElement*>(node())->cols();
return static_cast<int>(ceilf(charWidth * factor)) + scrollbarThickness();
}
int ScrollbarTheme::minimumThumbLength(const ScrollbarThemeClient* scrollbar)
{
return scrollbarThickness(scrollbar->controlSize());
}
int ScrollbarThemeComposite::minimumThumbLength(Scrollbar* scrollbar)
{
return scrollbarThickness(scrollbar->controlSize());
}
int Scrollbar::minimumThumbLength()
{
return scrollbarThickness();
}
int ScrollbarThemeChromiumLinux::minimumThumbLength(Scrollbar* scrollbar)
{
// This matches Firefox on Linux.
return 2 * scrollbarThickness(scrollbar->controlSize());
}
LayoutUnit RenderTextControlMultiLine::preferredContentLogicalWidth(float charWidth) const
{
return ceilf(charWidth * textAreaElement().cols()) + scrollbarThickness();
}
LayoutUnit RenderTextControlMultiLine::preferredContentLogicalWidth(float charWidth) const
{
int factor = toHTMLTextAreaElement(node())->cols();
return static_cast<LayoutUnit>(ceilf(charWidth * factor)) + scrollbarThickness();
}