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 30 matching lines...) Expand all Loading... | |
41 return; | 41 return; |
42 } | 42 } |
43 | 43 |
44 TRACE_EVENT_ASYNC_END0("webkit", "CCLayerTreeHostImpl::setVisible", id); | 44 TRACE_EVENT_ASYNC_END0("webkit", "CCLayerTreeHostImpl::setVisible", id); |
45 } | 45 } |
46 | 46 |
47 } // namespace | 47 } // namespace |
48 | 48 |
49 namespace WebCore { | 49 namespace WebCore { |
50 | 50 |
51 FloatRect CCPinchZoomViewport::bounds() const | |
52 { | |
53 FloatSize scaledBounds = m_unpinchedBounds; | |
54 if (m_pageScaleFactor > 1) | |
55 scaledBounds.scale(1 / m_pageScaleFactor); | |
56 | |
57 FloatRect bounds; | |
58 bounds.setSize(scaledBounds); | |
59 bounds.setLocation(m_pinchViewportScrollDelta); | |
60 | |
61 return bounds; | |
62 } | |
63 | |
64 FloatSize CCPinchZoomViewport::applyScroll(FloatSize& delta) | |
65 { | |
66 FloatSize overflow; | |
67 FloatRect pinchedBounds = bounds(); | |
68 | |
69 pinchedBounds.move(delta); | |
70 if (pinchedBounds.x() < 0) { | |
71 pinchedBounds.setX(0); | |
72 overflow.setWidth(pinchedBounds.x()); | |
73 } | |
74 | |
75 if (pinchedBounds.y() < 0) { | |
76 pinchedBounds.setY(0); | |
77 overflow.setHeight(pinchedBounds.y()); | |
78 } | |
79 | |
80 if (pinchedBounds.maxX() > m_unpinchedBounds.width()) { | |
81 pinchedBounds.move(m_unpinchedBounds.width() - pinchedBounds.maxX(), 0); | |
82 overflow.setWidth(pinchedBounds.maxX() - m_unpinchedBounds.width()); | |
83 } | |
84 | |
85 if (pinchedBounds.maxY() > m_unpinchedBounds.height()) { | |
86 pinchedBounds.move(0, m_unpinchedBounds.height() - pinchedBounds.maxY()) ; | |
87 overflow.setHeight(pinchedBounds.maxY() - m_unpinchedBounds.height()); | |
88 } | |
89 m_pinchViewportScrollDelta = pinchedBounds.location(); | |
90 | |
91 return overflow; | |
92 } | |
93 | |
51 class CCLayerTreeHostImplTimeSourceAdapter : public CCTimeSourceClient { | 94 class CCLayerTreeHostImplTimeSourceAdapter : public CCTimeSourceClient { |
52 WTF_MAKE_NONCOPYABLE(CCLayerTreeHostImplTimeSourceAdapter); | 95 WTF_MAKE_NONCOPYABLE(CCLayerTreeHostImplTimeSourceAdapter); |
53 public: | 96 public: |
54 static PassOwnPtr<CCLayerTreeHostImplTimeSourceAdapter> create(CCLayerTreeHo stImpl* layerTreeHostImpl, PassRefPtr<CCDelayBasedTimeSource> timeSource) | 97 static PassOwnPtr<CCLayerTreeHostImplTimeSourceAdapter> create(CCLayerTreeHo stImpl* layerTreeHostImpl, PassRefPtr<CCDelayBasedTimeSource> timeSource) |
55 { | 98 { |
56 return adoptPtr(new CCLayerTreeHostImplTimeSourceAdapter(layerTreeHostIm pl, timeSource)); | 99 return adoptPtr(new CCLayerTreeHostImplTimeSourceAdapter(layerTreeHostIm pl, timeSource)); |
57 } | 100 } |
58 virtual ~CCLayerTreeHostImplTimeSourceAdapter() | 101 virtual ~CCLayerTreeHostImplTimeSourceAdapter() |
59 { | 102 { |
60 m_timeSource->setClient(0); | 103 m_timeSource->setClient(0); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
100 , m_rootScrollLayerImpl(0) | 143 , m_rootScrollLayerImpl(0) |
101 , m_currentlyScrollingLayerImpl(0) | 144 , m_currentlyScrollingLayerImpl(0) |
102 , m_hudLayerImpl(0) | 145 , m_hudLayerImpl(0) |
103 , m_scrollingLayerIdFromPreviousTree(-1) | 146 , m_scrollingLayerIdFromPreviousTree(-1) |
104 , m_scrollDeltaIsInScreenSpace(false) | 147 , m_scrollDeltaIsInScreenSpace(false) |
105 , m_settings(settings) | 148 , m_settings(settings) |
106 , m_deviceScaleFactor(1) | 149 , m_deviceScaleFactor(1) |
107 , m_visible(true) | 150 , m_visible(true) |
108 , m_contentsTexturesPurged(false) | 151 , m_contentsTexturesPurged(false) |
109 , m_memoryAllocationLimitBytes(CCPrioritizedTextureManager::defaultMemoryAll ocationLimit()) | 152 , m_memoryAllocationLimitBytes(CCPrioritizedTextureManager::defaultMemoryAll ocationLimit()) |
110 , m_pageScale(1) | 153 , m_pageScaleFactor(1) |
111 , m_pageScaleDelta(1) | 154 , m_pageScaleDelta(1) |
112 , m_sentPageScaleDelta(1) | 155 , m_sentPageScaleDelta(1) |
113 , m_minPageScale(0) | 156 , m_minPageScaleFactor(0) |
114 , m_maxPageScale(0) | 157 , m_maxPageScaleFactor(0) |
115 , m_backgroundColor(0) | 158 , m_backgroundColor(0) |
116 , m_hasTransparentBackground(false) | 159 , m_hasTransparentBackground(false) |
117 , m_needsAnimateLayers(false) | 160 , m_needsAnimateLayers(false) |
118 , m_pinchGestureActive(false) | 161 , m_pinchGestureActive(false) |
119 , m_fpsCounter(CCFrameRateCounter::create()) | 162 , m_fpsCounter(CCFrameRateCounter::create()) |
120 , m_debugRectHistory(CCDebugRectHistory::create()) | 163 , m_debugRectHistory(CCDebugRectHistory::create()) |
121 { | 164 { |
122 ASSERT(CCProxy::isImplThread()); | 165 ASSERT(CCProxy::isImplThread()); |
123 didVisibilityChange(this, m_visible); | 166 didVisibilityChange(this, m_visible); |
124 } | 167 } |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
181 animateScrollbars(monotonicTime); | 224 animateScrollbars(monotonicTime); |
182 } | 225 } |
183 | 226 |
184 void CCLayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration) | 227 void CCLayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration) |
185 { | 228 { |
186 if (!m_rootScrollLayerImpl) | 229 if (!m_rootScrollLayerImpl) |
187 return; | 230 return; |
188 | 231 |
189 IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta()); | 232 IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta()); |
190 scrollTotal.scale(m_pageScaleDelta); | 233 scrollTotal.scale(m_pageScaleDelta); |
191 float scaleTotal = m_pageScale * m_pageScaleDelta; | 234 float scaleTotal = m_pageScaleFactor * m_pageScaleDelta; |
192 IntSize scaledContentSize = contentSize(); | 235 IntSize scaledContentSize = contentSize(); |
193 scaledContentSize.scale(m_pageScaleDelta); | 236 scaledContentSize.scale(m_pageScaleDelta); |
194 | 237 |
195 m_pageScaleAnimation = CCPageScaleAnimation::create(scrollTotal, scaleTotal, m_deviceViewportSize, scaledContentSize, startTime); | 238 m_pageScaleAnimation = CCPageScaleAnimation::create(scrollTotal, scaleTotal, m_deviceViewportSize, scaledContentSize, startTime); |
196 | 239 |
197 if (anchorPoint) { | 240 if (anchorPoint) { |
198 IntSize windowAnchor(targetPosition); | 241 IntSize windowAnchor(targetPosition); |
199 windowAnchor.scale(scaleTotal / pageScale); | 242 windowAnchor.scale(scaleTotal / pageScale); |
200 windowAnchor -= scrollTotal; | 243 windowAnchor -= scrollTotal; |
201 m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, duration); | 244 m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, duration); |
(...skipping 517 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
719 } | 762 } |
720 | 763 |
721 void CCLayerTreeHostImpl::setViewportSize(const IntSize& layoutViewportSize, con st IntSize& deviceViewportSize) | 764 void CCLayerTreeHostImpl::setViewportSize(const IntSize& layoutViewportSize, con st IntSize& deviceViewportSize) |
722 { | 765 { |
723 if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_de viceViewportSize) | 766 if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_de viceViewportSize) |
724 return; | 767 return; |
725 | 768 |
726 m_layoutViewportSize = layoutViewportSize; | 769 m_layoutViewportSize = layoutViewportSize; |
727 m_deviceViewportSize = deviceViewportSize; | 770 m_deviceViewportSize = deviceViewportSize; |
728 | 771 |
772 m_pinchZoomViewport.setUnpinchedBounds(FloatSize(layoutViewportSize)); | |
773 | |
729 updateMaxScrollPosition(); | 774 updateMaxScrollPosition(); |
730 | 775 |
731 if (m_renderer) | 776 if (m_renderer) |
732 m_renderer->viewportChanged(); | 777 m_renderer->viewportChanged(); |
733 | 778 |
734 m_client->onCanDrawStateChanged(canDraw()); | 779 m_client->onCanDrawStateChanged(canDraw()); |
735 } | 780 } |
736 | 781 |
737 static void adjustScrollsForPageScaleChange(CCLayerImpl* layerImpl, float pageSc aleChange) | |
738 { | |
739 if (!layerImpl) | |
740 return; | |
741 | |
742 if (layerImpl->scrollable()) { | |
743 // We need to convert impl-side scroll deltas to pageScale space. | |
744 FloatSize scrollDelta = layerImpl->scrollDelta(); | |
745 scrollDelta.scale(pageScaleChange); | |
746 layerImpl->setScrollDelta(scrollDelta); | |
747 } | |
748 | |
749 for (size_t i = 0; i < layerImpl->children().size(); ++i) | |
750 adjustScrollsForPageScaleChange(layerImpl->children()[i].get(), pageScal eChange); | |
751 } | |
752 | |
753 void CCLayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor) | 782 void CCLayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor) |
754 { | 783 { |
755 if (deviceScaleFactor == m_deviceScaleFactor) | 784 if (deviceScaleFactor == m_deviceScaleFactor) |
756 return; | 785 return; |
757 m_deviceScaleFactor = deviceScaleFactor; | 786 m_deviceScaleFactor = deviceScaleFactor; |
758 | 787 |
759 updateMaxScrollPosition(); | 788 updateMaxScrollPosition(); |
760 } | 789 } |
761 | 790 |
762 | 791 |
763 void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScale, float min PageScale, float maxPageScale) | 792 void CCLayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScaleFactor, flo at minPageScaleFactor, float maxPageScaleFactor) |
764 { | 793 { |
765 if (!pageScale) | 794 if (!pageScaleFactor) |
766 return; | 795 return; |
767 | 796 |
768 if (m_sentPageScaleDelta == 1 && pageScale == m_pageScale && minPageScale == m_minPageScale && maxPageScale == m_maxPageScale) | 797 if (m_sentPageScaleDelta == 1 && pageScaleFactor == m_pageScaleFactor && min PageScaleFactor == m_minPageScaleFactor && maxPageScaleFactor == m_maxPageScaleF actor) |
769 return; | 798 return; |
770 | 799 |
771 m_minPageScale = minPageScale; | 800 m_minPageScaleFactor = minPageScaleFactor; |
772 m_maxPageScale = maxPageScale; | 801 m_maxPageScaleFactor = maxPageScaleFactor; |
773 | 802 |
774 float pageScaleChange = pageScale / m_pageScale; | 803 m_pageScaleFactor = pageScaleFactor; |
775 m_pageScale = pageScale; | |
776 | |
777 if (pageScaleChange != 1) | |
778 adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange); | |
779 | 804 |
780 // Clamp delta to limits and refresh display matrix. | 805 // Clamp delta to limits and refresh display matrix. |
781 setPageScaleDelta(m_pageScaleDelta / m_sentPageScaleDelta); | 806 setPageScaleDelta(m_pageScaleDelta / m_sentPageScaleDelta); |
782 m_sentPageScaleDelta = 1; | 807 m_sentPageScaleDelta = 1; |
783 if (m_rootScrollLayerImpl) | 808 if (m_rootScrollLayerImpl) |
784 m_rootScrollLayerImpl->setPageScaleDelta(m_pageScaleDelta); | 809 m_rootScrollLayerImpl->setPageScaleDelta(m_pageScaleDelta); |
785 } | 810 } |
786 | 811 |
787 void CCLayerTreeHostImpl::setPageScaleDelta(float delta) | 812 void CCLayerTreeHostImpl::setPageScaleDelta(float delta) |
788 { | 813 { |
789 // Clamp to the current min/max limits. | 814 // Clamp to the current min/max limits. |
790 float finalMagnifyScale = m_pageScale * delta; | 815 float finalMagnifyScale = m_pageScaleFactor * delta; |
791 if (m_minPageScale && finalMagnifyScale < m_minPageScale) | 816 if (m_minPageScaleFactor && finalMagnifyScale < m_minPageScaleFactor) |
792 delta = m_minPageScale / m_pageScale; | 817 delta = m_minPageScaleFactor / m_pageScaleFactor; |
793 else if (m_maxPageScale && finalMagnifyScale > m_maxPageScale) | 818 else if (m_maxPageScaleFactor && finalMagnifyScale > m_maxPageScaleFactor) |
794 delta = m_maxPageScale / m_pageScale; | 819 delta = m_maxPageScaleFactor / m_pageScaleFactor; |
795 | 820 |
796 if (delta == m_pageScaleDelta) | 821 if (delta == m_pageScaleDelta) |
797 return; | 822 return; |
798 | 823 |
799 m_pageScaleDelta = delta; | 824 m_pageScaleDelta = delta; |
800 | 825 |
801 updateMaxScrollPosition(); | 826 updateMaxScrollPosition(); |
802 if (m_rootScrollLayerImpl) | 827 if (m_rootScrollLayerImpl) { |
803 m_rootScrollLayerImpl->setPageScaleDelta(m_pageScaleDelta); | 828 m_rootScrollLayerImpl->setPageScaleDelta(m_pageScaleDelta); |
829 m_rootScrollLayerImpl->setPageScaleFactor(m_pageScaleFactor); | |
830 } | |
804 } | 831 } |
805 | 832 |
806 void CCLayerTreeHostImpl::updateMaxScrollPosition() | 833 void CCLayerTreeHostImpl::updateMaxScrollPosition() |
807 { | 834 { |
808 if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size()) | 835 if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size()) |
809 return; | 836 return; |
810 | 837 |
811 FloatSize viewBounds = m_deviceViewportSize; | 838 FloatSize viewBounds = m_deviceViewportSize; |
812 if (CCLayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) { | 839 if (CCLayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) { |
813 // Compensate for non-overlay scrollbars. | 840 // Compensate for non-overlay scrollbars. |
814 if (clipLayer->masksToBounds()) { | 841 if (clipLayer->masksToBounds()) { |
815 viewBounds = clipLayer->bounds(); | 842 viewBounds = clipLayer->bounds(); |
816 viewBounds.scale(m_deviceScaleFactor); | 843 viewBounds.scale(m_deviceScaleFactor); |
817 } | 844 } |
818 } | 845 } |
819 viewBounds.scale(1 / m_pageScaleDelta); | 846 viewBounds.scale(1 / m_pageScaleDelta); |
820 | 847 |
821 // maxScroll is computed in physical pixels, but scroll positions are in lay out pixels. | 848 // maxScroll is computed in physical pixels, but scroll positions are in lay out pixels. |
822 IntSize maxScroll = contentSize() - expandedIntSize(viewBounds); | 849 // Compute the contentSize in terms of layout pixels. |
823 maxScroll.scale(1 / m_deviceScaleFactor); | 850 IntSize scaledContentSize = contentSize(); |
851 scaledContentSize.scale(1 / (m_pageScaleFactor * m_deviceScaleFactor)); | |
852 | |
853 IntSize maxScroll = scaledContentSize - expandedIntSize(viewBounds); | |
854 maxScroll.scale(1 / (m_deviceScaleFactor)); | |
855 | |
824 // The viewport may be larger than the contents in some cases, such as | 856 // The viewport may be larger than the contents in some cases, such as |
825 // having a vertical scrollbar but no horizontal overflow. | 857 // having a vertical scrollbar but no horizontal overflow. |
826 maxScroll.clampNegativeToZero(); | 858 maxScroll.clampNegativeToZero(); |
827 | 859 |
828 m_rootScrollLayerImpl->setMaxScrollPosition(maxScroll); | 860 m_rootScrollLayerImpl->setMaxScrollPosition(maxScroll); |
829 } | 861 } |
830 | 862 |
831 void CCLayerTreeHostImpl::setNeedsRedraw() | 863 void CCLayerTreeHostImpl::setNeedsRedraw() |
832 { | 864 { |
833 m_client->setNeedsRedrawOnImplThread(); | 865 m_client->setNeedsRedrawOnImplThread(); |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
896 m_currentlyScrollingLayerImpl = potentiallyScrollingLayerImpl; | 928 m_currentlyScrollingLayerImpl = potentiallyScrollingLayerImpl; |
897 // Gesture events need to be transformed from screen coordinates to loca l layer coordinates | 929 // Gesture events need to be transformed from screen coordinates to loca l layer coordinates |
898 // so that the scrolling contents exactly follow the user's finger. In c ontrast, wheel | 930 // so that the scrolling contents exactly follow the user's finger. In c ontrast, wheel |
899 // events are already in local layer coordinates so we can just apply th em directly. | 931 // events are already in local layer coordinates so we can just apply th em directly. |
900 m_scrollDeltaIsInScreenSpace = (type == Gesture); | 932 m_scrollDeltaIsInScreenSpace = (type == Gesture); |
901 return ScrollStarted; | 933 return ScrollStarted; |
902 } | 934 } |
903 return ScrollIgnored; | 935 return ScrollIgnored; |
904 } | 936 } |
905 | 937 |
906 static FloatSize scrollLayerWithScreenSpaceDelta(CCLayerImpl& layerImpl, const F loatPoint& screenSpacePoint, const FloatSize& screenSpaceDelta) | 938 static FloatSize scrollLayerWithScreenSpaceDelta(CCPinchZoomViewport* viewport, CCLayerImpl& layerImpl, const FloatPoint& screenSpacePoint, const FloatSize& scr eenSpaceDelta) |
907 { | 939 { |
908 // Layers with non-invertible screen space transforms should not have passed the scroll hit | 940 // Layers with non-invertible screen space transforms should not have passed the scroll hit |
909 // test in the first place. | 941 // test in the first place. |
910 ASSERT(layerImpl.screenSpaceTransform().isInvertible()); | 942 ASSERT(layerImpl.screenSpaceTransform().isInvertible()); |
911 WebTransformationMatrix inverseScreenSpaceTransform = layerImpl.screenSpaceT ransform().inverse(); | 943 WebTransformationMatrix inverseScreenSpaceTransform = layerImpl.screenSpaceT ransform().inverse(); |
912 | 944 |
913 // First project the scroll start and end points to local layer space to fin d the scroll delta | 945 // First project the scroll start and end points to local layer space to fin d the scroll delta |
914 // in layer coordinates. | 946 // in layer coordinates. |
915 bool startClipped, endClipped; | 947 bool startClipped, endClipped; |
916 FloatPoint screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta; | 948 FloatPoint screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta; |
917 FloatPoint localStartPoint = CCMathUtil::projectPoint(inverseScreenSpaceTran sform, screenSpacePoint, startClipped); | 949 FloatPoint localStartPoint = CCMathUtil::projectPoint(inverseScreenSpaceTran sform, screenSpacePoint, startClipped); |
918 FloatPoint localEndPoint = CCMathUtil::projectPoint(inverseScreenSpaceTransf orm, screenSpaceEndPoint, endClipped); | 950 FloatPoint localEndPoint = CCMathUtil::projectPoint(inverseScreenSpaceTransf orm, screenSpaceEndPoint, endClipped); |
919 | 951 |
920 // In general scroll point coordinates should not get clipped. | 952 // In general scroll point coordinates should not get clipped. |
921 ASSERT(!startClipped); | 953 ASSERT(!startClipped); |
922 ASSERT(!endClipped); | 954 ASSERT(!endClipped); |
923 if (startClipped || endClipped) | 955 if (startClipped || endClipped) |
924 return FloatSize(); | 956 return FloatSize(); |
925 | 957 |
926 // Apply the scroll delta. | 958 // Apply the scroll delta. |
927 FloatSize previousDelta(layerImpl.scrollDelta()); | 959 FloatSize previousDelta(layerImpl.scrollDelta()); |
928 layerImpl.scrollBy(localEndPoint - localStartPoint); | 960 FloatSize unscrolled = layerImpl.scrollBy(localEndPoint - localStartPoint); |
961 | |
962 if (viewport) { | |
963 viewport->applyScroll(unscrolled); | |
964 layerImpl.setLocalOffset(FloatSize(-viewport->scrollDelta().x(), -viewpo rt->scrollDelta().y())); | |
965 } | |
929 | 966 |
930 // Calculate the applied scroll delta in screen space coordinates. | 967 // Calculate the applied scroll delta in screen space coordinates. |
931 FloatPoint actualLocalEndPoint = localStartPoint + layerImpl.scrollDelta() - previousDelta; | 968 FloatPoint actualLocalEndPoint = localStartPoint + layerImpl.scrollDelta() - previousDelta; |
932 FloatPoint actualScreenSpaceEndPoint = CCMathUtil::mapPoint(layerImpl.screen SpaceTransform(), actualLocalEndPoint, endClipped); | 969 FloatPoint actualScreenSpaceEndPoint = CCMathUtil::mapPoint(layerImpl.screen SpaceTransform(), actualLocalEndPoint, endClipped); |
933 ASSERT(!endClipped); | 970 ASSERT(!endClipped); |
934 if (endClipped) | 971 if (endClipped) |
935 return FloatSize(); | 972 return FloatSize(); |
936 return actualScreenSpaceEndPoint - screenSpacePoint; | 973 return actualScreenSpaceEndPoint - screenSpacePoint; |
937 } | 974 } |
938 | 975 |
(...skipping 11 matching lines...) Expand all Loading... | |
950 return; | 987 return; |
951 | 988 |
952 FloatSize pendingDelta(scrollDelta); | 989 FloatSize pendingDelta(scrollDelta); |
953 | 990 |
954 pendingDelta.scale(m_deviceScaleFactor); | 991 pendingDelta.scale(m_deviceScaleFactor); |
955 | 992 |
956 for (CCLayerImpl* layerImpl = m_currentlyScrollingLayerImpl; layerImpl; laye rImpl = layerImpl->parent()) { | 993 for (CCLayerImpl* layerImpl = m_currentlyScrollingLayerImpl; layerImpl; laye rImpl = layerImpl->parent()) { |
957 if (!layerImpl->scrollable()) | 994 if (!layerImpl->scrollable()) |
958 continue; | 995 continue; |
959 | 996 |
997 CCPinchZoomViewport* viewport = layerImpl == m_rootScrollLayerImpl ? &m_ pinchZoomViewport : 0; | |
960 FloatSize appliedDelta; | 998 FloatSize appliedDelta; |
961 if (m_scrollDeltaIsInScreenSpace) | 999 if (m_scrollDeltaIsInScreenSpace) |
962 appliedDelta = scrollLayerWithScreenSpaceDelta(*layerImpl, viewportP oint, pendingDelta); | 1000 appliedDelta = scrollLayerWithScreenSpaceDelta(viewport, *layerImpl, viewportPoint, pendingDelta); |
963 else | 1001 else |
964 appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta); | 1002 appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta); |
965 | 1003 |
966 // If the layer wasn't able to move, try the next one in the hierarchy. | 1004 // If the layer wasn't able to move, try the next one in the hierarchy. |
967 float moveThresholdSquared = 0.1f * 0.1f; | 1005 float moveThresholdSquared = 0.1f * 0.1f; |
968 if (appliedDelta.diagonalLengthSquared() < moveThresholdSquared) | 1006 if (appliedDelta.diagonalLengthSquared() < moveThresholdSquared) |
969 continue; | 1007 continue; |
970 | 1008 |
971 // If the applied delta is within 45 degrees of the input delta, bail ou t to make it easier | 1009 // If the applied delta is within 45 degrees of the input delta, bail ou t to make it easier |
972 // to scroll just one layer in one direction without affecting any of it s parents. | 1010 // to scroll just one layer in one direction without affecting any of it s parents. |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1022 if (m_previousPinchAnchor == IntPoint::zero()) | 1060 if (m_previousPinchAnchor == IntPoint::zero()) |
1023 m_previousPinchAnchor = anchor; | 1061 m_previousPinchAnchor = anchor; |
1024 | 1062 |
1025 // Keep the center-of-pinch anchor specified by (x, y) in a stable | 1063 // Keep the center-of-pinch anchor specified by (x, y) in a stable |
1026 // position over the course of the magnify. | 1064 // position over the course of the magnify. |
1027 FloatPoint previousScaleAnchor(m_previousPinchAnchor.x() / m_pageScaleDelta, m_previousPinchAnchor.y() / m_pageScaleDelta); | 1065 FloatPoint previousScaleAnchor(m_previousPinchAnchor.x() / m_pageScaleDelta, m_previousPinchAnchor.y() / m_pageScaleDelta); |
1028 setPageScaleDelta(m_pageScaleDelta * magnifyDelta); | 1066 setPageScaleDelta(m_pageScaleDelta * magnifyDelta); |
1029 FloatPoint newScaleAnchor(anchor.x() / m_pageScaleDelta, anchor.y() / m_page ScaleDelta); | 1067 FloatPoint newScaleAnchor(anchor.x() / m_pageScaleDelta, anchor.y() / m_page ScaleDelta); |
1030 FloatSize move = previousScaleAnchor - newScaleAnchor; | 1068 FloatSize move = previousScaleAnchor - newScaleAnchor; |
1031 | 1069 |
1070 // Compute the appliation of the delta with respect to the current page zoom of the page. | |
1071 move.scale(1 / m_pageScaleFactor); | |
1072 | |
1032 m_previousPinchAnchor = anchor; | 1073 m_previousPinchAnchor = anchor; |
1033 | 1074 |
1034 m_rootScrollLayerImpl->scrollBy(roundedIntSize(move)); | 1075 m_pinchZoomViewport.setTotalPageScaleFactor(m_pageScaleFactor * m_pageScaleD elta); |
1076 | |
1077 FloatSize scrollOverflow = m_pinchZoomViewport.applyScroll(move); | |
1078 m_rootScrollLayerImpl->setLocalOffset(FloatSize(-m_pinchZoomViewport.scrollD elta().x(), -m_pinchZoomViewport.scrollDelta().y())); | |
1079 m_rootScrollLayerImpl->scrollBy(roundedIntSize(scrollOverflow)); | |
1035 | 1080 |
1036 if (m_rootScrollLayerImpl->scrollbarAnimationController()) | 1081 if (m_rootScrollLayerImpl->scrollbarAnimationController()) |
1037 m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUp date(); | 1082 m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUp date(); |
1038 | 1083 |
1039 m_client->setNeedsCommitOnImplThread(); | 1084 m_client->setNeedsCommitOnImplThread(); |
1040 m_client->setNeedsRedrawOnImplThread(); | 1085 m_client->setNeedsRedrawOnImplThread(); |
1041 } | 1086 } |
1042 | 1087 |
1043 void CCLayerTreeHostImpl::pinchGestureEnd() | 1088 void CCLayerTreeHostImpl::pinchGestureEnd() |
1044 { | 1089 { |
1045 m_pinchGestureActive = false; | 1090 m_pinchGestureActive = false; |
1046 | 1091 |
1047 if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationContro ller()) | 1092 if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationContro ller()) |
1048 m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureEn d(); | 1093 m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureEn d(); |
1049 | 1094 |
1050 m_client->setNeedsCommitOnImplThread(); | 1095 m_client->setNeedsCommitOnImplThread(); |
1051 } | 1096 } |
1052 | 1097 |
1053 void CCLayerTreeHostImpl::computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scroll Info) | 1098 void CCLayerTreeHostImpl::computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scroll Info) |
1054 { | 1099 { |
1055 float pageScale = m_pageScaleAnimation->finalPageScale(); | 1100 float pageScale = m_pageScaleAnimation->finalPageScale(); |
1056 IntSize scrollOffset = m_pageScaleAnimation->finalScrollOffset(); | 1101 IntSize scrollOffset = m_pageScaleAnimation->finalScrollOffset(); |
1057 scrollOffset.scale(m_pageScale / pageScale); | 1102 scrollOffset.scale(m_pageScaleFactor / pageScale); |
1058 makeScrollAndScaleSet(scrollInfo, scrollOffset, pageScale); | 1103 makeScrollAndScaleSet(scrollInfo, scrollOffset, pageScale); |
1059 } | 1104 } |
1060 | 1105 |
1061 void CCLayerTreeHostImpl::computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo ) | 1106 void CCLayerTreeHostImpl::computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo ) |
1062 { | 1107 { |
1063 if (!m_rootScrollLayerImpl) | 1108 if (!m_rootScrollLayerImpl) |
1064 return; | 1109 return; |
1065 | 1110 |
1066 // Only send fake scroll/zoom deltas if we're pinch zooming out by a | 1111 // Only send fake scroll/zoom deltas if we're pinch zooming out by a |
1067 // significant amount. This also ensures only one fake delta set will be | 1112 // significant amount. This also ensures only one fake delta set will be |
1068 // sent. | 1113 // sent. |
1069 const float pinchZoomOutSensitivity = 0.95f; | 1114 const float pinchZoomOutSensitivity = 0.95f; |
1070 if (m_pageScaleDelta > pinchZoomOutSensitivity) | 1115 if (m_pageScaleDelta > pinchZoomOutSensitivity) |
1071 return; | 1116 return; |
1072 | 1117 |
1073 // Compute where the scroll offset/page scale would be if fully pinch-zoomed | 1118 // Compute where the scroll offset/page scale would be if fully pinch-zoomed |
1074 // out from the anchor point. | 1119 // out from the anchor point. |
1075 IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta()); | 1120 IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta()); |
1076 scrollBegin.scale(m_pageScaleDelta); | 1121 scrollBegin.scale(m_pageScaleDelta); |
1077 float scaleBegin = m_pageScale * m_pageScaleDelta; | 1122 float scaleBegin = m_pageScaleFactor * m_pageScaleDelta; |
1078 float pageScaleDeltaToSend = m_minPageScale / m_pageScale; | 1123 float pageScaleDeltaToSend = m_minPageScaleFactor / m_pageScaleFactor; |
1079 FloatSize scaledContentsSize = contentSize(); | 1124 FloatSize scaledContentsSize = contentSize(); |
1080 scaledContentsSize.scale(pageScaleDeltaToSend); | 1125 scaledContentsSize.scale(pageScaleDeltaToSend); |
1081 | 1126 |
1082 FloatSize anchor = toSize(m_previousPinchAnchor); | 1127 FloatSize anchor = toSize(m_previousPinchAnchor); |
1083 FloatSize scrollEnd = scrollBegin + anchor; | 1128 FloatSize scrollEnd = scrollBegin + anchor; |
1084 scrollEnd.scale(m_minPageScale / scaleBegin); | 1129 scrollEnd.scale(m_minPageScaleFactor / scaleBegin); |
1085 scrollEnd -= anchor; | 1130 scrollEnd -= anchor; |
1086 scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_deviceV iewportSize)).expandedTo(FloatSize(0, 0)); | 1131 scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_deviceV iewportSize)).expandedTo(FloatSize(0, 0)); |
1087 scrollEnd.scale(1 / pageScaleDeltaToSend); | 1132 scrollEnd.scale(1 / pageScaleDeltaToSend); |
1088 scrollEnd.scale(m_deviceScaleFactor); | 1133 scrollEnd.scale(m_deviceScaleFactor); |
1089 | 1134 |
1090 makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_minPageScale) ; | 1135 makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_minPageScaleF actor); |
1091 } | 1136 } |
1092 | 1137 |
1093 void CCLayerTreeHostImpl::makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale) | 1138 void CCLayerTreeHostImpl::makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale) |
1094 { | 1139 { |
1095 if (!m_rootScrollLayerImpl) | 1140 if (!m_rootScrollLayerImpl) |
1096 return; | 1141 return; |
1097 | 1142 |
1098 CCLayerTreeHostCommon::ScrollUpdateInfo scroll; | 1143 CCLayerTreeHostCommon::ScrollUpdateInfo scroll; |
1099 scroll.layerId = m_rootScrollLayerImpl->id(); | 1144 scroll.layerId = m_rootScrollLayerImpl->id(); |
1100 scroll.scrollDelta = scrollOffset - toSize(m_rootScrollLayerImpl->scrollPosi tion()); | 1145 scroll.scrollDelta = scrollOffset - toSize(m_rootScrollLayerImpl->scrollPosi tion()); |
1101 scrollInfo->scrolls.append(scroll); | 1146 scrollInfo->scrolls.append(scroll); |
1102 m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta); | 1147 m_rootScrollLayerImpl->setSentScrollDelta(scroll.scrollDelta); |
1103 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = pageScale / m_pageScale; | 1148 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = pageScale / m_pageScaleF actor; |
1104 } | 1149 } |
1105 | 1150 |
1106 static void collectScrollDeltas(CCScrollAndScaleSet* scrollInfo, CCLayerImpl* la yerImpl) | 1151 static void collectScrollDeltas(CCScrollAndScaleSet* scrollInfo, CCLayerImpl* la yerImpl) |
1107 { | 1152 { |
1108 if (!layerImpl) | 1153 if (!layerImpl) |
1109 return; | 1154 return; |
1110 | 1155 |
1111 if (!layerImpl->scrollDelta().isZero()) { | 1156 if (!layerImpl->scrollDelta().isZero()) { |
1112 IntSize scrollDelta = flooredIntSize(layerImpl->scrollDelta()); | 1157 IntSize scrollDelta = flooredIntSize(layerImpl->scrollDelta()); |
1113 CCLayerTreeHostCommon::ScrollUpdateInfo scroll; | 1158 CCLayerTreeHostCommon::ScrollUpdateInfo scroll; |
1114 scroll.layerId = layerImpl->id(); | 1159 scroll.layerId = layerImpl->id(); |
1115 scroll.scrollDelta = scrollDelta; | 1160 scroll.scrollDelta = scrollDelta; |
1116 scrollInfo->scrolls.append(scroll); | 1161 scrollInfo->scrolls.append(scroll); |
1117 layerImpl->setSentScrollDelta(scrollDelta); | 1162 layerImpl->setSentScrollDelta(scrollDelta); |
1118 } | 1163 } |
1119 | 1164 |
1120 for (size_t i = 0; i < layerImpl->children().size(); ++i) | 1165 for (size_t i = 0; i < layerImpl->children().size(); ++i) |
1121 collectScrollDeltas(scrollInfo, layerImpl->children()[i].get()); | 1166 collectScrollDeltas(scrollInfo, layerImpl->children()[i].get()); |
1122 } | 1167 } |
1123 | 1168 |
1124 PassOwnPtr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas() | 1169 PassOwnPtr<CCScrollAndScaleSet> CCLayerTreeHostImpl::processScrollDeltas() |
1125 { | 1170 { |
1126 OwnPtr<CCScrollAndScaleSet> scrollInfo = adoptPtr(new CCScrollAndScaleSet()) ; | 1171 OwnPtr<CCScrollAndScaleSet> scrollInfo = adoptPtr(new CCScrollAndScaleSet()) ; |
1127 | 1172 |
1128 if (m_pinchGestureActive || m_pageScaleAnimation) { | 1173 if (m_pinchGestureActive || m_pageScaleAnimation) { |
1129 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = 1; | 1174 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = 1; |
1175 #if 0 | |
enne (OOO)
2012/09/13 19:40:54
?
Jeff Timanus
2012/09/13 19:58:50
This code needs to be retained so that the android
| |
1130 if (m_pinchGestureActive) | 1176 if (m_pinchGestureActive) |
1131 computePinchZoomDeltas(scrollInfo.get()); | 1177 computePinchZoomDeltas(scrollInfo.get()); |
1132 else if (m_pageScaleAnimation.get()) | 1178 else if (m_pageScaleAnimation.get()) |
1133 computeDoubleTapZoomDeltas(scrollInfo.get()); | 1179 computeDoubleTapZoomDeltas(scrollInfo.get()); |
1180 #endif | |
1134 return scrollInfo.release(); | 1181 return scrollInfo.release(); |
1135 } | 1182 } |
1136 | 1183 |
1137 collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get()); | 1184 collectScrollDeltas(scrollInfo.get(), m_rootLayerImpl.get()); |
1138 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = m_pageScaleDelta; | 1185 m_sentPageScaleDelta = scrollInfo->pageScaleDelta = m_pageScaleDelta; |
1139 | 1186 |
1140 return scrollInfo.release(); | 1187 return scrollInfo.release(); |
1141 } | 1188 } |
1142 | 1189 |
1143 void CCLayerTreeHostImpl::setFullRootLayerDamage() | 1190 void CCLayerTreeHostImpl::setFullRootLayerDamage() |
1144 { | 1191 { |
1145 if (m_rootLayerImpl) { | 1192 if (m_rootLayerImpl) { |
1146 CCRenderSurface* renderSurface = m_rootLayerImpl->renderSurface(); | 1193 CCRenderSurface* renderSurface = m_rootLayerImpl->renderSurface(); |
1147 if (renderSurface) | 1194 if (renderSurface) |
1148 renderSurface->damageTracker()->forceFullDamageNextUpdate(); | 1195 renderSurface->damageTracker()->forceFullDamageNextUpdate(); |
1149 } | 1196 } |
1150 } | 1197 } |
1151 | 1198 |
1152 void CCLayerTreeHostImpl::animatePageScale(double monotonicTime) | 1199 void CCLayerTreeHostImpl::animatePageScale(double monotonicTime) |
1153 { | 1200 { |
1154 if (!m_pageScaleAnimation || !m_rootScrollLayerImpl) | 1201 if (!m_pageScaleAnimation || !m_rootScrollLayerImpl) |
1155 return; | 1202 return; |
1156 | 1203 |
1157 IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta()); | 1204 IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta()); |
1158 | 1205 |
1159 setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_p ageScale); | 1206 setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_p ageScaleFactor); |
1160 IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime) ; | 1207 IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime) ; |
1161 nextScroll.scale(1 / m_pageScaleDelta); | 1208 nextScroll.scale(1 / m_pageScaleDelta); |
1162 m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal); | 1209 m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal); |
1163 m_client->setNeedsRedrawOnImplThread(); | 1210 m_client->setNeedsRedrawOnImplThread(); |
1164 | 1211 |
1165 if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) { | 1212 if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) { |
1166 m_pageScaleAnimation.clear(); | 1213 m_pageScaleAnimation.clear(); |
1167 m_client->setNeedsCommitOnImplThread(); | 1214 m_client->setNeedsCommitOnImplThread(); |
1168 } | 1215 } |
1169 } | 1216 } |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1263 | 1310 |
1264 CCScrollbarAnimationController* scrollbarController = layer->scrollbarAnimat ionController(); | 1311 CCScrollbarAnimationController* scrollbarController = layer->scrollbarAnimat ionController(); |
1265 if (scrollbarController && scrollbarController->animate(monotonicTime)) | 1312 if (scrollbarController && scrollbarController->animate(monotonicTime)) |
1266 m_client->setNeedsRedrawOnImplThread(); | 1313 m_client->setNeedsRedrawOnImplThread(); |
1267 | 1314 |
1268 for (size_t i = 0; i < layer->children().size(); ++i) | 1315 for (size_t i = 0; i < layer->children().size(); ++i) |
1269 animateScrollbarsRecursive(layer->children()[i].get(), monotonicTime); | 1316 animateScrollbarsRecursive(layer->children()[i].get(), monotonicTime); |
1270 } | 1317 } |
1271 | 1318 |
1272 } // namespace WebCore | 1319 } // namespace WebCore |
OLD | NEW |