blob: 4091d5124b6a9c27ee9af7176fbd13ab8ffa7726 [file] [log] [blame]
/*
* Copyright (C) 2008, 2009 Apple Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "RenderScrollbar.h"
#include "Frame.h"
#include "FrameView.h"
#include "RenderPart.h"
#include "RenderScrollbarPart.h"
#include "RenderScrollbarTheme.h"
namespace WebCore {
PassRefPtr<Scrollbar> RenderScrollbar::createCustomScrollbar(ScrollableArea* scrollableArea, ScrollbarOrientation orientation, RenderBox* renderer, Frame* owningFrame)
{
return adoptRef(new RenderScrollbar(scrollableArea, orientation, renderer, owningFrame));
}
RenderScrollbar::RenderScrollbar(ScrollableArea* scrollableArea, ScrollbarOrientation orientation, RenderBox* renderer, Frame* owningFrame)
: Scrollbar(scrollableArea, orientation, RegularScrollbar, RenderScrollbarTheme::renderScrollbarTheme())
, m_owner(renderer)
, m_owningFrame(owningFrame)
{
// FIXME: We need to do this because RenderScrollbar::styleChanged is called as soon as the scrollbar is created.
// Update the scrollbar size.
int width = 0;
int height = 0;
updateScrollbarPart(ScrollbarBGPart);
if (RenderScrollbarPart* part = m_parts.get(ScrollbarBGPart)) {
part->layout();
width = part->width();
height = part->height();
} else if (this->orientation() == HorizontalScrollbar)
width = this->width();
else
height = this->height();
setFrameRect(IntRect(0, 0, width, height));
}
RenderScrollbar::~RenderScrollbar()
{
ASSERT(m_parts.isEmpty());
}
RenderBox* RenderScrollbar::owningRenderer() const
{
if (m_owningFrame) {
RenderBox* currentRenderer = m_owningFrame->ownerRenderer();
return currentRenderer;
}
return m_owner;
}
void RenderScrollbar::setParent(ScrollView* parent)
{
Scrollbar::setParent(parent);
if (!parent) {
// Destroy all of the scrollbar's RenderBoxes.
updateScrollbarParts(true);
}
}
void RenderScrollbar::setEnabled(bool e)
{
bool wasEnabled = enabled();
Scrollbar::setEnabled(e);
if (wasEnabled != e)
updateScrollbarParts();
}
void RenderScrollbar::styleChanged()
{
updateScrollbarParts();
}
void RenderScrollbar::paint(GraphicsContext* context, const IntRect& damageRect)
{
if (context->updatingControlTints()) {
updateScrollbarParts();
return;
}
Scrollbar::paint(context, damageRect);
}
void RenderScrollbar::setHoveredPart(ScrollbarPart part)
{
if (part == m_hoveredPart)
return;
ScrollbarPart oldPart = m_hoveredPart;
m_hoveredPart = part;
updateScrollbarPart(oldPart);
updateScrollbarPart(m_hoveredPart);
updateScrollbarPart(ScrollbarBGPart);
updateScrollbarPart(TrackBGPart);
}
void RenderScrollbar::setPressedPart(ScrollbarPart part)
{
ScrollbarPart oldPart = m_pressedPart;
Scrollbar::setPressedPart(part);
updateScrollbarPart(oldPart);
updateScrollbarPart(part);
updateScrollbarPart(ScrollbarBGPart);
updateScrollbarPart(TrackBGPart);
}
static ScrollbarPart s_styleResolvePart;
static RenderScrollbar* s_styleResolveScrollbar;
RenderScrollbar* RenderScrollbar::scrollbarForStyleResolve()
{
return s_styleResolveScrollbar;
}
ScrollbarPart RenderScrollbar::partForStyleResolve()
{
return s_styleResolvePart;
}
PassRefPtr<RenderStyle> RenderScrollbar::getScrollbarPseudoStyle(ScrollbarPart partType, PseudoId pseudoId)
{
if (!m_owner)
return 0;
s_styleResolvePart = partType;
s_styleResolveScrollbar = this;
RefPtr<RenderStyle> result = owningRenderer()->getUncachedPseudoStyle(pseudoId, owningRenderer()->style());
s_styleResolvePart = NoPart;
s_styleResolveScrollbar = 0;
// Scrollbars for root frames should always have background color
// unless explicitly specified as transparent. So we force it.
// This is because WebKit assumes scrollbar to be always painted and missing background
// causes visual artifact like non-repainted dirty region.
if (result && m_owningFrame && m_owningFrame->view() && !m_owningFrame->view()->isTransparent() && !result->hasBackground())
result->setBackgroundColor(Color::white);
return result;
}
void RenderScrollbar::updateScrollbarParts(bool destroy)
{
updateScrollbarPart(ScrollbarBGPart, destroy);
updateScrollbarPart(BackButtonStartPart, destroy);
updateScrollbarPart(ForwardButtonStartPart, destroy);
updateScrollbarPart(BackTrackPart, destroy);
updateScrollbarPart(ThumbPart, destroy);
updateScrollbarPart(ForwardTrackPart, destroy);
updateScrollbarPart(BackButtonEndPart, destroy);
updateScrollbarPart(ForwardButtonEndPart, destroy);
updateScrollbarPart(TrackBGPart, destroy);
if (destroy)
return;
// See if the scrollbar's thickness changed. If so, we need to mark our owning object as needing a layout.
bool isHorizontal = orientation() == HorizontalScrollbar;
int oldThickness = isHorizontal ? height() : width();
int newThickness = 0;
RenderScrollbarPart* part = m_parts.get(ScrollbarBGPart);
if (part) {
part->layout();
newThickness = isHorizontal ? part->height() : part->width();
}
if (newThickness != oldThickness) {
setFrameRect(IntRect(x(), y(), isHorizontal ? width() : newThickness, isHorizontal ? newThickness : height()));
owningRenderer()->setChildNeedsLayout(true);
}
}
static PseudoId pseudoForScrollbarPart(ScrollbarPart part)
{
switch (part) {
case BackButtonStartPart:
case ForwardButtonStartPart:
case BackButtonEndPart:
case ForwardButtonEndPart:
return SCROLLBAR_BUTTON;
case BackTrackPart:
case ForwardTrackPart:
return SCROLLBAR_TRACK_PIECE;
case ThumbPart:
return SCROLLBAR_THUMB;
case TrackBGPart:
return SCROLLBAR_TRACK;
case ScrollbarBGPart:
return SCROLLBAR;
case NoPart:
case AllParts:
break;
}
ASSERT_NOT_REACHED();
return SCROLLBAR;
}
void RenderScrollbar::updateScrollbarPart(ScrollbarPart partType, bool destroy)
{
if (partType == NoPart)
return;
RefPtr<RenderStyle> partStyle = !destroy ? getScrollbarPseudoStyle(partType, pseudoForScrollbarPart(partType)) : 0;
bool needRenderer = !destroy && partStyle && partStyle->display() != NONE && partStyle->visibility() == VISIBLE;
if (needRenderer && partStyle->display() != BLOCK) {
// See if we are a button that should not be visible according to OS settings.
ScrollbarButtonsPlacement buttonsPlacement = theme()->buttonsPlacement();
switch (partType) {
case BackButtonStartPart:
needRenderer = (buttonsPlacement == ScrollbarButtonsSingle || buttonsPlacement == ScrollbarButtonsDoubleStart ||
buttonsPlacement == ScrollbarButtonsDoubleBoth);
break;
case ForwardButtonStartPart:
needRenderer = (buttonsPlacement == ScrollbarButtonsDoubleStart || buttonsPlacement == ScrollbarButtonsDoubleBoth);
break;
case BackButtonEndPart:
needRenderer = (buttonsPlacement == ScrollbarButtonsDoubleEnd || buttonsPlacement == ScrollbarButtonsDoubleBoth);
break;
case ForwardButtonEndPart:
needRenderer = (buttonsPlacement == ScrollbarButtonsSingle || buttonsPlacement == ScrollbarButtonsDoubleEnd ||
buttonsPlacement == ScrollbarButtonsDoubleBoth);
break;
default:
break;
}
}
RenderScrollbarPart* partRenderer = m_parts.get(partType);
if (!partRenderer && needRenderer) {
partRenderer = new (owningRenderer()->renderArena()) RenderScrollbarPart(owningRenderer()->document(), this, partType);
m_parts.set(partType, partRenderer);
} else if (partRenderer && !needRenderer) {
m_parts.remove(partType);
partRenderer->destroy();
partRenderer = 0;
}
if (partRenderer)
partRenderer->setStyle(partStyle.release());
}
void RenderScrollbar::paintPart(GraphicsContext* graphicsContext, ScrollbarPart partType, const IntRect& rect)
{
RenderScrollbarPart* partRenderer = m_parts.get(partType);
if (!partRenderer)
return;
partRenderer->paintIntoRect(graphicsContext, x(), y(), rect);
}
IntRect RenderScrollbar::buttonRect(ScrollbarPart partType)
{
RenderScrollbarPart* partRenderer = m_parts.get(partType);
if (!partRenderer)
return IntRect();
partRenderer->layout();
bool isHorizontal = orientation() == HorizontalScrollbar;
if (partType == BackButtonStartPart)
return IntRect(x(), y(), isHorizontal ? partRenderer->width() : width(), isHorizontal ? height() : partRenderer->height());
if (partType == ForwardButtonEndPart)
return IntRect(isHorizontal ? x() + width() - partRenderer->width() : x(),
isHorizontal ? y() : y() + height() - partRenderer->height(),
isHorizontal ? partRenderer->width() : width(),
isHorizontal ? height() : partRenderer->height());
if (partType == ForwardButtonStartPart) {
IntRect previousButton = buttonRect(BackButtonStartPart);
return IntRect(isHorizontal ? x() + previousButton.width() : x(),
isHorizontal ? y() : y() + previousButton.height(),
isHorizontal ? partRenderer->width() : width(),
isHorizontal ? height() : partRenderer->height());
}
IntRect followingButton = buttonRect(ForwardButtonEndPart);
return IntRect(isHorizontal ? x() + width() - followingButton.width() - partRenderer->width() : x(),
isHorizontal ? y() : y() + height() - followingButton.height() - partRenderer->height(),
isHorizontal ? partRenderer->width() : width(),
isHorizontal ? height() : partRenderer->height());
}
IntRect RenderScrollbar::trackRect(int startLength, int endLength)
{
RenderScrollbarPart* part = m_parts.get(TrackBGPart);
if (part)
part->layout();
if (orientation() == HorizontalScrollbar) {
int marginLeft = part ? part->marginLeft() : 0;
int marginRight = part ? part->marginRight() : 0;
startLength += marginLeft;
endLength += marginRight;
int totalLength = startLength + endLength;
return IntRect(x() + startLength, y(), width() - totalLength, height());
}
int marginTop = part ? part->marginTop() : 0;
int marginBottom = part ? part->marginBottom() : 0;
startLength += marginTop;
endLength += marginBottom;
int totalLength = startLength + endLength;
return IntRect(x(), y() + startLength, width(), height() - totalLength);
}
IntRect RenderScrollbar::trackPieceRectWithMargins(ScrollbarPart partType, const IntRect& oldRect)
{
RenderScrollbarPart* partRenderer = m_parts.get(partType);
if (!partRenderer)
return oldRect;
partRenderer->layout();
IntRect rect = oldRect;
if (orientation() == HorizontalScrollbar) {
rect.setX(rect.x() + partRenderer->marginLeft());
rect.setWidth(rect.width() - (partRenderer->marginLeft() + partRenderer->marginRight()));
} else {
rect.setY(rect.y() + partRenderer->marginTop());
rect.setHeight(rect.height() - (partRenderer->marginTop() + partRenderer->marginBottom()));
}
return rect;
}
int RenderScrollbar::minimumThumbLength()
{
RenderScrollbarPart* partRenderer = m_parts.get(ThumbPart);
if (!partRenderer)
return 0;
partRenderer->layout();
return orientation() == HorizontalScrollbar ? partRenderer->width() : partRenderer->height();
}
}