src/third_party/WebKit/public/platform/WebLayer.h

   1 /*
   2  * Copyright (C) 2011 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef WebLayer_h
  27 #define WebLayer_h
  28
  29 #include "WebAnimation.h"
  30 #include "WebBlendMode.h"
  31 #include "WebColor.h"
  32 #include "WebCommon.h"
  33 #include "WebPoint.h"
  34 #include "WebRect.h"
  35 #include "WebSize.h"
  36 #include "WebString.h"
  37 #include "WebVector.h"
  38
  39 class SkMatrix44;
  40 class SkImageFilter;
  41
  42 namespace blink {
  43 class WebAnimationDelegate;
  44 class WebFilterOperations;
  45 class WebLayerClient;
  46 class WebLayerScrollClient;
  47 struct WebFloatPoint;
  48 struct WebFloatRect;
  49 struct WebLayerPositionConstraint;
  50
  51 class WebLayer {
  52 public:
  53     virtual ~WebLayer() { }
  54
  55     // Returns a positive ID that will be unique across all WebLayers allocated in this process.
  56     virtual int id() const = 0;
  57
  58     // Sets a region of the layer as invalid, i.e. needs to update its content.
  59     virtual void invalidateRect(const WebFloatRect&) = 0;
  60
  61     // Sets the entire layer as invalid, i.e. needs to update its content.
  62     virtual void invalidate() = 0;
  63
  64     // These functions do not take ownership of the WebLayer* parameter.
  65     virtual void addChild(WebLayer*) = 0;
  66     virtual void insertChild(WebLayer*, size_t index) = 0;
  67     virtual void replaceChild(WebLayer* reference, WebLayer* newLayer) = 0;
  68     virtual void removeFromParent() = 0;
  69     virtual void removeAllChildren() = 0;
  70
  71     virtual void setAnchorPoint(const WebFloatPoint&) = 0;
  72     virtual WebFloatPoint anchorPoint() const = 0;
  73
  74     virtual void setAnchorPointZ(float) = 0;
  75     virtual float anchorPointZ() const = 0;
  76
  77     virtual void setBounds(const WebSize&) = 0;
  78     virtual WebSize bounds() const = 0;
  79
  80     virtual void setMasksToBounds(bool) = 0;
  81     virtual bool masksToBounds() const = 0;
  82
  83     virtual void setMaskLayer(WebLayer*) = 0;
  84     virtual void setReplicaLayer(WebLayer*) = 0;
  85
  86     virtual void setOpacity(float) = 0;
  87     virtual float opacity() const = 0;
  88
  89     virtual void setBlendMode(WebBlendMode) = 0;
  90     virtual WebBlendMode blendMode() const = 0;
  91
  92     virtual void setIsRootForIsolatedGroup(bool) = 0;
  93     virtual bool isRootForIsolatedGroup() = 0;
  94
  95     virtual void setOpaque(bool) = 0;
  96     virtual bool opaque() const = 0;
  97
  98     virtual void setPosition(const WebFloatPoint&) = 0;
  99     virtual WebFloatPoint position() const = 0;
 100
 101     virtual void setTransform(const SkMatrix44&) = 0;
 102     virtual SkMatrix44 transform() const = 0;
 103
 104     // Sets whether the layer draws its content when compositing.
 105     virtual void setDrawsContent(bool) = 0;
 106     virtual bool drawsContent() const = 0;
 107
 108     // Sets whether the layer's transform should be flattened.
 109     virtual void setShouldFlattenTransform(bool) = 0;
 110
 111     // Sets the id of the layer's 3d rendering context. Layers in the same 3d
 112     // rendering context id are sorted with one another according to their 3d
 113     // position rather than their tree order.
 114     virtual void setRenderingContext(int id) = 0;
 115
 116     // Mark that this layer should use its parent's transform and double-sided
 117     // properties in determining this layer's backface visibility instead of
 118     // using its own properties. If this property is set, this layer must
 119     // have a parent, and the parent may not have this property set.
 120     // Note: This API is to work around issues with visibility the handling of
 121     // WebKit layers that have a contents layer (canvas, plugin, WebGL, video,
 122     // etc).
 123     virtual void setUseParentBackfaceVisibility(bool) = 0;
 124
 125     virtual void setBackgroundColor(WebColor) = 0;
 126     virtual WebColor backgroundColor() const = 0;
 127
 128     // Clear the filters in use by passing in a newly instantiated
 129     // WebFilterOperations object.
 130     virtual void setFilters(const WebFilterOperations&) = 0;
 131
 132     // Apply filters to pixels that show through the background of this layer.
 133     // Note: These filters are only possible on layers that are drawn directly
 134     // to a root render surface with an opaque background. This means if an
 135     // ancestor of the background-filtered layer sets certain properties
 136     // (opacity, transforms), it may conflict and hide the background filters.
 137     virtual void setBackgroundFilters(const WebFilterOperations&) = 0;
 138
 139     // An animation delegate is notified when animations are started and
 140     // stopped. The WebLayer does not take ownership of the delegate, and it is
 141     // the responsibility of the client to reset the layer's delegate before
 142     // deleting the delegate.
 143     virtual void setAnimationDelegate(WebAnimationDelegate*) = 0;
 144
 145
 146     // Returns false if the animation cannot be added.
 147     // Takes ownership of the WebAnimation object.
 148     virtual bool addAnimation(WebAnimation*) = 0;
 149
 150     // Removes all animations with the given id.
 151     virtual void removeAnimation(int animationId) = 0;
 152
 153     // Removes all animations with the given id targeting the given property.
 154     virtual void removeAnimation(int animationId, WebAnimation::TargetProperty) = 0;
 155
 156     // Pauses all animations with the given id.
 157     virtual void pauseAnimation(int animationId, double timeOffset) = 0;
 158
 159     // Returns true if this layer has any active animations - useful for tests.
 160     virtual bool hasActiveAnimation() = 0;
 161
 162     // If a scroll parent is set, this layer will inherit its parent's scroll
 163     // delta and offset even though it will not be a descendant of the scroll
 164     // in the layer hierarchy.
 165     virtual void setScrollParent(WebLayer*) = 0;
 166
 167     // A layer will not respect any clips established by layers between it and
 168     // its nearest clipping ancestor. Note, the clip parent must be an ancestor.
 169     // This is not a requirement of the scroll parent.
 170     virtual void setClipParent(WebLayer*) = 0;
 171
 172     // Scrolling
 173     virtual void setScrollPosition(WebPoint) = 0;
 174     virtual WebPoint scrollPosition() const = 0;
 175
 176     // To set a WebLayer as scrollable we must specify the corresponding clip layer.
 177     virtual void setScrollClipLayer(WebLayer*) = 0;
 178     virtual bool scrollable() const = 0;
 179     virtual void setUserScrollable(bool horizontal, bool vertical) = 0;
 180     virtual bool userScrollableHorizontal() const = 0;
 181     virtual bool userScrollableVertical() const = 0;
 182
 183     virtual void setHaveWheelEventHandlers(bool) = 0;
 184     virtual bool haveWheelEventHandlers() const = 0;
 185
 186     virtual void setHaveScrollEventHandlers(bool) = 0;
 187     virtual bool haveScrollEventHandlers() const = 0;
 188
 189     virtual void setShouldScrollOnMainThread(bool) = 0;
 190     virtual bool shouldScrollOnMainThread() const = 0;
 191
 192     virtual void setNonFastScrollableRegion(const WebVector<WebRect>&) = 0;
 193     virtual WebVector<WebRect> nonFastScrollableRegion() const = 0;
 194
 195     virtual void setTouchEventHandlerRegion(const WebVector<WebRect>&) = 0;
 196     virtual WebVector<WebRect> touchEventHandlerRegion() const = 0;
 197
 198     virtual void setIsContainerForFixedPositionLayers(bool) = 0;
 199     virtual bool isContainerForFixedPositionLayers() const = 0;
 200
 201     // This function sets layer position constraint. The constraint will be used
 202     // to adjust layer position during threaded scrolling.
 203     virtual void setPositionConstraint(const WebLayerPositionConstraint&) = 0;
 204     virtual WebLayerPositionConstraint positionConstraint() const = 0;
 205
 206     // The scroll client is notified when the scroll position of the WebLayer
 207     // changes. Only a single scroll client can be set for a WebLayer at a time.
 208     // The WebLayer does not take ownership of the scroll client, and it is the
 209     // responsibility of the client to reset the layer's scroll client before
 210     // deleting the scroll client.
 211     virtual void setScrollClient(WebLayerScrollClient*) = 0;
 212
 213     // Forces this layer to use a render surface. There is no benefit in doing
 214     // so, but this is to facilitate benchmarks and tests.
 215     virtual void setForceRenderSurface(bool) = 0;
 216
 217     // True if the layer is not part of a tree attached to a WebLayerTreeView.
 218     virtual bool isOrphan() const = 0;
 219
 220     virtual void setWebLayerClient(WebLayerClient*) = 0;
 221 };
 222
 223 } // namespace blink
 224
 225 #endif // WebLayer_h