37897e6f812b171f90f2268ebc57d506103397be
[WebKit-https.git] / Source / WebKit / chromium / src / WebLayer.cpp
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 #include "config.h"
27 #include <public/WebLayer.h>
28
29 #include "LayerChromium.h"
30 #include "SkMatrix44.h"
31 #include "WebAnimationImpl.h"
32 #include "WebLayerImpl.h"
33 #include <public/WebFilterOperations.h>
34 #include <public/WebFloatPoint.h>
35 #include <public/WebFloatRect.h>
36 #include <public/WebSize.h>
37 #include <public/WebTransformationMatrix.h>
38
39 using namespace WebCore;
40 using WebKit::WebTransformationMatrix;
41
42 namespace {
43
44 WebTransformationMatrix transformationMatrixFromSkMatrix44(const SkMatrix44& matrix)
45 {
46     double data[16];
47     matrix.asColMajord(data);
48     return WebTransformationMatrix(data[0], data[1], data[2], data[3],
49                                    data[4], data[5], data[6], data[7],
50                                    data[8], data[9], data[10], data[11],
51                                    data[12], data[13], data[14], data[15]);
52 }
53
54 SkMatrix44 skMatrix44FromTransformationMatrix(const WebTransformationMatrix& matrix)
55 {
56     SkMatrix44 skMatrix;
57     skMatrix.set(0, 0, SkDoubleToMScalar(matrix.m11()));
58     skMatrix.set(1, 0, SkDoubleToMScalar(matrix.m12()));
59     skMatrix.set(2, 0, SkDoubleToMScalar(matrix.m13()));
60     skMatrix.set(3, 0, SkDoubleToMScalar(matrix.m14()));
61     skMatrix.set(0, 1, SkDoubleToMScalar(matrix.m21()));
62     skMatrix.set(1, 1, SkDoubleToMScalar(matrix.m22()));
63     skMatrix.set(2, 1, SkDoubleToMScalar(matrix.m23()));
64     skMatrix.set(3, 1, SkDoubleToMScalar(matrix.m24()));
65     skMatrix.set(0, 2, SkDoubleToMScalar(matrix.m31()));
66     skMatrix.set(1, 2, SkDoubleToMScalar(matrix.m32()));
67     skMatrix.set(2, 2, SkDoubleToMScalar(matrix.m33()));
68     skMatrix.set(3, 2, SkDoubleToMScalar(matrix.m34()));
69     skMatrix.set(0, 3, SkDoubleToMScalar(matrix.m41()));
70     skMatrix.set(1, 3, SkDoubleToMScalar(matrix.m42()));
71     skMatrix.set(2, 3, SkDoubleToMScalar(matrix.m43()));
72     skMatrix.set(3, 3, SkDoubleToMScalar(matrix.m44()));
73     return skMatrix;
74 }
75
76 } // anonymous namespace
77
78 namespace WebKit {
79
80 WebLayer WebLayer::create()
81 {
82     return WebLayer(WebLayerImpl::create());
83 }
84
85 void WebLayer::reset()
86 {
87     m_private.reset();
88 }
89
90 void WebLayer::assign(const WebLayer& other)
91 {
92     m_private = other.m_private;
93 }
94
95 bool WebLayer::equals(const WebLayer& n) const
96 {
97     return (m_private.get() == n.m_private.get());
98 }
99
100 void WebLayer::invalidateRect(const WebFloatRect& dirtyRect)
101 {
102     m_private->setNeedsDisplayRect(dirtyRect);
103 }
104
105 void WebLayer::invalidate()
106 {
107     m_private->setNeedsDisplay();
108 }
109
110 void WebLayer::addChild(const WebLayer& child)
111 {
112     m_private->addChild(child);
113 }
114
115 void WebLayer::insertChild(const WebLayer& child, size_t index)
116 {
117     m_private->insertChild(child, index);
118 }
119
120 void WebLayer::replaceChild(const WebLayer& reference, const WebLayer& newLayer)
121 {
122     WebLayer ref = reference;
123     m_private->replaceChild(ref.unwrap<LayerChromium>(), newLayer);
124 }
125
126 void WebLayer::setChildren(const WebVector<WebLayer>& webChildren)
127 {
128     Vector<RefPtr<LayerChromium> > children(webChildren.size());
129     for (size_t i = 0; i < webChildren.size(); ++i)
130         children[i] = webChildren[i].unwrap<LayerChromium>();
131     m_private->setChildren(children);
132 }
133
134 void WebLayer::removeFromParent()
135 {
136     m_private->removeFromParent();
137 }
138
139 void WebLayer::removeAllChildren()
140 {
141     m_private->removeAllChildren();
142 }
143
144 void WebLayer::setAnchorPoint(const WebFloatPoint& anchorPoint)
145 {
146     m_private->setAnchorPoint(anchorPoint);
147 }
148
149 WebFloatPoint WebLayer::anchorPoint() const
150 {
151     return WebFloatPoint(m_private->anchorPoint());
152 }
153
154 void WebLayer::setAnchorPointZ(float anchorPointZ)
155 {
156     m_private->setAnchorPointZ(anchorPointZ);
157 }
158
159 float WebLayer::anchorPointZ() const
160 {
161     return m_private->anchorPointZ();
162 }
163
164 void WebLayer::setBounds(const WebSize& size)
165 {
166     m_private->setBounds(size);
167 }
168
169 WebSize WebLayer::bounds() const
170 {
171     return WebSize(m_private->bounds());
172 }
173
174 void WebLayer::setMasksToBounds(bool masksToBounds)
175 {
176     m_private->setMasksToBounds(masksToBounds);
177 }
178
179 bool WebLayer::masksToBounds() const
180 {
181     return m_private->masksToBounds();
182 }
183
184 void WebLayer::setMaskLayer(const WebLayer& maskLayer)
185 {
186     WebLayer ref = maskLayer;
187     m_private->setMaskLayer(ref.unwrap<LayerChromium>());
188 }
189
190 void WebLayer::setReplicaLayer(const WebLayer& replicaLayer)
191 {
192     WebLayer ref = replicaLayer;
193     m_private->setReplicaLayer(ref.unwrap<LayerChromium>());
194 }
195
196 void WebLayer::setOpacity(float opacity)
197 {
198     m_private->setOpacity(opacity);
199 }
200
201 float WebLayer::opacity() const
202 {
203     return m_private->opacity();
204 }
205
206 void WebLayer::setOpaque(bool opaque)
207 {
208     m_private->setOpaque(opaque);
209 }
210
211 bool WebLayer::opaque() const
212 {
213     return m_private->opaque();
214 }
215
216 void WebLayer::setPosition(const WebFloatPoint& position)
217 {
218     m_private->setPosition(position);
219 }
220
221 WebFloatPoint WebLayer::position() const
222 {
223     return WebFloatPoint(m_private->position());
224 }
225
226 void WebLayer::setSublayerTransform(const SkMatrix44& matrix)
227 {
228     m_private->setSublayerTransform(transformationMatrixFromSkMatrix44(matrix));
229 }
230
231 void WebLayer::setSublayerTransform(const WebTransformationMatrix& matrix)
232 {
233     m_private->setSublayerTransform(matrix);
234 }
235
236 SkMatrix44 WebLayer::sublayerTransform() const
237 {
238     return skMatrix44FromTransformationMatrix(m_private->sublayerTransform());
239 }
240
241 void WebLayer::setTransform(const SkMatrix44& matrix)
242 {
243     m_private->setTransform(transformationMatrixFromSkMatrix44(matrix));
244 }
245
246 void WebLayer::setTransform(const WebTransformationMatrix& matrix)
247 {
248     m_private->setTransform(matrix);
249 }
250
251 SkMatrix44 WebLayer::transform() const
252 {
253     return skMatrix44FromTransformationMatrix(m_private->transform());
254 }
255
256 void WebLayer::setDrawsContent(bool drawsContent)
257 {
258     m_private->setIsDrawable(drawsContent);
259 }
260
261 bool WebLayer::drawsContent() const
262 {
263     return m_private->drawsContent();
264 }
265
266 void WebLayer::setPreserves3D(bool preserve3D)
267 {
268     m_private->setPreserves3D(preserve3D);
269 }
270
271 void WebLayer::setUseParentBackfaceVisibility(bool useParentBackfaceVisibility)
272 {
273     m_private->setUseParentBackfaceVisibility(useParentBackfaceVisibility);
274 }
275
276 void WebLayer::setBackgroundColor(WebColor color)
277 {
278     m_private->setBackgroundColor(color);
279 }
280
281 void WebLayer::setFilters(const WebFilterOperations& filters)
282 {
283     m_private->setFilters(filters);
284 }
285
286 void WebLayer::setBackgroundFilters(const WebFilterOperations& filters)
287 {
288     m_private->setBackgroundFilters(filters);
289 }
290
291 void WebLayer::setDebugBorderColor(const WebColor& color)
292 {
293     m_private->setDebugBorderColor(color);
294 }
295
296 void WebLayer::setDebugBorderWidth(float width)
297 {
298     m_private->setDebugBorderWidth(width);
299 }
300
301 void WebLayer::setDebugName(WebString name)
302 {
303     m_private->setDebugName(name);
304 }
305
306 void WebLayer::setAnimationDelegate(WebAnimationDelegate* delegate)
307 {
308     m_private->setLayerAnimationDelegate(delegate);
309 }
310
311 bool WebLayer::addAnimation(WebAnimation* animation)
312 {
313     return m_private->addAnimation(static_cast<WebAnimationImpl*>(animation)->cloneToCCAnimation());
314 }
315
316 void WebLayer::removeAnimation(int animationId)
317 {
318     m_private->removeAnimation(animationId);
319 }
320
321 void WebLayer::removeAnimation(int animationId, WebAnimation::TargetProperty targetProperty)
322 {
323     m_private->layerAnimationController()->removeAnimation(animationId, static_cast<CCActiveAnimation::TargetProperty>(targetProperty));
324 }
325
326 void WebLayer::pauseAnimation(int animationId, double timeOffset)
327 {
328     m_private->pauseAnimation(animationId, timeOffset);
329 }
330
331 void WebLayer::suspendAnimations(double monotonicTime)
332 {
333     m_private->suspendAnimations(monotonicTime);
334 }
335
336 void WebLayer::resumeAnimations(double monotonicTime)
337 {
338     m_private->resumeAnimations(monotonicTime);
339 }
340
341 bool WebLayer::hasActiveAnimation()
342 {
343     return m_private->hasActiveAnimation();
344 }
345
346 void WebLayer::transferAnimationsTo(WebLayer* other)
347 {
348     ASSERT(other);
349     if (other)
350         other->m_private->setLayerAnimationController(m_private->releaseLayerAnimationController());
351 }
352
353 void WebLayer::setForceRenderSurface(bool forceRenderSurface)
354 {
355     m_private->setForceRenderSurface(forceRenderSurface);
356 }
357
358 void WebLayer::clearRenderSurface()
359 {
360     m_private->clearRenderSurface();
361 }
362
363 WebLayer::WebLayer(const PassRefPtr<LayerChromium>& node)
364     : m_private(node)
365 {
366 }
367
368 WebLayer& WebLayer::operator=(const PassRefPtr<LayerChromium>& node)
369 {
370     m_private = node;
371     return *this;
372 }
373
374 WebLayer::operator PassRefPtr<LayerChromium>() const
375 {
376     return m_private.get();
377 }
378
379 } // namespace WebKit