cc/scrollbar_layer_impl.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/scrollbar_layer_impl.h"
   6
   7 #include "cc/layer_tree_impl.h"
   8 #include "cc/quad_sink.h"
   9 #include "cc/scrollbar_animation_controller.h"
  10 #include "cc/texture_draw_quad.h"
  11 #include "ui/gfx/rect_conversions.h"
  12
  13 using WebKit::WebRect;
  14 using WebKit::WebScrollbar;
  15
  16 namespace cc {
  17
  18 scoped_ptr<ScrollbarLayerImpl> ScrollbarLayerImpl::create(LayerTreeImpl* treeImpl, int id, scoped_ptr<ScrollbarGeometryFixedThumb> geometry)
  19 {
  20     return make_scoped_ptr(new ScrollbarLayerImpl(treeImpl, id, geometry.Pass()));
  21 }
  22
  23 ScrollbarLayerImpl::ScrollbarLayerImpl(LayerTreeImpl* treeImpl, int id, scoped_ptr<ScrollbarGeometryFixedThumb> geometry)
  24     : ScrollbarLayerImplBase(treeImpl, id)
  25     , m_scrollbar(this)
  26     , m_backTrackResourceId(0)
  27     , m_foreTrackResourceId(0)
  28     , m_thumbResourceId(0)
  29     , m_geometry(geometry.Pass())
  30     , m_currentPos(0)
  31     , m_totalSize(0)
  32     , m_maximum(0)
  33     , m_scrollLayerId(-1)
  34     , m_scrollbarOverlayStyle(WebScrollbar::ScrollbarOverlayStyleDefault)
  35     , m_orientation(WebScrollbar::Horizontal)
  36     , m_controlSize(WebScrollbar::RegularScrollbar)
  37     , m_pressedPart(WebScrollbar::NoPart)
  38     , m_hoveredPart(WebScrollbar::NoPart)
  39     , m_isScrollableAreaActive(false)
  40     , m_isScrollViewScrollbar(false)
  41     , m_enabled(false)
  42     , m_isCustomScrollbar(false)
  43     , m_isOverlayScrollbar(false)
  44 {
  45 }
  46
  47 ScrollbarLayerImpl::~ScrollbarLayerImpl()
  48 {
  49 }
  50
  51 ScrollbarLayerImpl* ScrollbarLayerImpl::toScrollbarLayer()
  52 {
  53     return this;
  54 }
  55
  56 void ScrollbarLayerImpl::setScrollbarData(WebScrollbar* scrollbar)
  57 {
  58     m_scrollbarOverlayStyle = scrollbar->scrollbarOverlayStyle();
  59     m_orientation = scrollbar->orientation();
  60     m_controlSize = scrollbar->controlSize();
  61     m_pressedPart = scrollbar->pressedPart();
  62     m_hoveredPart = scrollbar->hoveredPart();
  63     m_isScrollableAreaActive = scrollbar->isScrollableAreaActive();
  64     m_isScrollViewScrollbar = scrollbar->isScrollViewScrollbar();
  65     m_enabled = scrollbar->enabled();
  66     m_isCustomScrollbar = scrollbar->isCustomScrollbar();
  67     m_isOverlayScrollbar = scrollbar->isOverlay();
  68
  69     scrollbar->getTickmarks(m_tickmarks);
  70 }
  71
  72 void ScrollbarLayerImpl::setThumbSize(gfx::Size size)
  73 {
  74     m_thumbSize = size;
  75     if (!m_geometry) {
  76         // In impl-side painting, the ScrollbarLayerImpl in the pending tree
  77         // simply holds properties that are later pushed to the active tree's
  78         // layer, but it doesn't hold geometry or append quads.
  79         DCHECK(layerTreeImpl()->IsPendingTree());
  80         return;
  81     }
  82     m_geometry->setThumbSize(size);
  83 }
  84
  85 float ScrollbarLayerImpl::currentPos() const
  86 {
  87     return m_currentPos;
  88 }
  89
  90 int ScrollbarLayerImpl::totalSize() const
  91 {
  92     return m_totalSize;
  93 }
  94
  95 int ScrollbarLayerImpl::maximum() const
  96 {
  97     return m_maximum;
  98 }
  99
 100 WebKit::WebScrollbar::Orientation ScrollbarLayerImpl::orientation() const
 101 {
 102     return m_orientation;
 103 }
 104
 105 static gfx::RectF toUVRect(const gfx::Rect& r, const gfx::Rect& bounds)
 106 {
 107     return gfx::ScaleRect(r, 1.0 / bounds.width(), 1.0 / bounds.height());
 108 }
 109
 110 gfx::Rect ScrollbarLayerImpl::scrollbarLayerRectToContentRect(const gfx::Rect& layerRect) const
 111 {
 112     // Don't intersect with the bounds as in layerRectToContentRect() because
 113     // layerRect here might be in coordinates of the containing layer.
 114     gfx::RectF contentRect = gfx::ScaleRect(layerRect, contentsScaleX(), contentsScaleY());
 115     return gfx::ToEnclosingRect(contentRect);
 116 }
 117
 118 scoped_ptr<LayerImpl> ScrollbarLayerImpl::createLayerImpl(LayerTreeImpl* treeImpl)
 119 {
 120     return ScrollbarLayerImpl::create(treeImpl, id(), m_geometry.Pass()).PassAs<LayerImpl>();
 121 }
 122
 123 void ScrollbarLayerImpl::pushPropertiesTo(LayerImpl* layer)
 124 {
 125     LayerImpl::pushPropertiesTo(layer);
 126
 127     ScrollbarLayerImpl* scrollbarLayer = static_cast<ScrollbarLayerImpl*>(layer);
 128
 129     scrollbarLayer->setScrollbarData(&m_scrollbar);
 130     scrollbarLayer->setThumbSize(m_thumbSize);
 131
 132     scrollbarLayer->setBackTrackResourceId(m_backTrackResourceId);
 133     scrollbarLayer->setForeTrackResourceId(m_foreTrackResourceId);
 134     scrollbarLayer->setThumbResourceId(m_thumbResourceId);
 135 }
 136
 137 void ScrollbarLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
 138 {
 139     bool premultipledAlpha = false;
 140     bool flipped = false;
 141     gfx::PointF uvTopLeft(0.f, 0.f);
 142     gfx::PointF uvBottomRight(1.f, 1.f);
 143     gfx::Rect boundsRect(gfx::Point(), bounds());
 144     gfx::Rect contentBoundsRect(gfx::Point(), contentBounds());
 145
 146     SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
 147     appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
 148
 149     WebRect thumbRect, backTrackRect, foreTrackRect;
 150     m_geometry->splitTrack(&m_scrollbar, m_geometry->trackRect(&m_scrollbar), backTrackRect, thumbRect, foreTrackRect);
 151     if (!m_geometry->hasThumb(&m_scrollbar))
 152         thumbRect = WebRect();
 153
 154     if (m_thumbResourceId && !thumbRect.isEmpty()) {
 155         gfx::Rect quadRect(scrollbarLayerRectToContentRect(thumbRect));
 156         gfx::Rect opaqueRect;
 157         const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
 158         scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
 159         quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_thumbResourceId, premultipledAlpha, uvTopLeft, uvBottomRight, opacity, flipped);
 160         quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 161     }
 162
 163     if (!m_backTrackResourceId)
 164         return;
 165
 166     // We only paint the track in two parts if we were given a texture for the forward track part.
 167     if (m_foreTrackResourceId && !foreTrackRect.isEmpty()) {
 168         gfx::Rect quadRect(scrollbarLayerRectToContentRect(foreTrackRect));
 169         gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
 170         gfx::RectF uvRect(toUVRect(foreTrackRect, boundsRect));
 171         const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
 172         scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
 173         quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_foreTrackResourceId, premultipledAlpha, uvRect.origin(), uvRect.bottom_right(), opacity, flipped);
 174         quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 175     }
 176
 177     // Order matters here: since the back track texture is being drawn to the entire contents rect, we must append it after the thumb and
 178     // fore track quads. The back track texture contains (and displays) the buttons.
 179     if (!contentBoundsRect.IsEmpty()) {
 180         gfx::Rect quadRect(contentBoundsRect);
 181         gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
 182         const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
 183         scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
 184         quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_backTrackResourceId, premultipledAlpha, uvTopLeft, uvBottomRight, opacity, flipped);
 185         quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 186     }
 187 }
 188
 189 void ScrollbarLayerImpl::didLoseOutputSurface()
 190 {
 191     m_backTrackResourceId = 0;
 192     m_foreTrackResourceId = 0;
 193     m_thumbResourceId = 0;
 194 }
 195
 196 bool ScrollbarLayerImpl::Scrollbar::isOverlay() const
 197 {
 198     return m_owner->m_isOverlayScrollbar;
 199 }
 200
 201 int ScrollbarLayerImpl::Scrollbar::value() const
 202 {
 203     return m_owner->currentPos();
 204 }
 205
 206 WebKit::WebPoint ScrollbarLayerImpl::Scrollbar::location() const
 207 {
 208     return WebKit::WebPoint();
 209 }
 210
 211 WebKit::WebSize ScrollbarLayerImpl::Scrollbar::size() const
 212 {
 213     return WebKit::WebSize(m_owner->bounds().width(), m_owner->bounds().height());
 214 }
 215
 216 bool ScrollbarLayerImpl::Scrollbar::enabled() const
 217 {
 218     return m_owner->m_enabled;
 219 }
 220
 221 int ScrollbarLayerImpl::Scrollbar::maximum() const
 222 {
 223     return m_owner->maximum();
 224 }
 225
 226 int ScrollbarLayerImpl::Scrollbar::totalSize() const
 227 {
 228     return m_owner->totalSize();
 229 }
 230
 231 bool ScrollbarLayerImpl::Scrollbar::isScrollViewScrollbar() const
 232 {
 233     return m_owner->m_isScrollViewScrollbar;
 234 }
 235
 236 bool ScrollbarLayerImpl::Scrollbar::isScrollableAreaActive() const
 237 {
 238     return m_owner->m_isScrollableAreaActive;
 239 }
 240
 241 void ScrollbarLayerImpl::Scrollbar::getTickmarks(WebKit::WebVector<WebRect>& tickmarks) const
 242 {
 243     tickmarks = m_owner->m_tickmarks;
 244 }
 245
 246 WebScrollbar::ScrollbarControlSize ScrollbarLayerImpl::Scrollbar::controlSize() const
 247 {
 248     return m_owner->m_controlSize;
 249 }
 250
 251 WebScrollbar::ScrollbarPart ScrollbarLayerImpl::Scrollbar::pressedPart() const
 252 {
 253     return m_owner->m_pressedPart;
 254 }
 255
 256 WebScrollbar::ScrollbarPart ScrollbarLayerImpl::Scrollbar::hoveredPart() const
 257 {
 258     return m_owner->m_hoveredPart;
 259 }
 260
 261 WebScrollbar::ScrollbarOverlayStyle ScrollbarLayerImpl::Scrollbar::scrollbarOverlayStyle() const
 262 {
 263     return m_owner->m_scrollbarOverlayStyle;
 264 }
 265
 266 WebScrollbar::Orientation ScrollbarLayerImpl::Scrollbar::orientation() const
 267 {
 268     return m_owner->m_orientation;
 269 }
 270
 271 bool ScrollbarLayerImpl::Scrollbar::isCustomScrollbar() const
 272 {
 273     return m_owner->m_isCustomScrollbar;
 274 }
 275
 276 const char* ScrollbarLayerImpl::layerTypeAsString() const
 277 {
 278     return "ScrollbarLayer";
 279 }
 280
 281 }  // namespace cc