Rename IFWL classes which do not have CFWL equivalents

This CL moves the IFWL classes that do not have CFWL class buddies to have the
CFWL name. This CL leaves the tree in a weird state of having CFWL be two
hierarchies, one of which is intertwined with the IFWL hierarchy. This should
be commited just before the CL to move the rest of IFWL to CFWL.

Review-Url: https://codereview.chromium.org/2525083002

1 files changed, 563 insertions, 0 deletions

diff --git a/xfa/fwl/core/cfwl_scrollbar.cpp b/xfa/fwl/core/cfwl_scrollbar.cpp
new file mode 100644
index 0000000000..85ab271258
--- /dev/null
+++ b/xfa/fwl/core/cfwl_scrollbar.cpp
@@ -0,0 +1,563 @@
+// Copyright 2014 PDFium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
+
+#include "xfa/fwl/core/cfwl_scrollbar.h"
+
+#include <algorithm>
+#include <memory>
+#include <utility>
+
+#include "third_party/base/ptr_util.h"
+#include "xfa/fwl/core/cfwl_msgmouse.h"
+#include "xfa/fwl/core/cfwl_msgmousewheel.h"
+#include "xfa/fwl/core/cfwl_notedriver.h"
+#include "xfa/fwl/core/cfwl_themebackground.h"
+#include "xfa/fwl/core/cfwl_themepart.h"
+#include "xfa/fwl/core/cfwl_timerinfo.h"
+#include "xfa/fwl/core/ifwl_themeprovider.h"
+
+#define FWL_SCROLLBAR_Elapse 500
+#define FWL_SCROLLBAR_MinThumb 5
+
+CFWL_ScrollBar::CFWL_ScrollBar(
+    const CFWL_App* app,
+    std::unique_ptr<CFWL_WidgetProperties> properties,
+    IFWL_Widget* pOuter)
+    : IFWL_Widget(app, std::move(properties), pOuter),
+      m_pTimerInfo(nullptr),
+      m_fRangeMin(0),
+      m_fRangeMax(-1),
+      m_fPageSize(0),
+      m_fStepSize(0),
+      m_fPos(0),
+      m_fTrackPos(0),
+      m_iMinButtonState(CFWL_PartState_Normal),
+      m_iMaxButtonState(CFWL_PartState_Normal),
+      m_iThumbButtonState(CFWL_PartState_Normal),
+      m_iMinTrackState(CFWL_PartState_Normal),
+      m_iMaxTrackState(CFWL_PartState_Normal),
+      m_fLastTrackPos(0),
+      m_cpTrackPointX(0),
+      m_cpTrackPointY(0),
+      m_iMouseWheel(0),
+      m_bMouseDown(false),
+      m_fButtonLen(0),
+      m_bMinSize(false),
+      m_fMinThumb(FWL_SCROLLBAR_MinThumb),
+      m_Timer(this) {
+  m_rtClient.Reset();
+  m_rtThumb.Reset();
+  m_rtMinBtn.Reset();
+  m_rtMaxBtn.Reset();
+  m_rtMinTrack.Reset();
+  m_rtMaxTrack.Reset();
+}
+
+CFWL_ScrollBar::~CFWL_ScrollBar() {}
+
+FWL_Type CFWL_ScrollBar::GetClassID() const {
+  return FWL_Type::ScrollBar;
+}
+
+void CFWL_ScrollBar::GetWidgetRect(CFX_RectF& rect, bool bAutoSize) {
+  if (!bAutoSize) {
+    rect = m_pProperties->m_rtWidget;
+    return;
+  }
+
+  rect.Set(0, 0, 0, 0);
+  FX_FLOAT* pfMinWidth = static_cast<FX_FLOAT*>(
+      GetThemeCapacity(CFWL_WidgetCapacity::ScrollBarWidth));
+  if (!pfMinWidth)
+    return;
+  if (IsVertical())
+    rect.Set(0, 0, (*pfMinWidth), (*pfMinWidth) * 3);
+  else
+    rect.Set(0, 0, (*pfMinWidth) * 3, (*pfMinWidth));
+  IFWL_Widget::GetWidgetRect(rect, true);
+}
+
+void CFWL_ScrollBar::Update() {
+  if (IsLocked())
+    return;
+  if (!m_pProperties->m_pThemeProvider)
+    m_pProperties->m_pThemeProvider = GetAvailableTheme();
+
+  Layout();
+}
+
+void CFWL_ScrollBar::DrawWidget(CFX_Graphics* pGraphics,
+                                const CFX_Matrix* pMatrix) {
+  if (!pGraphics)
+    return;
+  if (!m_pProperties->m_pThemeProvider)
+    return;
+
+  IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider;
+  if (HasBorder())
+    DrawBorder(pGraphics, CFWL_Part::Border, pTheme, pMatrix);
+  if (HasEdge())
+    DrawEdge(pGraphics, CFWL_Part::Edge, pTheme, pMatrix);
+  DrawTrack(pGraphics, pTheme, true, pMatrix);
+  DrawTrack(pGraphics, pTheme, false, pMatrix);
+  DrawArrowBtn(pGraphics, pTheme, true, pMatrix);
+  DrawArrowBtn(pGraphics, pTheme, false, pMatrix);
+  DrawThumb(pGraphics, pTheme, pMatrix);
+}
+
+void CFWL_ScrollBar::SetTrackPos(FX_FLOAT fTrackPos) {
+  m_fTrackPos = fTrackPos;
+  CalcThumbButtonRect(m_rtThumb);
+  CalcMinTrackRect(m_rtMinTrack);
+  CalcMaxTrackRect(m_rtMaxTrack);
+}
+
+bool CFWL_ScrollBar::DoScroll(FWL_SCBCODE dwCode, FX_FLOAT fPos) {
+  if (dwCode == FWL_SCBCODE::None)
+    return false;
+  return OnScroll(dwCode, fPos);
+}
+
+void CFWL_ScrollBar::DrawTrack(CFX_Graphics* pGraphics,
+                               IFWL_ThemeProvider* pTheme,
+                               bool bLower,
+                               const CFX_Matrix* pMatrix) {
+  CFWL_ThemeBackground param;
+  param.m_pWidget = this;
+  param.m_iPart = bLower ? CFWL_Part::LowerTrack : CFWL_Part::UpperTrack;
+  param.m_dwStates = (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)
+                         ? CFWL_PartState_Disabled
+                         : (bLower ? m_iMinTrackState : m_iMaxTrackState);
+  param.m_pGraphics = pGraphics;
+  param.m_matrix.Concat(*pMatrix);
+  param.m_rtPart = bLower ? m_rtMinTrack : m_rtMaxTrack;
+  pTheme->DrawBackground(&param);
+}
+
+void CFWL_ScrollBar::DrawArrowBtn(CFX_Graphics* pGraphics,
+                                  IFWL_ThemeProvider* pTheme,
+                                  bool bMinBtn,
+                                  const CFX_Matrix* pMatrix) {
+  CFWL_ThemeBackground param;
+  param.m_pWidget = this;
+  param.m_iPart = bMinBtn ? CFWL_Part::ForeArrow : CFWL_Part::BackArrow;
+  param.m_dwStates = (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)
+                         ? CFWL_PartState_Disabled
+                         : (bMinBtn ? m_iMinButtonState : m_iMaxButtonState);
+  param.m_pGraphics = pGraphics;
+  param.m_matrix.Concat(*pMatrix);
+  param.m_rtPart = bMinBtn ? m_rtMinBtn : m_rtMaxBtn;
+  if (param.m_rtPart.height > 0 && param.m_rtPart.width > 0)
+    pTheme->DrawBackground(&param);
+}
+
+void CFWL_ScrollBar::DrawThumb(CFX_Graphics* pGraphics,
+                               IFWL_ThemeProvider* pTheme,
+                               const CFX_Matrix* pMatrix) {
+  CFWL_ThemeBackground param;
+  param.m_pWidget = this;
+  param.m_iPart = CFWL_Part::Thumb;
+  param.m_dwStates = (m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled)
+                         ? CFWL_PartState_Disabled
+                         : m_iThumbButtonState;
+  param.m_pGraphics = pGraphics;
+  param.m_matrix.Concat(*pMatrix);
+  param.m_rtPart = m_rtThumb;
+  pTheme->DrawBackground(&param);
+}
+
+void CFWL_ScrollBar::Layout() {
+  IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider;
+  CFWL_ThemePart part;
+  part.m_pWidget = this;
+  m_fMinThumb = *static_cast<FX_FLOAT*>(
+      pTheme->GetCapacity(&part, CFWL_WidgetCapacity::Size));
+  GetClientRect(m_rtClient);
+  CalcButtonLen();
+  CalcMinButtonRect(m_rtMinBtn);
+  CalcMaxButtonRect(m_rtMaxBtn);
+  CalcThumbButtonRect(m_rtThumb);
+  CalcMinTrackRect(m_rtMinTrack);
+  CalcMaxTrackRect(m_rtMaxTrack);
+}
+
+void CFWL_ScrollBar::CalcButtonLen() {
+  m_fButtonLen = IsVertical() ? m_rtClient.width : m_rtClient.height;
+  FX_FLOAT fLength = IsVertical() ? m_rtClient.height : m_rtClient.width;
+  if (fLength < m_fButtonLen * 2) {
+    m_fButtonLen = fLength / 2;
+    m_bMinSize = true;
+  } else {
+    m_bMinSize = false;
+  }
+}
+
+void CFWL_ScrollBar::CalcMinButtonRect(CFX_RectF& rect) {
+  rect.left = m_rtClient.left;
+  rect.top = m_rtClient.top;
+  rect.width = IsVertical() ? m_rtClient.width : m_fButtonLen;
+  rect.height = IsVertical() ? m_fButtonLen : m_rtClient.height;
+}
+
+void CFWL_ScrollBar::CalcMaxButtonRect(CFX_RectF& rect) {
+  rect.left =
+      IsVertical() ? m_rtClient.left : m_rtClient.right() - m_fButtonLen;
+  rect.top = IsVertical() ? m_rtClient.bottom() - m_fButtonLen : m_rtClient.top;
+  rect.width = IsVertical() ? m_rtClient.width : m_fButtonLen;
+  rect.height = IsVertical() ? m_fButtonLen : m_rtClient.height;
+}
+
+void CFWL_ScrollBar::CalcThumbButtonRect(CFX_RectF& rect) {
+  if (!IsEnabled()) {
+    m_rtThumb.Reset();
+    return;
+  }
+  if (m_bMinSize) {
+    m_rtThumb.Empty();
+    return;
+  }
+
+  FX_FLOAT fRange = m_fRangeMax - m_fRangeMin;
+  memset(&rect, 0, sizeof(CFX_Rect));
+  if (fRange < 0) {
+    if (IsVertical())
+      rect.Set(m_rtClient.left, m_rtMaxBtn.bottom(), m_rtClient.width, 0);
+    else
+      rect.Set(m_rtMaxBtn.right(), m_rtClient.top, 0, m_rtClient.height);
+    return;
+  }
+
+  CFX_RectF rtClient = m_rtClient;
+  FX_FLOAT fLength = IsVertical() ? rtClient.height : rtClient.width;
+  FX_FLOAT fSize = m_fButtonLen;
+  fLength -= fSize * 2.0f;
+  if (fLength < fSize)
+    fLength = 0.0f;
+
+  FX_FLOAT fThumbSize = fLength * fLength / (fRange + fLength);
+  fThumbSize = std::max(fThumbSize, m_fMinThumb);
+
+  FX_FLOAT fDiff = std::max(fLength - fThumbSize, 0.0f);
+  FX_FLOAT fTrackPos =
+      std::max(std::min(m_fTrackPos, m_fRangeMax), m_fRangeMin);
+  if (!fRange)
+    return;
+
+  FX_FLOAT iPos = fSize + fDiff * (fTrackPos - m_fRangeMin) / fRange;
+  rect.left = rtClient.left;
+  if (!IsVertical())
+    rect.left += iPos;
+
+  rect.top = rtClient.top;
+  if (IsVertical())
+    rect.top += iPos;
+
+  rect.width = IsVertical() ? rtClient.width : fThumbSize;
+  rect.height = IsVertical() ? fThumbSize : rtClient.height;
+}
+
+void CFWL_ScrollBar::CalcMinTrackRect(CFX_RectF& rect) {
+  if (m_bMinSize) {
+    rect.Empty();
+    return;
+  }
+
+  FX_FLOAT fBottom = m_rtThumb.bottom();
+  FX_FLOAT fRight = m_rtThumb.right();
+  FX_FLOAT ix = (m_rtThumb.left + fRight) / 2;
+  FX_FLOAT iy = (m_rtThumb.top + fBottom) / 2;
+  rect.left = m_rtClient.left;
+  rect.top = m_rtClient.top;
+  bool bVertical = IsVertical();
+  rect.width = bVertical ? m_rtClient.width : ix;
+  rect.height = bVertical ? iy : m_rtClient.height;
+}
+
+void CFWL_ScrollBar::CalcMaxTrackRect(CFX_RectF& rect) {
+  if (m_bMinSize) {
+    rect.Empty();
+    return;
+  }
+
+  FX_FLOAT ix = (m_rtThumb.left + m_rtThumb.right()) / 2;
+  FX_FLOAT iy = (m_rtThumb.top + m_rtThumb.bottom()) / 2;
+  bool bVertical = IsVertical();
+  rect.left = bVertical ? m_rtClient.left : ix;
+  rect.top = bVertical ? iy : m_rtClient.top;
+  rect.width = bVertical ? m_rtClient.width : m_rtClient.right() - ix;
+  rect.height = bVertical ? m_rtClient.bottom() - iy : m_rtClient.height;
+}
+
+FX_FLOAT CFWL_ScrollBar::GetTrackPointPos(FX_FLOAT fx, FX_FLOAT fy) {
+  FX_FLOAT fDiffX = fx - m_cpTrackPointX;
+  FX_FLOAT fDiffY = fy - m_cpTrackPointY;
+  FX_FLOAT fRange = m_fRangeMax - m_fRangeMin;
+  FX_FLOAT fPos;
+
+  if (IsVertical()) {
+    fPos = fRange * fDiffY /
+           (m_rtMaxBtn.top - m_rtMinBtn.bottom() - m_rtThumb.height);
+  } else {
+    fPos = fRange * fDiffX /
+           (m_rtMaxBtn.left - m_rtMinBtn.right() - m_rtThumb.width);
+  }
+
+  fPos += m_fLastTrackPos;
+  return std::min(std::max(fPos, m_fRangeMin), m_fRangeMax);
+}
+
+void CFWL_ScrollBar::GetTrackRect(CFX_RectF& rect, bool bLower) {
+  bool bDisabled = !!(m_pProperties->m_dwStates & FWL_WGTSTATE_Disabled);
+  if (bDisabled) {
+    rect = bLower ? m_rtMinTrack : m_rtMaxTrack;
+    return;
+  }
+
+  FX_FLOAT fW = m_rtThumb.width / 2;
+  FX_FLOAT fH = m_rtThumb.height / 2;
+  bool bVert = IsVertical();
+  if (bLower) {
+    if (bVert) {
+      FX_FLOAT fMinTrackHeight = m_rtMinTrack.height - fH - m_rtMinBtn.height;
+      fMinTrackHeight = (fMinTrackHeight >= 0.0f) ? fMinTrackHeight : 0.0f;
+      rect.Set(m_rtMinTrack.left, m_rtMinTrack.top + m_rtMinBtn.height,
+               m_rtMinTrack.width, fMinTrackHeight);
+      return;
+    }
+
+    FX_FLOAT fMinTrackWidth = m_rtMinTrack.width - fW - m_rtMinBtn.width + 2;
+    fMinTrackWidth = (fMinTrackWidth >= 0.0f) ? fMinTrackWidth : 0.0f;
+    rect.Set(m_rtMinTrack.left + m_rtMinBtn.width - 1, m_rtMinTrack.top,
+             fMinTrackWidth, m_rtMinTrack.height);
+    return;
+  }
+
+  if (bVert) {
+    FX_FLOAT fMaxTrackHeight = m_rtMaxTrack.height - fH - m_rtMaxBtn.height;
+    fMaxTrackHeight = (fMaxTrackHeight >= 0.0f) ? fMaxTrackHeight : 0.0f;
+    rect.Set(m_rtMaxTrack.left, m_rtMaxTrack.top + fH, m_rtMaxTrack.width,
+             fMaxTrackHeight);
+    return;
+  }
+
+  FX_FLOAT fMaxTrackWidth = m_rtMaxTrack.width - fW - m_rtMaxBtn.width + 2;
+  fMaxTrackWidth = (fMaxTrackWidth >= 0.0f) ? fMaxTrackWidth : 0.0f;
+  rect.Set(m_rtMaxTrack.left + fW, m_rtMaxTrack.top, fMaxTrackWidth,
+           m_rtMaxTrack.height);
+}
+
+bool CFWL_ScrollBar::SendEvent() {
+  if (m_iMinButtonState == CFWL_PartState_Pressed) {
+    DoScroll(FWL_SCBCODE::StepBackward, m_fTrackPos);
+    return false;
+  }
+  if (m_iMaxButtonState == CFWL_PartState_Pressed) {
+    DoScroll(FWL_SCBCODE::StepForward, m_fTrackPos);
+    return false;
+  }
+  if (m_iMinTrackState == CFWL_PartState_Pressed) {
+    DoScroll(FWL_SCBCODE::PageBackward, m_fTrackPos);
+    return m_rtThumb.Contains(m_cpTrackPointX, m_cpTrackPointY);
+  }
+  if (m_iMaxTrackState == CFWL_PartState_Pressed) {
+    DoScroll(FWL_SCBCODE::PageForward, m_fTrackPos);
+    return m_rtThumb.Contains(m_cpTrackPointX, m_cpTrackPointY);
+  }
+  if (m_iMouseWheel) {
+    FWL_SCBCODE dwCode = m_iMouseWheel < 0 ? FWL_SCBCODE::StepForward
+                                           : FWL_SCBCODE::StepBackward;
+    DoScroll(dwCode, m_fTrackPos);
+  }
+  return true;
+}
+
+bool CFWL_ScrollBar::OnScroll(FWL_SCBCODE dwCode, FX_FLOAT fPos) {
+  bool bRet = true;
+  CFWL_EvtScroll ev;
+  ev.m_iScrollCode = dwCode;
+  ev.m_pSrcTarget = this;
+  ev.m_fPos = fPos;
+  ev.m_pRet = &bRet;
+  DispatchEvent(&ev);
+  return bRet;
+}
+
+void CFWL_ScrollBar::OnProcessMessage(CFWL_Message* pMessage) {
+  if (!pMessage)
+    return;
+
+  CFWL_MessageType dwMsgCode = pMessage->GetClassID();
+  if (dwMsgCode == CFWL_MessageType::Mouse) {
+    CFWL_MsgMouse* pMsg = static_cast<CFWL_MsgMouse*>(pMessage);
+    switch (pMsg->m_dwCmd) {
+      case FWL_MouseCommand::LeftButtonDown:
+        OnLButtonDown(pMsg->m_dwFlags, pMsg->m_fx, pMsg->m_fy);
+        break;
+      case FWL_MouseCommand::LeftButtonUp:
+        OnLButtonUp(pMsg->m_dwFlags, pMsg->m_fx, pMsg->m_fy);
+        break;
+      case FWL_MouseCommand::Move:
+        OnMouseMove(pMsg->m_dwFlags, pMsg->m_fx, pMsg->m_fy);
+        break;
+      case FWL_MouseCommand::Leave:
+        OnMouseLeave();
+        break;
+      default:
+        break;
+    }
+  } else if (dwMsgCode == CFWL_MessageType::MouseWheel) {
+    CFWL_MsgMouseWheel* pMsg = static_cast<CFWL_MsgMouseWheel*>(pMessage);
+    OnMouseWheel(pMsg->m_fx, pMsg->m_fy, pMsg->m_dwFlags, pMsg->m_fDeltaX,
+                 pMsg->m_fDeltaY);
+  }
+}
+
+void CFWL_ScrollBar::OnDrawWidget(CFX_Graphics* pGraphics,
+                                  const CFX_Matrix* pMatrix) {
+  DrawWidget(pGraphics, pMatrix);
+}
+
+void CFWL_ScrollBar::OnLButtonDown(uint32_t dwFlags, FX_FLOAT fx, FX_FLOAT fy) {
+  if (!IsEnabled())
+    return;
+
+  m_bMouseDown = true;
+  SetGrab(true);
+  m_cpTrackPointX = fx;
+  m_cpTrackPointY = fy;
+  m_fLastTrackPos = m_fTrackPos;
+  if (m_rtMinBtn.Contains(fx, fy))
+    DoMouseDown(0, m_rtMinBtn, m_iMinButtonState, fx, fy);
+  else if (m_rtThumb.Contains(fx, fy))
+    DoMouseDown(1, m_rtThumb, m_iThumbButtonState, fx, fy);
+  else if (m_rtMaxBtn.Contains(fx, fy))
+    DoMouseDown(2, m_rtMaxBtn, m_iMaxButtonState, fx, fy);
+  else if (m_rtMinTrack.Contains(fx, fy))
+    DoMouseDown(3, m_rtMinTrack, m_iMinTrackState, fx, fy);
+  else
+    DoMouseDown(4, m_rtMaxTrack, m_iMaxTrackState, fx, fy);
+
+  if (!SendEvent())
+    m_pTimerInfo = m_Timer.StartTimer(FWL_SCROLLBAR_Elapse, true);
+}
+
+void CFWL_ScrollBar::OnLButtonUp(uint32_t dwFlags, FX_FLOAT fx, FX_FLOAT fy) {
+  m_pTimerInfo->StopTimer();
+  m_bMouseDown = false;
+  DoMouseUp(0, m_rtMinBtn, m_iMinButtonState, fx, fy);
+  DoMouseUp(1, m_rtThumb, m_iThumbButtonState, fx, fy);
+  DoMouseUp(2, m_rtMaxBtn, m_iMaxButtonState, fx, fy);
+  DoMouseUp(3, m_rtMinTrack, m_iMinTrackState, fx, fy);
+  DoMouseUp(4, m_rtMaxTrack, m_iMaxTrackState, fx, fy);
+  SetGrab(false);
+}
+
+void CFWL_ScrollBar::OnMouseMove(uint32_t dwFlags, FX_FLOAT fx, FX_FLOAT fy) {
+  DoMouseMove(0, m_rtMinBtn, m_iMinButtonState, fx, fy);
+  DoMouseMove(1, m_rtThumb, m_iThumbButtonState, fx, fy);
+  DoMouseMove(2, m_rtMaxBtn, m_iMaxButtonState, fx, fy);
+  DoMouseMove(3, m_rtMinTrack, m_iMinTrackState, fx, fy);
+  DoMouseMove(4, m_rtMaxTrack, m_iMaxTrackState, fx, fy);
+}
+
+void CFWL_ScrollBar::OnMouseLeave() {
+  DoMouseLeave(0, m_rtMinBtn, m_iMinButtonState);
+  DoMouseLeave(1, m_rtThumb, m_iThumbButtonState);
+  DoMouseLeave(2, m_rtMaxBtn, m_iMaxButtonState);
+  DoMouseLeave(3, m_rtMinTrack, m_iMinTrackState);
+  DoMouseLeave(4, m_rtMaxTrack, m_iMaxTrackState);
+}
+
+void CFWL_ScrollBar::OnMouseWheel(FX_FLOAT fx,
+                                  FX_FLOAT fy,
+                                  uint32_t dwFlags,
+                                  FX_FLOAT fDeltaX,
+                                  FX_FLOAT fDeltaY) {
+  m_iMouseWheel = (int32_t)fDeltaX;
+  SendEvent();
+  m_iMouseWheel = 0;
+}
+
+void CFWL_ScrollBar::DoMouseDown(int32_t iItem,
+                                 const CFX_RectF& rtItem,
+                                 int32_t& iState,
+                                 FX_FLOAT fx,
+                                 FX_FLOAT fy) {
+  if (!rtItem.Contains(fx, fy))
+    return;
+  if (iState == CFWL_PartState_Pressed)
+    return;
+
+  iState = CFWL_PartState_Pressed;
+  Repaint(&rtItem);
+}
+
+void CFWL_ScrollBar::DoMouseUp(int32_t iItem,
+                               const CFX_RectF& rtItem,
+                               int32_t& iState,
+                               FX_FLOAT fx,
+                               FX_FLOAT fy) {
+  int32_t iNewState =
+      rtItem.Contains(fx, fy) ? CFWL_PartState_Hovered : CFWL_PartState_Normal;
+  if (iState == iNewState)
+    return;
+
+  iState = iNewState;
+  Repaint(&rtItem);
+  OnScroll(FWL_SCBCODE::EndScroll, m_fTrackPos);
+}
+
+void CFWL_ScrollBar::DoMouseMove(int32_t iItem,
+                                 const CFX_RectF& rtItem,
+                                 int32_t& iState,
+                                 FX_FLOAT fx,
+                                 FX_FLOAT fy) {
+  if (!m_bMouseDown) {
+    int32_t iNewState = rtItem.Contains(fx, fy) ? CFWL_PartState_Hovered
+                                                : CFWL_PartState_Normal;
+    if (iState == iNewState)
+      return;
+
+    iState = iNewState;
+    Repaint(&rtItem);
+  } else if ((2 == iItem) && (m_iThumbButtonState == CFWL_PartState_Pressed)) {
+    FX_FLOAT fPos = GetTrackPointPos(fx, fy);
+    m_fTrackPos = fPos;
+    OnScroll(FWL_SCBCODE::TrackPos, fPos);
+  }
+}
+
+void CFWL_ScrollBar::DoMouseLeave(int32_t iItem,
+                                  const CFX_RectF& rtItem,
+                                  int32_t& iState) {
+  if (iState == CFWL_PartState_Normal)
+    return;
+
+  iState = CFWL_PartState_Normal;
+  Repaint(&rtItem);
+}
+
+void CFWL_ScrollBar::DoMouseHover(int32_t iItem,
+                                  const CFX_RectF& rtItem,
+                                  int32_t& iState) {
+  if (iState == CFWL_PartState_Hovered)
+    return;
+
+  iState = CFWL_PartState_Hovered;
+  Repaint(&rtItem);
+}
+
+CFWL_ScrollBar::Timer::Timer(CFWL_ScrollBar* pToolTip) : CFWL_Timer(pToolTip) {}
+
+void CFWL_ScrollBar::Timer::Run(CFWL_TimerInfo* pTimerInfo) {
+  CFWL_ScrollBar* pButton = static_cast<CFWL_ScrollBar*>(m_pWidget);
+
+  if (pButton->m_pTimerInfo)
+    pButton->m_pTimerInfo->StopTimer();
+
+  if (!pButton->SendEvent())
+    pButton->m_pTimerInfo = StartTimer(0, true);
+}