Region CCTiledLayerImpl::visibleContentOpaqueRegion() const
{
if (m_skipsDraw)
return Region();
if (opaque())
return visibleContentRect();
return m_tiler->opaqueRegionInContentRect(visibleContentRect());
}
IntRect FrameView::windowClipRect() const
{
ASSERT(m_frame->view() == this);
if (paintsEntireContents())
return IntRect(IntPoint(), size());
// Set our clip rect to be our contents.
IntRect clipRect = contentsToWindow(visibleContentRect());
return clipRect;
}
IntRect FramelessScrollView::windowClipRect(bool clipToContents) const
{
return contentsToWindow(visibleContentRect(clipToContents ? ExcludeScrollbars : IncludeScrollbars));
}
IntRect FramelessScrollView::windowClipRect(bool clipToContents) const
{
return contentsToWindow(visibleContentRect(!clipToContents));
}
IntPoint ScrollableArea::constrainScrollPositionForOverhang(const IntPoint& scrollPosition)
{
return constrainScrollPositionForOverhang(visibleContentRect(), totalContentsSize(), scrollPosition, scrollOrigin(), headerHeight(), footerHeight());
}
FloatRect ScrollView::visibleContentRectConsideringExternalScrollers() const
{
// FIXME: clip this rect if parent scroll views cut off the visible
// area.
return visibleContentRect();
}
void CCTiledLayerImpl::appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData)
{
const IntRect& contentRect = visibleContentRect();
if (!m_tiler || m_tiler->hasEmptyBounds() || contentRect.isEmpty())
return;
CCSharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
int left, top, right, bottom;
m_tiler->contentRectToTileIndices(contentRect, left, top, right, bottom);
if (hasDebugBorders()) {
for (int j = top; j <= bottom; ++j) {
for (int i = left; i <= right; ++i) {
DrawableTile* tile = tileAt(i, j);
IntRect tileRect = m_tiler->tileBounds(i, j);
SkColor borderColor;
if (m_skipsDraw || !tile || !tile->resourceId())
borderColor = SkColorSetARGB(debugTileBorderAlpha, debugTileBorderMissingTileColorRed, debugTileBorderMissingTileColorGreen, debugTileBorderMissingTileColorBlue);
else
borderColor = SkColorSetARGB(debugTileBorderAlpha, debugTileBorderColorRed, debugTileBorderColorGreen, debugTileBorderColorBlue);
quadSink.append(CCDebugBorderDrawQuad::create(sharedQuadState, tileRect, borderColor, debugTileBorderWidth).PassAs<CCDrawQuad>(), appendQuadsData);
}
}
}
if (m_skipsDraw)
return;
for (int j = top; j <= bottom; ++j) {
for (int i = left; i <= right; ++i) {
DrawableTile* tile = tileAt(i, j);
IntRect tileRect = m_tiler->tileBounds(i, j);
IntRect displayRect = tileRect;
tileRect.intersect(contentRect);
// Skip empty tiles.
if (tileRect.isEmpty())
continue;
if (!tile || !tile->resourceId()) {
if (drawCheckerboardForMissingTiles()) {
SkColor defaultColor = SkColorSetRGB(defaultCheckerboardColorRed, defaultCheckerboardColorGreen, defaultCheckerboardColorBlue);
SkColor evictedColor = SkColorSetRGB(debugTileEvictedCheckerboardColorRed, debugTileEvictedCheckerboardColorGreen, debugTileEvictedCheckerboardColorBlue);
SkColor invalidatedColor = SkColorSetRGB(debugTileInvalidatedCheckerboardColorRed, debugTileEvictedCheckerboardColorGreen, debugTileEvictedCheckerboardColorBlue);
SkColor checkerColor;
if (hasDebugBorders())
checkerColor = tile ? invalidatedColor : evictedColor;
else
checkerColor = defaultColor;
appendQuadsData.hadMissingTiles |= quadSink.append(CCCheckerboardDrawQuad::create(sharedQuadState, tileRect, checkerColor).PassAs<CCDrawQuad>(), appendQuadsData);
} else
appendQuadsData.hadMissingTiles |= quadSink.append(CCSolidColorDrawQuad::create(sharedQuadState, tileRect, backgroundColor()).PassAs<CCDrawQuad>(), appendQuadsData);
continue;
}
IntRect tileOpaqueRect = tile->opaqueRect();
tileOpaqueRect.intersect(contentRect);
// Keep track of how the top left has moved, so the texture can be
// offset the same amount.
IntSize displayOffset = tileRect.minXMinYCorner() - displayRect.minXMinYCorner();
IntPoint textureOffset = m_tiler->textureOffset(i, j) + displayOffset;
float tileWidth = static_cast<float>(m_tiler->tileSize().width());
float tileHeight = static_cast<float>(m_tiler->tileSize().height());
IntSize textureSize(tileWidth, tileHeight);
bool clipped = false;
FloatQuad visibleContentInTargetQuad = CCMathUtil::mapQuad(drawTransform(), FloatQuad(visibleContentRect()), clipped);
bool isAxisAlignedInTarget = !clipped && visibleContentInTargetQuad.isRectilinear();
bool useAA = m_tiler->hasBorderTexels() && !isAxisAlignedInTarget;
bool leftEdgeAA = !i && useAA;
bool topEdgeAA = !j && useAA;
bool rightEdgeAA = i == m_tiler->numTilesX() - 1 && useAA;
bool bottomEdgeAA = j == m_tiler->numTilesY() - 1 && useAA;
const GC3Dint textureFilter = m_tiler->hasBorderTexels() ? GraphicsContext3D::LINEAR : GraphicsContext3D::NEAREST;
quadSink.append(CCTileDrawQuad::create(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), textureOffset, textureSize, textureFilter, contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA).PassAs<CCDrawQuad>(), appendQuadsData);
}
}
}
DoubleRect ScrollableArea::visibleContentRectDouble(IncludeScrollbarsInRect scrollbarInclusion) const
{
return visibleContentRect(scrollbarInclusion);
}
void ScrollView::paint(GraphicsContext* context, const IntRect& rect)
{
// FIXME: This code is here so we don't have to fork FrameView.h/.cpp.
// In the end, FrameView should just merge with ScrollView.
ASSERT(isFrameView());
if (context->paintingDisabled() && !context->updatingControlTints())
return;
IntRect documentDirtyRect = rect;
documentDirtyRect.intersect(frameGeometry());
context->save();
context->translate(x(), y());
documentDirtyRect.move(-x(), -y());
context->translate(-contentsX(), -contentsY());
documentDirtyRect.move(contentsX(), contentsY());
context->clip(enclosingIntRect(visibleContentRect()));
static_cast<const FrameView*>(this)->frame()->paint(context, documentDirtyRect);
context->restore();
// Now paint the scrollbars.
if (!m_data->m_scrollbarsSuppressed && (m_data->m_hBar || m_data->m_vBar)) {
context->save();
IntRect scrollViewDirtyRect = rect;
scrollViewDirtyRect.intersect(frameGeometry());
context->translate(x(), y());
scrollViewDirtyRect.move(-x(), -y());
if (m_data->m_hBar)
m_data->m_hBar->paint(context, scrollViewDirtyRect);
if (m_data->m_vBar)
m_data->m_vBar->paint(context, scrollViewDirtyRect);
// Fill the scroll corner with white.
IntRect hCorner;
if (m_data->m_hBar && width() - m_data->m_hBar->width() > 0) {
hCorner = IntRect(m_data->m_hBar->width(),
height() - m_data->m_hBar->height(),
width() - m_data->m_hBar->width(),
m_data->m_hBar->height());
if (hCorner.intersects(scrollViewDirtyRect))
context->fillRect(hCorner, Color::white);
}
if (m_data->m_vBar && height() - m_data->m_vBar->height() > 0) {
IntRect vCorner(width() - m_data->m_vBar->width(),
m_data->m_vBar->height(),
m_data->m_vBar->width(),
height() - m_data->m_vBar->height());
if (vCorner != hCorner && vCorner.intersects(scrollViewDirtyRect))
context->fillRect(vCorner, Color::white);
}
context->restore();
}
}
FloatRect ScrollView::visibleContentRectConsideringExternalScrollers() const
{
// external scrollers not supported for now
return visibleContentRect();
}
Region CCLayerImpl::visibleContentOpaqueRegion() const
{
if (opaque())
return visibleContentRect();
return Region();
}
