RenderScrollbarPart.cpp [plain text]
#include "config.h"
#include "RenderScrollbarPart.h"
#include "PaintInfo.h"
#include "RenderScrollbar.h"
#include "RenderScrollbarTheme.h"
#include "RenderView.h"
#include <wtf/StackStats.h>
namespace WebCore {
RenderScrollbarPart::RenderScrollbarPart(Document& document, PassRef<RenderStyle> style, RenderScrollbar* scrollbar, ScrollbarPart part)
: RenderBlock(document, WTF::move(style), 0)
, m_scrollbar(scrollbar)
, m_part(part)
{
}
RenderScrollbarPart::~RenderScrollbarPart()
{
}
void RenderScrollbarPart::layout()
{
StackStats::LayoutCheckPoint layoutCheckPoint;
setLocation(LayoutPoint()); if (m_scrollbar->orientation() == HorizontalScrollbar)
layoutHorizontalPart();
else
layoutVerticalPart();
clearNeedsLayout();
}
void RenderScrollbarPart::layoutHorizontalPart()
{
if (m_part == ScrollbarBGPart) {
setWidth(m_scrollbar->width());
computeScrollbarHeight();
} else {
computeScrollbarWidth();
setHeight(m_scrollbar->height());
}
}
void RenderScrollbarPart::layoutVerticalPart()
{
if (m_part == ScrollbarBGPart) {
computeScrollbarWidth();
setHeight(m_scrollbar->height());
} else {
setWidth(m_scrollbar->width());
computeScrollbarHeight();
}
}
static int calcScrollbarThicknessUsing(SizeType sizeType, const Length& length, int containingLength)
{
if (!length.isIntrinsicOrAuto() || (sizeType == MinSize && length.isAuto()))
return minimumValueForLength(length, containingLength);
return ScrollbarTheme::theme()->scrollbarThickness();
}
void RenderScrollbarPart::computeScrollbarWidth()
{
if (!m_scrollbar->owningRenderer())
return;
int visibleSize = m_scrollbar->owningRenderer()->width() - m_scrollbar->owningRenderer()->style().borderLeftWidth() - m_scrollbar->owningRenderer()->style().borderRightWidth();
int w = calcScrollbarThicknessUsing(MainOrPreferredSize, style().width(), visibleSize);
int minWidth = calcScrollbarThicknessUsing(MinSize, style().minWidth(), visibleSize);
int maxWidth = style().maxWidth().isUndefined() ? w : calcScrollbarThicknessUsing(MaxSize, style().maxWidth(), visibleSize);
setWidth(std::max(minWidth, std::min(maxWidth, w)));
m_marginBox.setLeft(minimumValueForLength(style().marginLeft(), visibleSize));
m_marginBox.setRight(minimumValueForLength(style().marginRight(), visibleSize));
}
void RenderScrollbarPart::computeScrollbarHeight()
{
if (!m_scrollbar->owningRenderer())
return;
int visibleSize = m_scrollbar->owningRenderer()->height() - m_scrollbar->owningRenderer()->style().borderTopWidth() - m_scrollbar->owningRenderer()->style().borderBottomWidth();
int h = calcScrollbarThicknessUsing(MainOrPreferredSize, style().height(), visibleSize);
int minHeight = calcScrollbarThicknessUsing(MinSize, style().minHeight(), visibleSize);
int maxHeight = style().maxHeight().isUndefined() ? h : calcScrollbarThicknessUsing(MaxSize, style().maxHeight(), visibleSize);
setHeight(std::max(minHeight, std::min(maxHeight, h)));
m_marginBox.setTop(minimumValueForLength(style().marginTop(), visibleSize));
m_marginBox.setBottom(minimumValueForLength(style().marginBottom(), visibleSize));
}
void RenderScrollbarPart::computePreferredLogicalWidths()
{
if (!preferredLogicalWidthsDirty())
return;
m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = 0;
setPreferredLogicalWidthsDirty(false);
}
void RenderScrollbarPart::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
RenderBlock::styleDidChange(diff, oldStyle);
setInline(false);
clearPositionedState();
setFloating(false);
setHasOverflowClip(false);
if (oldStyle && m_scrollbar && m_part != NoPart && diff >= StyleDifferenceRepaint)
m_scrollbar->theme()->invalidatePart(m_scrollbar, m_part);
}
void RenderScrollbarPart::imageChanged(WrappedImagePtr image, const IntRect* rect)
{
if (m_scrollbar && m_part != NoPart)
m_scrollbar->theme()->invalidatePart(m_scrollbar, m_part);
else {
if (view().frameView().isFrameViewScrollCorner(this)) {
view().frameView().invalidateScrollCorner(view().frameView().scrollCornerRect());
return;
}
RenderBlock::imageChanged(image, rect);
}
}
void RenderScrollbarPart::paintIntoRect(GraphicsContext* graphicsContext, const LayoutPoint& paintOffset, const LayoutRect& rect)
{
setLocation(rect.location() - toLayoutSize(paintOffset));
setWidth(rect.width());
setHeight(rect.height());
if (graphicsContext->paintingDisabled() || !style().opacity())
return;
bool needsTransparencyLayer = m_part != ScrollbarBGPart && style().opacity() < 1;
if (needsTransparencyLayer) {
graphicsContext->save();
graphicsContext->clip(rect);
graphicsContext->beginTransparencyLayer(style().opacity());
}
PaintInfo paintInfo(graphicsContext, pixelSnappedIntRect(rect), PaintPhaseBlockBackground, PaintBehaviorNormal);
paint(paintInfo, paintOffset);
paintInfo.phase = PaintPhaseChildBlockBackgrounds;
paint(paintInfo, paintOffset);
paintInfo.phase = PaintPhaseFloat;
paint(paintInfo, paintOffset);
paintInfo.phase = PaintPhaseForeground;
paint(paintInfo, paintOffset);
paintInfo.phase = PaintPhaseOutline;
paint(paintInfo, paintOffset);
if (needsTransparencyLayer) {
graphicsContext->endTransparencyLayer();
graphicsContext->restore();
}
}
RenderBox* RenderScrollbarPart::rendererOwningScrollbar() const
{
if (!m_scrollbar)
return nullptr;
return m_scrollbar->owningRenderer();
}
}