Source/WebCore/platform/graphics/texmap/TextureMapperLayer.h

   1 /*
   2  Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
   3
   4  This library is free software; you can redistribute it and/or
   5  modify it under the terms of the GNU Library General Public
   6  License as published by the Free Software Foundation; either
   7  version 2 of the License, or (at your option) any later version.
   8
   9  This library is distributed in the hope that it will be useful,
  10  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  Library General Public License for more details.
  13
  14  You should have received a copy of the GNU Library General Public License
  15  along with this library; see the file COPYING.LIB.  If not, write to
  16  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifndef TextureMapperLayer_h
  21 #define TextureMapperLayer_h
  22
  23 #if USE(ACCELERATED_COMPOSITING)
  24
  25 #include "FilterOperations.h"
  26 #include "FloatRect.h"
  27 #include "GraphicsLayerAnimation.h"
  28 #include "GraphicsLayerTransform.h"
  29 #include "TextureMapper.h"
  30 #include "TextureMapperBackingStore.h"
  31
  32 namespace WebCore {
  33
  34 class Region;
  35 class TextureMapperPaintOptions;
  36 class TextureMapperPlatformLayer;
  37
  38 class TextureMapperLayer : public GraphicsLayerAnimation::Client {
  39     WTF_MAKE_NONCOPYABLE(TextureMapperLayer);
  40     WTF_MAKE_FAST_ALLOCATED;
  41 public:
  42
  43     class ScrollingClient {
  44     public:
  45         virtual void commitScrollOffset(uint32_t layerID, const IntSize& offset) = 0;
  46     };
  47
  48     TextureMapperLayer()
  49         : m_parent(0)
  50         , m_effectTarget(0)
  51         , m_contentsLayer(0)
  52         , m_currentOpacity(1)
  53         , m_centerZ(0)
  54         , m_textureMapper(0)
  55         , m_fixedToViewport(false)
  56         , m_id(0)
  57         , m_scrollClient(0)
  58         , m_isScrollable(false)
  59         , m_patternTransformDirty(false)
  60     { }
  61
  62     virtual ~TextureMapperLayer();
  63
  64     void setID(uint32_t id) { m_id = id; }
  65     uint32_t id() { return m_id; }
  66
  67     const Vector<TextureMapperLayer*>& children() const { return m_children; }
  68     TextureMapperLayer* findScrollableContentsLayerAt(const FloatPoint& pos);
  69
  70     void setScrollClient(ScrollingClient* scrollClient) { m_scrollClient = scrollClient; }
  71     void scrollBy(const WebCore::FloatSize&);
  72
  73     void didCommitScrollOffset(const IntSize&);
  74     void setIsScrollable(bool isScrollable) { m_isScrollable = isScrollable; }
  75     bool isScrollable() const { return m_isScrollable; }
  76
  77     TextureMapper* textureMapper() const;
  78     void setTextureMapper(TextureMapper* texmap) { m_textureMapper = texmap; }
  79
  80     void setChildren(const Vector<TextureMapperLayer*>&);
  81     void setMaskLayer(TextureMapperLayer*);
  82     void setReplicaLayer(TextureMapperLayer*);
  83     void setPosition(const FloatPoint&);
  84     void setSize(const FloatSize&);
  85     void setAnchorPoint(const FloatPoint3D&);
  86     void setPreserves3D(bool);
  87     void setTransform(const TransformationMatrix&);
  88     void setChildrenTransform(const TransformationMatrix&);
  89     void setContentsRect(const IntRect&);
  90     void setMasksToBounds(bool);
  91     void setDrawsContent(bool);
  92     bool drawsContent() const { return m_state.drawsContent; }
  93     bool contentsAreVisible() const { return m_state.contentsVisible; }
  94     FloatSize size() const { return m_state.size; }
  95     float opacity() const { return m_state.opacity; }
  96     TransformationMatrix transform() const { return m_state.transform; }
  97     void setContentsVisible(bool);
  98     void setContentsOpaque(bool);
  99     void setBackfaceVisibility(bool);
 100     void setOpacity(float);
 101     void setSolidColor(const Color&);
 102     void setContentsTileSize(const IntSize&);
 103     void setContentsTilePhase(const IntPoint&);
 104 #if ENABLE(CSS_FILTERS)
 105     void setFilters(const FilterOperations&);
 106 #endif
 107
 108     bool hasFilters() const
 109     {
 110 #if ENABLE(CSS_FILTERS)
 111         return !m_currentFilters.isEmpty();
 112 #else
 113         return false;
 114 #endif
 115     }
 116
 117     void setDebugVisuals(bool showDebugBorders, const Color& debugBorderColor, float debugBorderWidth, bool showRepaintCounter);
 118     bool isShowingRepaintCounter() const { return m_state.showRepaintCounter; }
 119     void setRepaintCount(int);
 120     void setContentsLayer(TextureMapperPlatformLayer*);
 121     void setAnimations(const GraphicsLayerAnimations&);
 122     void setFixedToViewport(bool);
 123     bool fixedToViewport() const { return m_fixedToViewport; }
 124     void setBackingStore(PassRefPtr<TextureMapperBackingStore>);
 125     void setShouldMapBackingStoreToContentsRect(bool m) { m_state.shouldMapBackingStoreToContentsRect = m; }
 126
 127     void syncAnimations();
 128     bool descendantsOrSelfHaveRunningAnimations() const;
 129
 130     void paint();
 131
 132     void setScrollPositionDeltaIfNeeded(const FloatSize&);
 133
 134     void applyAnimationsRecursively();
 135     void addChild(TextureMapperLayer*);
 136
 137 private:
 138     const TextureMapperLayer* rootLayer() const;
 139     void computeTransformsRecursive();
 140
 141     static int compareGraphicsLayersZValue(const void* a, const void* b);
 142     static void sortByZOrder(Vector<TextureMapperLayer* >& array);
 143
 144     PassRefPtr<BitmapTexture> texture() { return m_backingStore ? m_backingStore->texture() : 0; }
 145     FloatPoint adjustedPosition() const { return m_state.pos + m_scrollPositionDelta - m_userScrollOffset; }
 146     bool isAncestorFixedToViewport() const;
 147     TransformationMatrix replicaTransform();
 148     void removeFromParent();
 149     void removeAllChildren();
 150
 151     enum ResolveSelfOverlapMode {
 152         ResolveSelfOverlapAlways = 0,
 153         ResolveSelfOverlapIfNeeded
 154     };
 155     void computeOverlapRegions(Region& overlapRegion, Region& nonOverlapRegion, ResolveSelfOverlapMode);
 156
 157     void paintRecursive(const TextureMapperPaintOptions&);
 158     void paintUsingOverlapRegions(const TextureMapperPaintOptions&);
 159     PassRefPtr<BitmapTexture> paintIntoSurface(const TextureMapperPaintOptions&, const IntSize&);
 160     void paintWithIntermediateSurface(const TextureMapperPaintOptions&, const IntRect&);
 161     void paintSelf(const TextureMapperPaintOptions&);
 162     void paintSelfAndChildren(const TextureMapperPaintOptions&);
 163     void paintSelfAndChildrenWithReplica(const TextureMapperPaintOptions&);
 164     void applyMask(const TextureMapperPaintOptions&);
 165     void computePatternTransformIfNeeded();
 166
 167     // GraphicsLayerAnimation::Client
 168     virtual void setAnimatedTransform(const TransformationMatrix&) OVERRIDE;
 169     virtual void setAnimatedOpacity(float) OVERRIDE;
 170 #if ENABLE(CSS_FILTERS)
 171     virtual void setAnimatedFilters(const FilterOperations&) OVERRIDE;
 172 #endif
 173
 174     bool isVisible() const;
 175     enum ContentsLayerCount {
 176         NoLayersWithContent,
 177         SingleLayerWithContents,
 178         MultipleLayersWithContents
 179     };
 180
 181     bool shouldBlend() const;
 182
 183     inline FloatRect layerRect() const
 184     {
 185         return FloatRect(FloatPoint::zero(), m_state.size);
 186     }
 187
 188     Vector<TextureMapperLayer*> m_children;
 189     TextureMapperLayer* m_parent;
 190     TextureMapperLayer* m_effectTarget;
 191     RefPtr<TextureMapperBackingStore> m_backingStore;
 192     TextureMapperPlatformLayer* m_contentsLayer;
 193     GraphicsLayerTransform m_currentTransform;
 194     float m_currentOpacity;
 195 #if ENABLE(CSS_FILTERS)
 196     FilterOperations m_currentFilters;
 197 #endif
 198     float m_centerZ;
 199
 200     template<class HitTestCondition> TextureMapperLayer* hitTest(const FloatPoint&, HitTestCondition);
 201     static bool scrollableLayerHitTestCondition(TextureMapperLayer*, const FloatPoint&);
 202
 203     FloatSize mapScrollOffset(const FloatSize&);
 204     void commitScrollOffset(const FloatSize&);
 205
 206     struct State {
 207         FloatPoint pos;
 208         FloatPoint3D anchorPoint;
 209         FloatSize size;
 210         TransformationMatrix transform;
 211         TransformationMatrix childrenTransform;
 212         float opacity;
 213         FloatRect contentsRect;
 214         IntSize contentsTileSize;
 215         IntPoint contentsTilePhase;
 216         TextureMapperLayer* maskLayer;
 217         TextureMapperLayer* replicaLayer;
 218         Color solidColor;
 219 #if ENABLE(CSS_FILTERS)
 220         FilterOperations filters;
 221 #endif
 222         Color debugBorderColor;
 223         float debugBorderWidth;
 224         int repaintCount;
 225
 226         bool preserves3D : 1;
 227         bool masksToBounds : 1;
 228         bool drawsContent : 1;
 229         bool contentsVisible : 1;
 230         bool contentsOpaque : 1;
 231         bool backfaceVisibility : 1;
 232         bool visible : 1;
 233         bool showDebugBorders : 1;
 234         bool showRepaintCounter : 1;
 235         bool shouldMapBackingStoreToContentsRect : 1;
 236
 237         State()
 238             : opacity(1)
 239             , maskLayer(0)
 240             , replicaLayer(0)
 241             , debugBorderWidth(0)
 242             , repaintCount(0)
 243             , preserves3D(false)
 244             , masksToBounds(false)
 245             , drawsContent(false)
 246             , contentsVisible(true)
 247             , contentsOpaque(false)
 248             , backfaceVisibility(true)
 249             , visible(true)
 250             , showDebugBorders(false)
 251             , showRepaintCounter(false)
 252             , shouldMapBackingStoreToContentsRect(false)
 253         {
 254         }
 255     };
 256
 257     State m_state;
 258     TextureMapper* m_textureMapper;
 259     GraphicsLayerAnimations m_animations;
 260     FloatSize m_scrollPositionDelta;
 261     bool m_fixedToViewport;
 262     uint32_t m_id;
 263     ScrollingClient* m_scrollClient;
 264     bool m_isScrollable;
 265     FloatSize m_userScrollOffset;
 266     FloatSize m_accumulatedScrollOffsetFractionalPart;
 267     TransformationMatrix m_patternTransform;
 268     bool m_patternTransformDirty;
 269 };
 270
 271 }
 272 #endif
 273
 274 #endif // TextureMapperLayer_h