OLD | NEW |
---|---|
1 // Copyright 2011 The Chromium Authors. All rights reserved. | 1 // Copyright 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "config.h" | 5 #include "config.h" |
6 | 6 |
7 #include "CCLayerTreeHostImpl.h" | 7 #include "CCLayerTreeHostImpl.h" |
8 | 8 |
9 #include "CCAppendQuadsData.h" | 9 #include "CCAppendQuadsData.h" |
10 #include "CCDamageTracker.h" | 10 #include "CCDamageTracker.h" |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
42 return; | 42 return; |
43 } | 43 } |
44 | 44 |
45 TRACE_EVENT_ASYNC_END0("webkit", "CCLayerTreeHostImpl::setVisible", id); | 45 TRACE_EVENT_ASYNC_END0("webkit", "CCLayerTreeHostImpl::setVisible", id); |
46 } | 46 } |
47 | 47 |
48 } // namespace | 48 } // namespace |
49 | 49 |
50 namespace cc { | 50 namespace cc { |
51 | 51 |
52 float CCPinchZoomViewport::totalPageScaleFactor() const | |
53 { | |
54 return m_pageScaleFactor * m_pageScaleDelta; | |
55 } | |
56 | |
57 void CCPinchZoomViewport::setPageScaleDelta(float delta) | |
58 { | |
59 // Clamp to the current min/max limits. | |
60 float finalMagnifyScale = m_pageScaleFactor * delta; | |
aelias_OOO_until_Jul13
2012/09/26 23:15:09
Rename "finalMagnifyScale" to "totalPageScaleFacto
Jeff Timanus
2012/10/01 21:42:36
Done.
| |
61 if (m_minPageScaleFactor && finalMagnifyScale < m_minPageScaleFactor) | |
62 delta = m_minPageScaleFactor / m_pageScaleFactor; | |
63 else if (m_maxPageScaleFactor && finalMagnifyScale > m_maxPageScaleFactor) | |
64 delta = m_maxPageScaleFactor / m_pageScaleFactor; | |
65 | |
66 if (delta == m_pageScaleDelta) | |
67 return; | |
68 | |
69 m_pageScaleDelta = delta; | |
70 } | |
71 | |
72 bool CCPinchZoomViewport::setPageScaleFactorAndLimits(float pageScaleFactor, flo at minPageScaleFactor, float maxPageScaleFactor) | |
73 { | |
74 if (!pageScaleFactor) | |
aelias_OOO_until_Jul13
2012/09/26 23:15:09
Replace this with ASSERT(pageScaleFactor); since i
Jeff Timanus
2012/10/01 21:42:36
Done.
| |
75 return false; | |
76 | |
77 if (m_sentPageScaleDelta == 1 && pageScaleFactor == m_pageScaleFactor && min PageScaleFactor == m_minPageScaleFactor && maxPageScaleFactor == m_maxPageScaleF actor) | |
78 return false; | |
79 | |
80 m_minPageScaleFactor = minPageScaleFactor; | |
81 m_maxPageScaleFactor = maxPageScaleFactor; | |
82 | |
83 m_pageScaleFactor = pageScaleFactor; | |
84 return true; | |
85 } | |
86 | |
87 FloatRect CCPinchZoomViewport::bounds() const | |
88 { | |
89 FloatSize scaledBounds = m_unpinchedBounds; | |
90 float totalScale = totalPageScaleFactor(); | |
aelias_OOO_until_Jul13
2012/09/26 23:15:09
No need for this local variable.
Jeff Timanus
2012/10/01 21:42:36
Done.
| |
91 if (totalScale > 1) | |
aelias_OOO_until_Jul13
2012/09/26 23:15:09
Remove this if(). It's correct in the == 1 or < 1
aelias_OOO_until_Jul13
2012/09/26 23:19:04
Actually, maybe it's not. As I suggested in my co
| |
92 scaledBounds.scale(1 / totalScale); | |
93 | |
94 FloatRect bounds; | |
95 bounds.setSize(scaledBounds); | |
aelias_OOO_until_Jul13
2012/09/26 23:15:09
Use the FloatRect constructor instead.
Jeff Timanus
2012/10/01 21:42:36
Done.
| |
96 bounds.setLocation(m_pinchViewportScrollDelta); | |
97 | |
98 return bounds; | |
99 } | |
100 | |
101 FloatSize CCPinchZoomViewport::applyScroll(FloatSize& delta) | |
102 { | |
103 FloatSize overflow; | |
104 FloatRect pinchedBounds = bounds(); | |
105 | |
106 pinchedBounds.move(delta); | |
107 if (pinchedBounds.x() < 0) { | |
108 pinchedBounds.setX(0); | |
109 overflow.setWidth(pinchedBounds.x()); | |
aelias_OOO_until_Jul13
2012/09/26 23:15:09
Looks like a bug here. Seems overflow values shou
Jeff Timanus
2012/10/01 21:42:36
Good catch. I'm surprised that this wasn't causin
Jeff Timanus
2012/10/01 21:42:36
Good catch. Fixed.
| |
110 } | |
111 | |
112 if (pinchedBounds.y() < 0) { | |
113 pinchedBounds.setY(0); | |
114 overflow.setHeight(pinchedBounds.y()); | |
115 } | |
116 | |
117 if (pinchedBounds.maxX() > m_unpinchedBounds.width()) { | |
118 pinchedBounds.move(m_unpinchedBounds.width() - pinchedBounds.maxX(), 0); | |
119 overflow.setWidth(pinchedBounds.maxX() - m_unpinchedBounds.width()); | |
120 } | |
121 | |
122 if (pinchedBounds.maxY() > m_unpinchedBounds.height()) { | |
123 pinchedBounds.move(0, m_unpinchedBounds.height() - pinchedBounds.maxY()) ; | |
124 overflow.setHeight(pinchedBounds.maxY() - m_unpinchedBounds.height()); | |
125 } | |
126 m_pinchViewportScrollDelta = pinchedBounds.location(); | |
127 | |
128 return overflow; | |
129 } | |
130 | |
52 class CCLayerTreeHostImplTimeSourceAdapter : public CCTimeSourceClient { | 131 class CCLayerTreeHostImplTimeSourceAdapter : public CCTimeSourceClient { |
53 WTF_MAKE_NONCOPYABLE(CCLayerTreeHostImplTimeSourceAdapter); | 132 WTF_MAKE_NONCOPYABLE(CCLayerTreeHostImplTimeSourceAdapter); |
54 public: | 133 public: |
55 static PassOwnPtr<CCLayerTreeHostImplTimeSourceAdapter> create(CCLayerTreeHo stImpl* layerTreeHostImpl, PassRefPtr<CCDelayBasedTimeSource> timeSource) | 134 static PassOwnPtr<CCLayerTreeHostImplTimeSourceAdapter> create(CCLayerTreeHo stImpl* layerTreeHostImpl, PassRefPtr<CCDelayBasedTimeSource> timeSource) |
56 { | 135 { |
57 return adoptPtr(new CCLayerTreeHostImplTimeSourceAdapter(layerTreeHostIm pl, timeSource)); | 136 return adoptPtr(new CCLayerTreeHostImplTimeSourceAdapter(layerTreeHostIm pl, timeSource)); |
58 } | 137 } |
59 virtual ~CCLayerTreeHostImplTimeSourceAdapter() | 138 virtual ~CCLayerTreeHostImplTimeSourceAdapter() |
60 { | 139 { |
61 m_timeSource->setClient(0); | 140 m_timeSource->setClient(0); |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
109 , m_rootScrollLayerImpl(0) | 188 , m_rootScrollLayerImpl(0) |
110 , m_currentlyScrollingLayerImpl(0) | 189 , m_currentlyScrollingLayerImpl(0) |
111 , m_hudLayerImpl(0) | 190 , m_hudLayerImpl(0) |
112 , m_scrollingLayerIdFromPreviousTree(-1) | 191 , m_scrollingLayerIdFromPreviousTree(-1) |
113 , m_scrollDeltaIsInScreenSpace(false) | 192 , m_scrollDeltaIsInScreenSpace(false) |
114 , m_settings(settings) | 193 , m_settings(settings) |
115 , m_deviceScaleFactor(1) | 194 , m_deviceScaleFactor(1) |
116 , m_visible(true) | 195 , m_visible(true) |
117 , m_contentsTexturesPurged(false) | 196 , m_contentsTexturesPurged(false) |
118 , m_memoryAllocationLimitBytes(CCPrioritizedTextureManager::defaultMemoryAll ocationLimit()) | 197 , m_memoryAllocationLimitBytes(CCPrioritizedTextureManager::defaultMemoryAll ocationLimit()) |
119 , m_pageScale(1) | |
120 , m_pageScaleDelta(1) | |
121 , m_sentPageScaleDelta(1) | |
122 , m_minPageScale(0) | |
123 , m_maxPageScale(0) | |
124 , m_backgroundColor(0) | 198 , m_backgroundColor(0) |
125 , m_hasTransparentBackground(false) | 199 , m_hasTransparentBackground(false) |
126 , m_needsAnimateLayers(false) | 200 , m_needsAnimateLayers(false) |
127 , m_pinchGestureActive(false) | 201 , m_pinchGestureActive(false) |
128 , m_fpsCounter(CCFrameRateCounter::create()) | 202 , m_fpsCounter(CCFrameRateCounter::create()) |
129 , m_debugRectHistory(CCDebugRectHistory::create()) | 203 , m_debugRectHistory(CCDebugRectHistory::create()) |
130 { | 204 { |
131 ASSERT(CCProxy::isImplThread()); | 205 ASSERT(CCProxy::isImplThread()); |
132 didVisibilityChange(this, m_visible); | 206 didVisibilityChange(this, m_visible); |
133 } | 207 } |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
189 animateLayers(monotonicTime, wallClockTime); | 263 animateLayers(monotonicTime, wallClockTime); |
190 animateScrollbars(monotonicTime); | 264 animateScrollbars(monotonicTime); |
191 } | 265 } |
192 | 266 |
193 void CCLayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration) | 267 void CCLayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration) |
194 { | 268 { |
195 if (!m_rootScrollLayerImpl) | 269 if (!m_rootScrollLayerImpl) |
196 return; | 270 return; |
197 | 271 |
198 IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta()); | 272 IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta()); |
199 scrollTotal.scale(m_pageScaleDelta); | 273 scrollTotal.scale(m_pinchZoomViewport.pageScaleDelta()); |
200 float scaleTotal = m_pageScale * m_pageScaleDelta; | 274 float scaleTotal = m_pinchZoomViewport.totalPageScaleFactor(); |
201 IntSize scaledContentSize = contentSize(); | 275 IntSize scaledContentSize = contentSize(); |
202 scaledContentSize.scale(m_pageScaleDelta); | 276 scaledContentSize.scale(m_pinchZoomViewport.pageScaleDelta()); |
203 | 277 |
204 m_pageScaleAnimation = CCPageScaleAnimation::create(scrollTotal, scaleTotal, m_deviceViewportSize, scaledContentSize, startTime); | 278 m_pageScaleAnimation = CCPageScaleAnimation::create(scrollTotal, scaleTotal, m_deviceViewportSize, scaledContentSize, startTime); |
205 | 279 |
206 if (anchorPoint) { | 280 if (anchorPoint) { |
207 IntSize windowAnchor(targetPosition); | 281 IntSize windowAnchor(targetPosition); |
208 windowAnchor.scale(scaleTotal / pageScale); | 282 windowAnchor.scale(scaleTotal / pageScale); |
209 windowAnchor -= scrollTotal; | 283 windowAnchor -= scrollTotal; |
210 m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, duration); | 284 m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, duration); |
211 } else | 285 } else |
212 m_pageScaleAnimation->zoomTo(targetPosition, pageScale, duration); | 286 m_pageScaleAnimation->zoomTo(targetPosition, pageScale, duration); |
(...skipping 14 matching lines...) Expand all Loading... | |
227 // damage rect. The root damage rect is then used to scissor each surface. | 301 // damage rect. The root damage rect is then used to scissor each surface. |
228 | 302 |
229 for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) { | 303 for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) { |
230 CCLayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex]; | 304 CCLayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex]; |
231 CCRenderSurface* renderSurface = renderSurfaceLayer->renderSurface(); | 305 CCRenderSurface* renderSurface = renderSurfaceLayer->renderSurface(); |
232 ASSERT(renderSurface); | 306 ASSERT(renderSurface); |
233 renderSurface->damageTracker()->updateDamageTrackingState(renderSurface- >layerList(), renderSurfaceLayer->id(), renderSurface->surfacePropertyChangedOnl yFromDescendant(), renderSurface->contentRect(), renderSurfaceLayer->maskLayer() , renderSurfaceLayer->filters()); | 307 renderSurface->damageTracker()->updateDamageTrackingState(renderSurface- >layerList(), renderSurfaceLayer->id(), renderSurface->surfacePropertyChangedOnl yFromDescendant(), renderSurface->contentRect(), renderSurfaceLayer->maskLayer() , renderSurfaceLayer->filters()); |
234 } | 308 } |
235 } | 309 } |
236 | 310 |
311 void CCLayerTreeHostImpl::updateRootScrollLayerImplTransform() | |
312 { | |
313 if (m_rootScrollLayerImpl) { | |
314 m_rootScrollLayerImpl->setImplTransform(implTransform()); | |
315 } | |
316 } | |
317 | |
237 void CCLayerTreeHostImpl::calculateRenderSurfaceLayerList(CCLayerList& renderSur faceLayerList) | 318 void CCLayerTreeHostImpl::calculateRenderSurfaceLayerList(CCLayerList& renderSur faceLayerList) |
238 { | 319 { |
239 ASSERT(renderSurfaceLayerList.isEmpty()); | 320 ASSERT(renderSurfaceLayerList.isEmpty()); |
240 ASSERT(m_rootLayerImpl); | 321 ASSERT(m_rootLayerImpl); |
241 ASSERT(m_renderer); // For maxTextureSize. | 322 ASSERT(m_renderer); // For maxTextureSize. |
242 | 323 |
243 { | 324 { |
325 updateRootScrollLayerImplTransform(); | |
326 | |
244 TRACE_EVENT0("cc", "CCLayerTreeHostImpl::calcDrawEtc"); | 327 TRACE_EVENT0("cc", "CCLayerTreeHostImpl::calcDrawEtc"); |
245 CCLayerTreeHostCommon::calculateDrawTransforms(m_rootLayerImpl.get(), de viceViewportSize(), m_deviceScaleFactor, &m_layerSorter, rendererCapabilities(). maxTextureSize, renderSurfaceLayerList); | 328 CCLayerTreeHostCommon::calculateDrawTransforms(m_rootLayerImpl.get(), de viceViewportSize(), m_deviceScaleFactor, &m_layerSorter, rendererCapabilities(). maxTextureSize, renderSurfaceLayerList); |
246 CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList); | 329 CCLayerTreeHostCommon::calculateVisibleRects(renderSurfaceLayerList); |
247 | 330 |
248 trackDamageForAllSurfaces(m_rootLayerImpl.get(), renderSurfaceLayerList) ; | 331 trackDamageForAllSurfaces(m_rootLayerImpl.get(), renderSurfaceLayerList) ; |
249 } | 332 } |
250 } | 333 } |
251 | 334 |
252 void CCLayerTreeHostImpl::FrameData::appendRenderPass(PassOwnPtr<CCRenderPass> r enderPass) | 335 void CCLayerTreeHostImpl::FrameData::appendRenderPass(PassOwnPtr<CCRenderPass> r enderPass) |
253 { | 336 { |
(...skipping 508 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
762 } | 845 } |
763 | 846 |
764 void CCLayerTreeHostImpl::setViewportSize(const IntSize& layoutViewportSize, con st IntSize& deviceViewportSize) | 847 void CCLayerTreeHostImpl::setViewportSize(const IntSize& layoutViewportSize, con st IntSize& deviceViewportSize) |
765 { | 848 { |
766 if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_de viceViewportSize) | 849 if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_de viceViewportSize) |
767 return; | 850 return; |
768 | 851 |
769 m_layoutViewportSize = layoutViewportSize; | 852 m_layoutViewportSize = layoutViewportSize; |
770 m_deviceViewportSize = deviceViewportSize; | 853 m_deviceViewportSize = deviceViewportSize; |
771 | 854 |
855 m_pinchZoomViewport.setUnpinchedBounds(FloatSize(layoutViewportSize)); | |
856 | |
772 updateMaxScrollPosition(); | 857 updateMaxScrollPosition(); |
773 | 858 |
774 if (m_renderer) | 859 if (m_renderer) |
775 m_renderer->viewportChanged(); | 860 m_renderer->viewportChanged(); |
776 | 861 |
777 m_client->onCanDrawStateChanged(canDraw()); | 862 m_client->onCanDrawStateChanged(canDraw()); |
778 } | 863 } |
779 | 864 |
780 static void adjustScrollsForPageScaleChange(CCLayerImpl* layerImpl, float pageSc aleChange) | 865 static void adjustScrollsForPageScaleChange(CCLayerImpl* layerImpl, float pageSc aleChange) |
781 { | 866 { |
(...skipping 13 matching lines...) Expand all Loading... | |
795 | 880 |
796 void CCLayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor) | 881 void CCLayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor) |
797 { | 882 { |
798 if (deviceScaleFactor == m_deviceScaleFactor) | 883 if (deviceScaleFactor == m_deviceScaleFactor) |
799 return; | 884 return; |
800 m_deviceScaleFactor = deviceScaleFactor; | 885 m_deviceScaleFactor = deviceScaleFactor; |
801 | 886 |
802 updateMaxScrollPosition(); | 887 updateMaxScrollPosition(); |
803 } | 888 } |
804 | 889 |
890 float CCLayerTreeHostImpl::pageScaleFactor() const | |
891 { | |
892 return m_pinchZoomViewport.pageScaleFactor(); | |
893 } | |
805 | 894 |
806 void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScale, float min PageScale, float maxPageScale) | 895 void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScaleFactor, flo at minPageScaleFactor, float maxPageScaleFactor) |
807 { | 896 { |
808 if (!pageScale) | 897 if (!pageScaleFactor) |
809 return; | 898 return; |
810 | 899 |
811 if (m_sentPageScaleDelta == 1 && pageScale == m_pageScale && minPageScale == m_minPageScale && maxPageScale == m_maxPageScale) | 900 float pageScaleChange = pageScaleFactor / m_pinchZoomViewport.pageScaleFacto r(); |
812 return; | 901 m_pinchZoomViewport.setPageScaleFactorAndLimits(pageScaleFactor, minPageScal eFactor, maxPageScaleFactor); |
813 | 902 |
814 m_minPageScale = minPageScale; | 903 if (!CCSettings::pageScalePinchZoomEnabled()) { |
815 m_maxPageScale = maxPageScale; | 904 if (pageScaleChange != 1) |
816 | 905 adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChan ge); |
817 float pageScaleChange = pageScale / m_pageScale; | 906 } |
818 m_pageScale = pageScale; | |
819 | |
820 if (pageScaleChange != 1) | |
821 adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange); | |
822 | 907 |
823 // Clamp delta to limits and refresh display matrix. | 908 // Clamp delta to limits and refresh display matrix. |
824 setPageScaleDelta(m_pageScaleDelta / m_sentPageScaleDelta); | 909 setPageScaleDelta(m_pinchZoomViewport.pageScaleDelta() / m_pinchZoomViewport .sentPageScaleDelta()); |
825 m_sentPageScaleDelta = 1; | 910 m_pinchZoomViewport.setSentPageScaleDelta(1); |
826 if (m_rootScrollLayerImpl) | |
827 m_rootScrollLayerImpl->setPageScaleDelta(m_pageScaleDelta); | |
828 } | 911 } |
829 | 912 |
830 void CCLayerTreeHostImpl::setPageScaleDelta(float delta) | 913 void CCLayerTreeHostImpl::setPageScaleDelta(float delta) |
831 { | 914 { |
832 // Clamp to the current min/max limits. | 915 m_pinchZoomViewport.setPageScaleDelta(delta); |
833 float finalMagnifyScale = m_pageScale * delta; | |
834 if (m_minPageScale && finalMagnifyScale < m_minPageScale) | |
835 delta = m_minPageScale / m_pageScale; | |
836 else if (m_maxPageScale && finalMagnifyScale > m_maxPageScale) | |
837 delta = m_maxPageScale / m_pageScale; | |
838 | |
839 if (delta == m_pageScaleDelta) | |
840 return; | |
841 | |
842 m_pageScaleDelta = delta; | |
843 | 916 |
844 updateMaxScrollPosition(); | 917 updateMaxScrollPosition(); |
845 if (m_rootScrollLayerImpl) | |
846 m_rootScrollLayerImpl->setPageScaleDelta(m_pageScaleDelta); | |
847 } | 918 } |
848 | 919 |
849 void CCLayerTreeHostImpl::updateMaxScrollPosition() | 920 void CCLayerTreeHostImpl::updateMaxScrollPosition() |
850 { | 921 { |
851 if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size()) | 922 if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size()) |
852 return; | 923 return; |
853 | 924 |
854 FloatSize viewBounds = m_deviceViewportSize; | 925 FloatSize viewBounds = m_deviceViewportSize; |
855 if (CCLayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) { | 926 if (CCLayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) { |
856 // Compensate for non-overlay scrollbars. | 927 // Compensate for non-overlay scrollbars. |
857 if (clipLayer->masksToBounds()) { | 928 if (clipLayer->masksToBounds()) { |
858 viewBounds = clipLayer->bounds(); | 929 viewBounds = clipLayer->bounds(); |
859 viewBounds.scale(m_deviceScaleFactor); | 930 viewBounds.scale(m_deviceScaleFactor); |
860 } | 931 } |
861 } | 932 } |
862 viewBounds.scale(1 / m_pageScaleDelta); | |
863 | 933 |
864 // maxScroll is computed in physical pixels, but scroll positions are in lay out pixels. | 934 IntSize contentBounds = contentSize(); |
865 IntSize maxScroll = contentSize() - expandedIntSize(viewBounds); | 935 if (CCSettings::pageScalePinchZoomEnabled()) { |
936 // Pinch with pageScale scrolls entirely in layout space. contentSize | |
937 // returns the bounds including the page scale factor, so calculate the | |
938 // pre page-scale layout size here. | |
939 float pageScaleFactor = m_pinchZoomViewport.pageScaleFactor(); | |
940 contentBounds.setWidth(contentBounds.width() / pageScaleFactor); | |
941 contentBounds.setHeight(contentBounds.height() / pageScaleFactor); | |
942 } else { | |
943 viewBounds.scale(1 / m_pinchZoomViewport.pageScaleDelta()); | |
944 } | |
945 | |
946 IntSize maxScroll = contentBounds - expandedIntSize(viewBounds); | |
866 maxScroll.scale(1 / m_deviceScaleFactor); | 947 maxScroll.scale(1 / m_deviceScaleFactor); |
948 | |
867 // The viewport may be larger than the contents in some cases, such as | 949 // The viewport may be larger than the contents in some cases, such as |
868 // having a vertical scrollbar but no horizontal overflow. | 950 // having a vertical scrollbar but no horizontal overflow. |
869 maxScroll.clampNegativeToZero(); | 951 maxScroll.clampNegativeToZero(); |
870 | 952 |
871 m_rootScrollLayerImpl->setMaxScrollPosition(maxScroll); | 953 m_rootScrollLayerImpl->setMaxScrollPosition(maxScroll); |
872 } | 954 } |
873 | 955 |
874 void CCLayerTreeHostImpl::setNeedsRedraw() | 956 void CCLayerTreeHostImpl::setNeedsRedraw() |
875 { | 957 { |
876 m_client->setNeedsRedrawOnImplThread(); | 958 m_client->setNeedsRedrawOnImplThread(); |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
939 m_currentlyScrollingLayerImpl = potentiallyScrollingLayerImpl; | 1021 m_currentlyScrollingLayerImpl = potentiallyScrollingLayerImpl; |
940 // Gesture events need to be transformed from screen coordinates to loca l layer coordinates | 1022 // Gesture events need to be transformed from screen coordinates to loca l layer coordinates |
941 // so that the scrolling contents exactly follow the user's finger. In c ontrast, wheel | 1023 // so that the scrolling contents exactly follow the user's finger. In c ontrast, wheel |
942 // events are already in local layer coordinates so we can just apply th em directly. | 1024 // events are already in local layer coordinates so we can just apply th em directly. |
943 m_scrollDeltaIsInScreenSpace = (type == Gesture); | 1025 m_scrollDeltaIsInScreenSpace = (type == Gesture); |
944 return ScrollStarted; | 1026 return ScrollStarted; |
945 } | 1027 } |
946 return ScrollIgnored; | 1028 return ScrollIgnored; |
947 } | 1029 } |
948 | 1030 |
949 static FloatSize scrollLayerWithScreenSpaceDelta(CCLayerImpl& layerImpl, const F loatPoint& screenSpacePoint, const FloatSize& screenSpaceDelta) | 1031 static FloatSize scrollLayerWithScreenSpaceDelta(CCPinchZoomViewport* viewport, CCLayerImpl& layerImpl, const FloatPoint& screenSpacePoint, const FloatSize& scr eenSpaceDelta) |
950 { | 1032 { |
951 // Layers with non-invertible screen space transforms should not have passed the scroll hit | 1033 // Layers with non-invertible screen space transforms should not have passed the scroll hit |
952 // test in the first place. | 1034 // test in the first place. |
953 ASSERT(layerImpl.screenSpaceTransform().isInvertible()); | 1035 ASSERT(layerImpl.screenSpaceTransform().isInvertible()); |
954 WebTransformationMatrix inverseScreenSpaceTransform = layerImpl.screenSpaceT ransform().inverse(); | 1036 WebTransformationMatrix inverseScreenSpaceTransform = layerImpl.screenSpaceT ransform().inverse(); |
955 | 1037 |
956 // First project the scroll start and end points to local layer space to fin d the scroll delta | 1038 // First project the scroll start and end points to local layer space to fin d the scroll delta |
957 // in layer coordinates. | 1039 // in layer coordinates. |
958 bool startClipped, endClipped; | 1040 bool startClipped, endClipped; |
959 FloatPoint screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta; | 1041 FloatPoint screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta; |
960 FloatPoint localStartPoint = CCMathUtil::projectPoint(inverseScreenSpaceTran sform, screenSpacePoint, startClipped); | 1042 FloatPoint localStartPoint = CCMathUtil::projectPoint(inverseScreenSpaceTran sform, screenSpacePoint, startClipped); |
961 FloatPoint localEndPoint = CCMathUtil::projectPoint(inverseScreenSpaceTransf orm, screenSpaceEndPoint, endClipped); | 1043 FloatPoint localEndPoint = CCMathUtil::projectPoint(inverseScreenSpaceTransf orm, screenSpaceEndPoint, endClipped); |
962 | 1044 |
963 // In general scroll point coordinates should not get clipped. | 1045 // In general scroll point coordinates should not get clipped. |
964 ASSERT(!startClipped); | 1046 ASSERT(!startClipped); |
965 ASSERT(!endClipped); | 1047 ASSERT(!endClipped); |
966 if (startClipped || endClipped) | 1048 if (startClipped || endClipped) |
967 return FloatSize(); | 1049 return FloatSize(); |
968 | 1050 |
969 // Apply the scroll delta. | 1051 // Apply the scroll delta. |
970 FloatSize previousDelta(layerImpl.scrollDelta()); | 1052 FloatSize previousDelta(layerImpl.scrollDelta()); |
971 layerImpl.scrollBy(localEndPoint - localStartPoint); | 1053 FloatSize unscrolled = layerImpl.scrollBy(localEndPoint - localStartPoint); |
1054 | |
1055 if (viewport) | |
1056 viewport->applyScroll(unscrolled); | |
972 | 1057 |
973 // Calculate the applied scroll delta in screen space coordinates. | 1058 // Calculate the applied scroll delta in screen space coordinates. |
974 FloatPoint actualLocalEndPoint = localStartPoint + layerImpl.scrollDelta() - previousDelta; | 1059 FloatPoint actualLocalEndPoint = localStartPoint + layerImpl.scrollDelta() - previousDelta; |
975 FloatPoint actualScreenSpaceEndPoint = CCMathUtil::mapPoint(layerImpl.screen SpaceTransform(), actualLocalEndPoint, endClipped); | 1060 FloatPoint actualScreenSpaceEndPoint = CCMathUtil::mapPoint(layerImpl.screen SpaceTransform(), actualLocalEndPoint, endClipped); |
976 ASSERT(!endClipped); | 1061 ASSERT(!endClipped); |
977 if (endClipped) | 1062 if (endClipped) |
978 return FloatSize(); | 1063 return FloatSize(); |
979 return actualScreenSpaceEndPoint - screenSpacePoint; | 1064 return actualScreenSpaceEndPoint - screenSpacePoint; |
980 } | 1065 } |
981 | 1066 |
(...skipping 11 matching lines...) Expand all Loading... | |
993 return; | 1078 return; |
994 | 1079 |
995 FloatSize pendingDelta(scrollDelta); | 1080 FloatSize pendingDelta(scrollDelta); |
996 | 1081 |
997 pendingDelta.scale(m_deviceScaleFactor); | 1082 pendingDelta.scale(m_deviceScaleFactor); |
998 | 1083 |
999 for (CCLayerImpl* layerImpl = m_currentlyScrollingLayerImpl; layerImpl; laye rImpl = layerImpl->parent()) { | 1084 for (CCLayerImpl* layerImpl = m_currentlyScrollingLayerImpl; layerImpl; laye rImpl = layerImpl->parent()) { |
1000 if (!layerImpl->scrollable()) | 1085 if (!layerImpl->scrollable()) |
1001 continue; | 1086 continue; |
1002 | 1087 |
1088 CCPinchZoomViewport* viewport = layerImpl == m_rootScrollLayerImpl ? &m_ pinchZoomViewport : 0; | |
1003 FloatSize appliedDelta; | 1089 FloatSize appliedDelta; |
1004 if (m_scrollDeltaIsInScreenSpace) | 1090 if (m_scrollDeltaIsInScreenSpace) |
1005 appliedDelta = scrollLayerWithScreenSpaceDelta(*layerImpl, viewportP oint, pendingDelta); | 1091 appliedDelta = scrollLayerWithScreenSpaceDelta(viewport, *layerImpl, viewportPoint, pendingDelta); |
1006 else | 1092 else |
1007 appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta); | 1093 appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta); |
1008 | 1094 |
1009 // If the layer wasn't able to move, try the next one in the hierarchy. | 1095 // If the layer wasn't able to move, try the next one in the hierarchy. |
1010 float moveThresholdSquared = 0.1f * 0.1f; | 1096 float moveThresholdSquared = 0.1f * 0.1f; |
1011 if (appliedDelta.diagonalLengthSquared() < moveThresholdSquared) | 1097 if (appliedDelta.diagonalLengthSquared() < moveThresholdSquared) |
1012 continue; | 1098 continue; |
1013 | 1099 |
1014 // If the applied delta is within 45 degrees of the input delta, bail ou t to make it easier | 1100 // If the applied delta is within 45 degrees of the input delta, bail ou t to make it easier |
1015 // to scroll just one layer in one direction without affecting any of it s parents. | 1101 // to scroll just one layer in one direction without affecting any of it s parents. |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1060 TRACE_EVENT0("cc", "CCLayerTreeHostImpl::pinchGestureUpdate"); | 1146 TRACE_EVENT0("cc", "CCLayerTreeHostImpl::pinchGestureUpdate"); |
1061 | 1147 |
1062 if (!m_rootScrollLayerImpl) | 1148 if (!m_rootScrollLayerImpl) |
1063 return; | 1149 return; |
1064 | 1150 |
1065 if (m_previousPinchAnchor == IntPoint::zero()) | 1151 if (m_previousPinchAnchor == IntPoint::zero()) |
1066 m_previousPinchAnchor = anchor; | 1152 m_previousPinchAnchor = anchor; |
1067 | 1153 |
1068 // Keep the center-of-pinch anchor specified by (x, y) in a stable | 1154 // Keep the center-of-pinch anchor specified by (x, y) in a stable |
1069 // position over the course of the magnify. | 1155 // position over the course of the magnify. |
1070 FloatPoint previousScaleAnchor(m_previousPinchAnchor.x() / m_pageScaleDelta, m_previousPinchAnchor.y() / m_pageScaleDelta); | 1156 float pageScaleDelta = m_pinchZoomViewport.pageScaleDelta(); |
1071 setPageScaleDelta(m_pageScaleDelta * magnifyDelta); | 1157 FloatPoint previousScaleAnchor(m_previousPinchAnchor.x() / pageScaleDelta, |
1072 FloatPoint newScaleAnchor(anchor.x() / m_pageScaleDelta, anchor.y() / m_page ScaleDelta); | 1158 m_previousPinchAnchor.y() / pageScaleDelta); |
1159 setPageScaleDelta(pageScaleDelta * magnifyDelta); | |
1160 pageScaleDelta = m_pinchZoomViewport.pageScaleDelta(); | |
1161 FloatPoint newScaleAnchor(anchor.x() / pageScaleDelta, anchor.y() / pageScal eDelta); | |
1073 FloatSize move = previousScaleAnchor - newScaleAnchor; | 1162 FloatSize move = previousScaleAnchor - newScaleAnchor; |
1074 | 1163 |
1075 m_previousPinchAnchor = anchor; | 1164 m_previousPinchAnchor = anchor; |
1076 | 1165 |
1077 m_rootScrollLayerImpl->scrollBy(roundedIntSize(move)); | 1166 if (CCSettings::pageScalePinchZoomEnabled()) { |
1167 // Compute the application of the delta with respect to the current page zoom of the page. | |
1168 move.scale(1 / (m_pinchZoomViewport.pageScaleFactor() * m_deviceScaleFac tor)); | |
1169 } | |
1170 | |
1171 FloatSize scrollOverflow = CCSettings::pageScalePinchZoomEnabled() ? m_pinch ZoomViewport.applyScroll(move) : move; | |
1172 m_rootScrollLayerImpl->scrollBy(roundedIntSize(scrollOverflow)); | |
1078 | 1173 |
1079 if (m_rootScrollLayerImpl->scrollbarAnimationController()) | 1174 if (m_rootScrollLayerImpl->scrollbarAnimationController()) |
1080 m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUp date(); | 1175 m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUp date(); |
1081 | 1176 |
1082 m_client->setNeedsCommitOnImplThread(); | 1177 m_client->setNeedsCommitOnImplThread(); |
1083 m_client->setNeedsRedrawOnImplThread(); | 1178 m_client->setNeedsRedrawOnImplThread(); |
1084 } | 1179 } |
1085 | 1180 |
1086 void CCLayerTreeHostImpl::pinchGestureEnd() | 1181 void CCLayerTreeHostImpl::pinchGestureEnd() |
1087 { | 1182 { |
1088 m_pinchGestureActive = false; | 1183 m_pinchGestureActive = false; |
1089 | 1184 |
1090 if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationContro ller()) | 1185 if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationContro ller()) |
1091 m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureEn d(); | 1186 m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureEn d(); |
1092 | 1187 |
1093 m_client->setNeedsCommitOnImplThread(); | 1188 m_client->setNeedsCommitOnImplThread(); |
1094 } | 1189 } |
1095 | 1190 |
1096 void CCLayerTreeHostImpl::computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scroll Info) | 1191 void CCLayerTreeHostImpl::computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scroll Info) |
1097 { | 1192 { |
1098 float pageScale = m_pageScaleAnimation->finalPageScale(); | 1193 float pageScale = m_pageScaleAnimation->finalPageScale(); |
1099 IntSize scrollOffset = m_pageScaleAnimation->finalScrollOffset(); | 1194 IntSize scrollOffset = m_pageScaleAnimation->finalScrollOffset(); |
1100 scrollOffset.scale(m_pageScale / pageScale); | 1195 scrollOffset.scale(m_pinchZoomViewport.pageScaleFactor() / pageScale); |
1101 makeScrollAndScaleSet(scrollInfo, scrollOffset, pageScale); | 1196 makeScrollAndScaleSet(scrollInfo, scrollOffset, pageScale); |
1102 } | 1197 } |
1103 | 1198 |
1104 void CCLayerTreeHostImpl::computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo ) | 1199 void CCLayerTreeHostImpl::computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo ) |
1105 { | 1200 { |
1106 if (!m_rootScrollLayerImpl) | 1201 if (!m_rootScrollLayerImpl) |
1107 return; | 1202 return; |
1108 | 1203 |
1109 // Only send fake scroll/zoom deltas if we're pinch zooming out by a | 1204 // Only send fake scroll/zoom deltas if we're pinch zooming out by a |
1110 // significant amount. This also ensures only one fake delta set will be | 1205 // significant amount. This also ensures only one fake delta set will be |
1111 // sent. | 1206 // sent. |
1112 const float pinchZoomOutSensitivity = 0.95f; | 1207 const float pinchZoomOutSensitivity = 0.95f; |
1113 if (m_pageScaleDelta > pinchZoomOutSensitivity) | 1208 if (m_pinchZoomViewport.pageScaleDelta() > pinchZoomOutSensitivity) |
1114 return; | 1209 return; |
1115 | 1210 |
1116 // Compute where the scroll offset/page scale would be if fully pinch-zoomed | 1211 // Compute where the scroll offset/page scale would be if fully pinch-zoomed |
1117 // out from the anchor point. | 1212 // out from the anchor point. |
1118 IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta()); | 1213 IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta()); |
1119 scrollBegin.scale(m_pageScaleDelta); | 1214 scrollBegin.scale(m_pinchZoomViewport.pageScaleDelta()); |
1120 float scaleBegin = m_pageScale * m_pageScaleDelta; | 1215 float scaleBegin = m_pinchZoomViewport.totalPageScaleFactor(); |
1121 float pageScaleDeltaToSend = m_minPageScale / m_pageScale; | 1216 float pageScaleDeltaToSend = m_pinchZoomViewport.minPageScaleFactor() / m_pi nchZoomViewport.pageScaleFactor(); |
1122 FloatSize scaledContentsSize = contentSize(); | 1217 FloatSize scaledContentsSize = contentSize(); |
1123 scaledContentsSize.scale(pageScaleDeltaToSend); | 1218 scaledContentsSize.scale(pageScaleDeltaToSend); |
1124 | 1219 |
1125 FloatSize anchor = toSize(m_previousPinchAnchor); | 1220 FloatSize anchor = toSize(m_previousPinchAnchor); |
1126 FloatSize scrollEnd = scrollBegin + anchor; | 1221 FloatSize scrollEnd = scrollBegin + anchor; |
1127 scrollEnd.scale(m_minPageScale / scaleBegin); | 1222 scrollEnd.scale(m_pinchZoomViewport.minPageScaleFactor() / scaleBegin); |
1128 scrollEnd -= anchor; | 1223 scrollEnd -= anchor; |
1129 scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_deviceV iewportSize)).expandedTo(FloatSize(0, 0)); | 1224 scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_deviceV iewportSize)).expandedTo(FloatSize(0, 0)); |
1130 scrollEnd.scale(1 / pageScaleDeltaToSend); | 1225 scrollEnd.scale(1 / pageScaleDeltaToSend); |
1131 scrollEnd.scale(m_deviceScaleFactor); | 1226 scrollEnd.scale(m_deviceScaleFactor); |
1132 | 1227 |
1133 makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_minPageScale) ; | 1228 makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_pinchZoomView port.minPageScaleFactor()); |
1134 } | 1229 } |
1135 | 1230 |
1136 void CCLayerTreeHostImpl::makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale) | 1231 void CCLayerTreeHostImpl::makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale) |
1137 { | 1232 { |
1138 if (!m_rootScrollLayerImpl) | 1233 if (!m_rootScrollLayerImpl) |
1139 return; | 1234 return; |
1140 | 1235 |
1141 CCLayerTreeHostCommon::ScrollUpdateInfo scroll; | 1236 CCLayerTreeHostCommon::ScrollUpdateInfo scroll; |
1142 scroll.layerId = m_rootScrollLayerImpl->id(); | 1237 scroll.layerId = m_rootScrollLayerImpl->id(); |
1143 scroll.scrollDelta = scrollOffset - toSize(m_rootScrollLayerImpl->scrollPosi tion()); | 1238 scroll.scrollDelta = scrollOffset - toSize(m_rootScrollLayerImpl->scrollPosi tion()); |
1144 scrollInfo->scrolls.append(scroll); | 1239 scrollInfo->scrolls.append(scroll); |
1145 m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta); | 1240 m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta); |
1146 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = pageScale / m_pageScale; | 1241 scrollInfo->pageScaleDelta = pageScale / m_pinchZoomViewport.pageScaleFactor (); |
1242 m_pinchZoomViewport.setSentPageScaleDelta(scrollInfo->pageScaleDelta); | |
1147 } | 1243 } |
1148 | 1244 |
1149 static void collectScrollDeltas(CCScrollAndScaleSet* scrollInfo, CCLayerImpl* la yerImpl) | 1245 static void collectScrollDeltas(CCScrollAndScaleSet* scrollInfo, CCLayerImpl* la yerImpl) |
1150 { | 1246 { |
1151 if (!layerImpl) | 1247 if (!layerImpl) |
1152 return; | 1248 return; |
1153 | 1249 |
1154 if (!layerImpl->scrollDelta().isZero()) { | 1250 if (!layerImpl->scrollDelta().isZero()) { |
1155 IntSize scrollDelta = flooredIntSize(layerImpl->scrollDelta()); | 1251 IntSize scrollDelta = flooredIntSize(layerImpl->scrollDelta()); |
1156 CCLayerTreeHostCommon::ScrollUpdateInfo scroll; | 1252 CCLayerTreeHostCommon::ScrollUpdateInfo scroll; |
1157 scroll.layerId = layerImpl->id(); | 1253 scroll.layerId = layerImpl->id(); |
1158 scroll.scrollDelta = scrollDelta; | 1254 scroll.scrollDelta = scrollDelta; |
1159 scrollInfo->scrolls.append(scroll); | 1255 scrollInfo->scrolls.append(scroll); |
1160 layerImpl->setSentScrollDelta(scrollDelta); | 1256 layerImpl->setSentScrollDelta(scrollDelta); |
1161 } | 1257 } |
1162 | 1258 |
1163 for (size_t i = 0; i < layerImpl->children().size(); ++i) | 1259 for (size_t i = 0; i < layerImpl->children().size(); ++i) |
1164 collectScrollDeltas(scrollInfo, layerImpl->children()[i]); | 1260 collectScrollDeltas(scrollInfo, layerImpl->children()[i]); |
1165 } | 1261 } |
1166 | 1262 |
1167 PassOwnPtr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas() | 1263 PassOwnPtr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas() |
1168 { | 1264 { |
1169 OwnPtr<CCScrollAndScaleSet> scrollInfo = adoptPtr(new CCScrollAndScaleSet()) ; | 1265 OwnPtr<CCScrollAndScaleSet> scrollInfo = adoptPtr(new CCScrollAndScaleSet()) ; |
1170 | 1266 |
1171 if (m_pinchGestureActive || m_pageScaleAnimation) { | 1267 if (m_pinchGestureActive || m_pageScaleAnimation) { |
1172 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = 1; | 1268 scrollInfo->pageScaleDelta = 1; |
1173 if (m_pinchGestureActive) | 1269 m_pinchZoomViewport.setSentPageScaleDelta(1); |
1174 computePinchZoomDeltas(scrollInfo.get()); | 1270 // If pinch zoom is applied in the impl thread, then there is no need to |
aelias_OOO_until_Jul13
2012/09/26 23:15:09
There is still a need for this in some form. It's
Jeff Timanus
2012/10/01 21:42:36
Done.
| |
1175 else if (m_pageScaleAnimation.get()) | 1271 // calculate these intermediate scale deltas. |
1176 computeDoubleTapZoomDeltas(scrollInfo.get()); | 1272 if (!CCSettings::pageScalePinchZoomEnabled()) { |
1273 if (m_pinchGestureActive) | |
1274 computePinchZoomDeltas(scrollInfo.get()); | |
1275 else if (m_pageScaleAnimation.get()) | |
1276 computeDoubleTapZoomDeltas(scrollInfo.get()); | |
1277 } | |
1177 return scrollInfo.release(); | 1278 return scrollInfo.release(); |
1178 } | 1279 } |
1179 | 1280 |
1180 collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get()); | 1281 collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get()); |
1181 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = m_pageScaleDelta; | 1282 scrollInfo->pageScaleDelta = m_pinchZoomViewport.pageScaleDelta(); |
1283 m_pinchZoomViewport.setSentPageScaleDelta(scrollInfo->pageScaleDelta); | |
1182 | 1284 |
1183 return scrollInfo.release(); | 1285 return scrollInfo.release(); |
1184 } | 1286 } |
1185 | 1287 |
1288 WebTransformationMatrix CCLayerTreeHostImpl::implTransform() const | |
aelias_OOO_until_Jul13
2012/09/26 23:15:09
Move this method into CCPinchZoomViewport.
Jeff Timanus
2012/10/01 21:42:36
Done.
| |
1289 { | |
1290 WebTransformationMatrix transform; | |
1291 transform.scale(m_pinchZoomViewport.pageScaleDelta()); | |
1292 | |
1293 // If the pinch state is applied in the impl, then push it to the | |
1294 // impl transform, otherwise the scale is handled by WebCore. | |
1295 if (CCSettings::pageScalePinchZoomEnabled()) { | |
1296 transform.scale(m_pinchZoomViewport.pageScaleFactor()); | |
1297 transform.translate(-m_pinchZoomViewport.scrollDelta().x(), | |
1298 -m_pinchZoomViewport.scrollDelta().y()); | |
1299 } | |
1300 | |
1301 return transform; | |
1302 } | |
1303 | |
1186 void CCLayerTreeHostImpl::setFullRootLayerDamage() | 1304 void CCLayerTreeHostImpl::setFullRootLayerDamage() |
1187 { | 1305 { |
1188 if (m_rootLayerImpl) { | 1306 if (m_rootLayerImpl) { |
1189 CCRenderSurface* renderSurface = m_rootLayerImpl->renderSurface(); | 1307 CCRenderSurface* renderSurface = m_rootLayerImpl->renderSurface(); |
1190 if (renderSurface) | 1308 if (renderSurface) |
1191 renderSurface->damageTracker()->forceFullDamageNextUpdate(); | 1309 renderSurface->damageTracker()->forceFullDamageNextUpdate(); |
1192 } | 1310 } |
1193 } | 1311 } |
1194 | 1312 |
1195 void CCLayerTreeHostImpl::animatePageScale(double monotonicTime) | 1313 void CCLayerTreeHostImpl::animatePageScale(double monotonicTime) |
1196 { | 1314 { |
1197 if (!m_pageScaleAnimation || !m_rootScrollLayerImpl) | 1315 if (!m_pageScaleAnimation || !m_rootScrollLayerImpl) |
1198 return; | 1316 return; |
1199 | 1317 |
1200 IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta()); | 1318 IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta()); |
1201 | 1319 |
1202 setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_p ageScale); | 1320 setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_p inchZoomViewport.pageScaleFactor()); |
1203 IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime) ; | 1321 IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime) ; |
1204 nextScroll.scale(1 / m_pageScaleDelta); | 1322 nextScroll.scale(1 / m_pinchZoomViewport.pageScaleDelta()); |
1205 m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal); | 1323 m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal); |
1206 m_client->setNeedsRedrawOnImplThread(); | 1324 m_client->setNeedsRedrawOnImplThread(); |
1207 | 1325 |
1208 if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) { | 1326 if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) { |
1209 m_pageScaleAnimation.clear(); | 1327 m_pageScaleAnimation.clear(); |
1210 m_client->setNeedsCommitOnImplThread(); | 1328 m_client->setNeedsCommitOnImplThread(); |
1211 } | 1329 } |
1212 } | 1330 } |
1213 | 1331 |
1214 void CCLayerTreeHostImpl::animateLayers(double monotonicTime, double wallClockTi me) | 1332 void CCLayerTreeHostImpl::animateLayers(double monotonicTime, double wallClockTi me) |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1306 | 1424 |
1307 CCScrollbarAnimationController* scrollbarController = layer->scrollbarAnimat ionController(); | 1425 CCScrollbarAnimationController* scrollbarController = layer->scrollbarAnimat ionController(); |
1308 if (scrollbarController && scrollbarController->animate(monotonicTime)) | 1426 if (scrollbarController && scrollbarController->animate(monotonicTime)) |
1309 m_client->setNeedsRedrawOnImplThread(); | 1427 m_client->setNeedsRedrawOnImplThread(); |
1310 | 1428 |
1311 for (size_t i = 0; i < layer->children().size(); ++i) | 1429 for (size_t i = 0; i < layer->children().size(); ++i) |
1312 animateScrollbarsRecursive(layer->children()[i], monotonicTime); | 1430 animateScrollbarsRecursive(layer->children()[i], monotonicTime); |
1313 } | 1431 } |
1314 | 1432 |
1315 } // namespace cc | 1433 } // namespace cc |
OLD | NEW |