Fennec: Support scroll bar dragging and page up/down/left/right by mouse

Signed-off-by: NChen Gang <chengang@emindsoft.com.cn>
Reviewed-by: NDong Peng <dongpeng@emindsoft.com.cn>
Reviewed-by: NLiu Xiaoxu <823090683@qq.com>

gfx/layers/apz/src/AsyncPanZoomController.cpp

@@ -698,6 +698,8 @@ AsyncPanZoomController::AsyncPanZoomController(uint64_t aLayersId,
      mLastContentPaintMetrics(mLastContentPaintMetadata.GetMetrics()),
      mX(this),
      mY(this),
+     mDragFlagH(false),
+     mDragFlagV(false),
      mPanDirRestricted(false),
      mZoomConstraints(false, false,
         mFrameMetrics.GetDevPixelsPerCSSPixel() * kViewportMinScale / ParentLayerToScreenScale(1),
@@ -1503,6 +1505,7 @@ AsyncPanZoomController::GetScrollWheelDelta(const ScrollWheelInput& aEvent) cons
   ParentLayerSize scrollAmount;
   ParentLayerSize pageScrollSize;
   bool isRootContent = false;
+  float cur, range, page, ratio, length;
 
   {
     // Grab the lock to access the frame metrics.
@@ -1517,23 +1520,67 @@ AsyncPanZoomController::GetScrollWheelDelta(const ScrollWheelInput& aEvent) cons
   }
 
   ParentLayerPoint delta;
-  switch (aEvent.mDeltaType) {
-    case ScrollWheelInput::SCROLLDELTA_LINE: {
-      delta.x = aEvent.mDeltaX * scrollAmount.width;
-      delta.y = aEvent.mDeltaY * scrollAmount.height;
+
+  delta.x = 0.0f;
+  delta.y = 0.0f;
+  switch (aEvent.mScrollStatus) {
+    case ScrollWheelInput::SCROLLSTATUS_H_CONTINUE:
+    case ScrollWheelInput::SCROLLSTATUS_H_END:
+      range = mX.GetPageLength().value;
+      page = mX.GetCompositionLength().value;
+      ratio = page / range;
+      cur = mX.GetOrigin().value * ratio;
+      length = page * ratio / 2;
+      if (aEvent.mScrollStatus == ScrollWheelInput::SCROLLSTATUS_H_CONTINUE) {
+        delta.x = aEvent.mOrigin.x - cur - length;
+      } else if (!mDragFlagH) {
+        if (aEvent.mOrigin.x > cur + length) {
+          delta.x = page;
+        } else {
+          delta.x = -1 * page;
+        }
+      }
       break;
-    }
-    case ScrollWheelInput::SCROLLDELTA_PAGE: {
-      delta.x = aEvent.mDeltaX * pageScrollSize.width;
-      delta.y = aEvent.mDeltaY * pageScrollSize.height;
+    case ScrollWheelInput::SCROLLSTATUS_V_CONTINUE:
+    case ScrollWheelInput::SCROLLSTATUS_V_END:
+      range = mY.GetPageLength().value;
+      page = mY.GetCompositionLength().value;
+      ratio = page / range;
+      cur = mY.GetOrigin().value * ratio;
+      length = page * ratio / 2;
+      if (aEvent.mScrollStatus == ScrollWheelInput::SCROLLSTATUS_V_CONTINUE) {
+        delta.y = aEvent.mOrigin.y - cur - length;
+      } else if (!mDragFlagV) {
+        if (aEvent.mOrigin.y > cur + length) {
+          delta.y = page;
+        } else {
+          delta.y = -1 * page;
+        }
+      }
       break;
-    }
-    case ScrollWheelInput::SCROLLDELTA_PIXEL: {
-      delta = ToParentLayerCoordinates(ScreenPoint(aEvent.mDeltaX, aEvent.mDeltaY), aEvent.mOrigin);
+    case ScrollWheelInput::SCROLLSTATUS_H_BEGIN:
+    case ScrollWheelInput::SCROLLSTATUS_V_BEGIN:
       break;
-    }
     default:
-      MOZ_ASSERT_UNREACHABLE("unexpected scroll delta type");
+      switch (aEvent.mDeltaType) {
+        case ScrollWheelInput::SCROLLDELTA_LINE: {
+          delta.x = aEvent.mDeltaX * scrollAmount.width;
+          delta.y = aEvent.mDeltaY * scrollAmount.height;
+          break;
+        }
+        case ScrollWheelInput::SCROLLDELTA_PAGE: {
+          delta.x = aEvent.mDeltaX * pageScrollSize.width;
+          delta.y = aEvent.mDeltaY * pageScrollSize.height;
+          break;
+        }
+        case ScrollWheelInput::SCROLLDELTA_PIXEL: {
+          delta = ToParentLayerCoordinates(ScreenPoint(aEvent.mDeltaX, aEvent.mDeltaY), aEvent.mOrigin);
+          break;
+        }
+        default:
+          MOZ_ASSERT_UNREACHABLE("unexpected scroll delta type");
+      }
+      break;
   }
 
   // Apply user-set multipliers.
@@ -1673,6 +1720,24 @@ ScrollInputMethodForWheelDeltaType(ScrollWheelInput::ScrollDeltaType aDeltaType)
 nsEventStatus AsyncPanZoomController::OnScrollWheel(const ScrollWheelInput& aEvent)
 {
   ParentLayerPoint delta = GetScrollWheelDelta(aEvent);
+
+  switch (aEvent.mScrollStatus) {
+    case ScrollWheelInput::SCROLLSTATUS_H_CONTINUE:
+      mDragFlagH = true;
+      break;
+    case ScrollWheelInput::SCROLLSTATUS_V_CONTINUE:
+      mDragFlagV = true;
+      break;
+    case ScrollWheelInput::SCROLLSTATUS_H_END:
+      mDragFlagH = false;
+      break;
+    case ScrollWheelInput::SCROLLSTATUS_V_END:
+      mDragFlagV = false;
+      break;
+    default:
+      break;
+  }
+
   APZC_LOG("%p got a scroll-wheel with delta %s\n", this, Stringify(delta).c_str());
 
   if ((delta.x || delta.y) && !CanScrollWithWheel(delta)) {

gfx/layers/apz/src/AsyncPanZoomController.h

@@ -692,6 +692,9 @@ private:
   AxisX mX;
   AxisY mY;
 
+  bool mDragFlagH;
+  bool mDragFlagV;
+
   // This flag is set to true when we are in a axis-locked pan as a result of
   // the touch-action CSS property.
   bool mPanDirRestricted;

layout/generic/nsGfxScrollFrame.cpp

@@ -5668,6 +5668,7 @@ ScrollFrameHelper::GetActualScrollbarSizes() const
 void
 ScrollFrameHelper::SetScrollbarVisibility(nsIFrame* aScrollbar, bool aVisible)
 {
+  aVisible = true;
   nsScrollbarFrame* scrollbar = do_QueryFrame(aScrollbar);
   if (scrollbar) {
     // See if we have a mediator.

mobile/android/themes/core/content.css

@@ -31,32 +31,32 @@ xul|scrollbar {
 /* Scrollbar code will reset the margin to the correct side depending on
    where layout actually puts the scrollbar */
 xul|scrollbar[orient="vertical"] {
-  margin-left: -6px;
-  min-width: 6px;
-  max-width: 6px;
+  margin-left: -10px;
+  min-width: 10px;
+  max-width: 10px;
 }
 
 xul|scrollbar[orient="vertical"] xul|thumb {
   -moz-appearance: scrollbarthumb-vertical !important;
-  max-width: 2px !important;
-  min-width: 2px !important;
+  max-width: 10px !important;
+  min-width: 10px !important;
 }
 
 xul|scrollbar[orient="horizontal"] {
-  margin-top: -6px;
-  min-height: 6px;
-  max-height: 6px;
+  margin-top: -10px;
+  min-height: 10px;
+  max-height: 10px;
 }
 
 xul|scrollbar[orient="horizontal"] xul|thumb {
   -moz-appearance: scrollbarthumb-horizontal !important;
-  max-height: 2px !important;
-  min-height: 2px !important;
+  max-height: 10px !important;
+  min-height: 10px !important;
 }
 
 xul|scrollbar:not([active="true"]),
 xul|scrollbar[disabled] {
-  opacity: 0;
+  opacity: 128;
 }
 
 xul|scrollbarbutton {
@@ -72,7 +72,7 @@ xul|scrollbarbutton[sbattr="scrollbar-bottom-top"] {
 }
 
 xul|scrollbar xul|thumb {
-  background-color: rgba(119, 119, 119, 0.4) !important;
+  background-color: rgba(99, 119, 109, 0.5) !important;
   -moz-border-top-colors: none !important;
   -moz-border-bottom-colors: none !important;
   -moz-border-right-colors: none !important;

widget/InputData.h

@@ -571,6 +571,19 @@ public:
     SCROLLDELTA_PIXEL
   };
 
+  enum ScrollStatusType
+  {
+    SCROLLSTATUS_NULL,
+    SCROLLSTATUS_H_BEGIN,
+    SCROLLSTATUS_H_CONTINUE,
+    SCROLLSTATUS_H_END,
+    SCROLLSTATUS_H_CANCEL,
+    SCROLLSTATUS_V_BEGIN,
+    SCROLLSTATUS_V_CONTINUE,
+    SCROLLSTATUS_V_END,
+    SCROLLSTATUS_V_CANCEL
+  };
+
   static ScrollDeltaType
   DeltaTypeForDeltaMode(uint32_t aDeltaMode)
   {
@@ -617,7 +630,8 @@ public:
                    const ScreenPoint& aOrigin,
                    double aDeltaX,
                    double aDeltaY,
-                   bool aAllowToOverrideSystemScrollSpeed)
+                   bool aAllowToOverrideSystemScrollSpeed,
+                   ScrollStatusType aScrollStatus = SCROLLSTATUS_NULL)
     : InputData(SCROLLWHEEL_INPUT, aTime, aTimeStamp, aModifiers)
     , mDeltaType(aDeltaType)
     , mScrollMode(aScrollMode)
@@ -633,6 +647,7 @@ public:
     , mMayHaveMomentum(false)
     , mIsMomentum(false)
     , mAllowToOverrideSystemScrollSpeed(aAllowToOverrideSystemScrollSpeed)
+    , mScrollStatus(aScrollStatus)
   {}
 
   explicit ScrollWheelInput(const WidgetWheelEvent& aEvent);
@@ -678,6 +693,8 @@ public:
   bool mMayHaveMomentum;
   bool mIsMomentum;
   bool mAllowToOverrideSystemScrollSpeed;
+
+  ScrollStatusType mScrollStatus;
 };
 
 } // namespace mozilla

widget/android/nsWindow.cpp

@@ -510,11 +510,6 @@ public:
             return false;
         }
 
-        RefPtr<APZCTreeManager> controller = mWindow->mAPZC;
-        if (!controller) {
-            return false;
-        }
-
         ScreenPoint origin = ScreenPoint(aX, aY);
 
         ScrollWheelInput input(aTime, TimeStamp::Now(), GetModifiers(aMetaState),
@@ -523,6 +518,15 @@ public:
                                origin,
                                aHScroll, aVScroll,
                                false);
+        return HandleScrollEventCore(input);
+    }
+
+    bool HandleScrollEventCore(ScrollWheelInput input)
+    {
+        RefPtr<APZCTreeManager> controller = mWindow->mAPZC;
+        if (!controller) {
+            return false;
+        }
 
         ScrollableLayerGuid guid;
         uint64_t blockId;
@@ -599,9 +603,67 @@ public:
         return result;
     }
 
+    bool HandleScrollBarTouchEventV(int32_t aAction, int64_t aTime, float y) {
+        ScrollWheelInput::ScrollStatusType status;
+
+        switch (aAction) {
+            case AndroidMotionEvent::ACTION_UP:
+                status = ScrollWheelInput::SCROLLSTATUS_V_END;
+                break;
+            case AndroidMotionEvent::ACTION_MOVE:
+                status = ScrollWheelInput::SCROLLSTATUS_V_CONTINUE;
+                break;
+            case AndroidMotionEvent::ACTION_DOWN:
+                return true;
+            default:
+                return false;
+        }
+
+        ScreenPoint origin = ScreenPoint(0.0f, y);
+
+        ScrollWheelInput input(aTime, TimeStamp::Now(), 0,
+                               ScrollWheelInput::SCROLLMODE_SMOOTH,
+                               ScrollWheelInput::SCROLLDELTA_PIXEL,
+                               origin,
+                               0.0f, 0.0f,
+                               false,
+                               status);
+        return HandleScrollEventCore(input);
+    }
+
+    bool HandleScrollBarTouchEventH(int32_t aAction, int64_t aTime, float x) {
+        ScrollWheelInput::ScrollStatusType status;
+
+        switch (aAction) {
+            case AndroidMotionEvent::ACTION_UP:
+                status = ScrollWheelInput::SCROLLSTATUS_H_END;
+                break;
+            case AndroidMotionEvent::ACTION_MOVE:
+                status = ScrollWheelInput::SCROLLSTATUS_H_CONTINUE;
+                break;
+            case AndroidMotionEvent::ACTION_DOWN:
+                return true;
+            default:
+                return false;
+        }
+
+        ScreenPoint origin = ScreenPoint(x, 0.0f);
+
+        ScrollWheelInput input(aTime, TimeStamp::Now(), 0,
+                               ScrollWheelInput::SCROLLMODE_SMOOTH,
+                               ScrollWheelInput::SCROLLDELTA_PIXEL,
+                               origin,
+                               0.0f, 0.0f,
+                               false,
+                               status);
+        return HandleScrollEventCore(input);
+    }
+
     bool HandleMouseEvent(int32_t aAction, int64_t aTime, int32_t aMetaState,
                           float aX, float aY, int buttons)
     {
+    #define SCROLL_BAR_THICK 15
+
         MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
 
         MutexAutoLock lock(mWindowLock);
@@ -610,6 +672,16 @@ public:
             return false;
         }
 
+        if ((((int)aX + SCROLL_BAR_THICK) > mWindow->mBounds.width)
+            && HandleScrollBarTouchEventV(aAction, aTime, aY)) {
+            return true;
+        }
+
+        if ((((int)aY + SCROLL_BAR_THICK) > mWindow->mBounds.height)
+            && HandleScrollBarTouchEventH(aAction, aTime, aX)) {
+            return true;
+        }
+
         RefPtr<APZCTreeManager> controller = mWindow->mAPZC;
         if (!controller) {
             return false;