Rename PWL_FooBar files to cpwl_foo_bar.

Change-Id: I7ed0ba0acbbee291e285555974ebf50c0073668f
Reviewed-on: https://pdfium-review.googlesource.com/6250
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Commit-Queue: Lei Zhang <thestig@chromium.org>

1 files changed, 1186 insertions, 0 deletions

diff --git a/fpdfsdk/pdfwindow/cpwl_scroll_bar.cpp b/fpdfsdk/pdfwindow/cpwl_scroll_bar.cpp
new file mode 100644
index 0000000000..2f234b2432
--- /dev/null
+++ b/fpdfsdk/pdfwindow/cpwl_scroll_bar.cpp
@@ -0,0 +1,1186 @@
+// 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 "fpdfsdk/pdfwindow/cpwl_scroll_bar.h"
+
+#include "core/fxge/cfx_pathdata.h"
+#include "core/fxge/cfx_renderdevice.h"
+#include "fpdfsdk/pdfwindow/cpwl_utils.h"
+#include "fpdfsdk/pdfwindow/cpwl_wnd.h"
+
+PWL_FLOATRANGE::PWL_FLOATRANGE() {
+  Default();
+}
+
+PWL_FLOATRANGE::PWL_FLOATRANGE(float min, float max) {
+  Set(min, max);
+}
+
+void PWL_FLOATRANGE::Default() {
+  fMin = 0;
+  fMax = 0;
+}
+
+void PWL_FLOATRANGE::Set(float min, float max) {
+  if (min > max) {
+    fMin = max;
+    fMax = min;
+  } else {
+    fMin = min;
+    fMax = max;
+  }
+}
+
+bool PWL_FLOATRANGE::In(float x) const {
+  return (IsFloatBigger(x, fMin) || IsFloatEqual(x, fMin)) &&
+         (IsFloatSmaller(x, fMax) || IsFloatEqual(x, fMax));
+}
+
+float PWL_FLOATRANGE::GetWidth() const {
+  return fMax - fMin;
+}
+
+PWL_SCROLL_PRIVATEDATA::PWL_SCROLL_PRIVATEDATA() {
+  Default();
+}
+
+void PWL_SCROLL_PRIVATEDATA::Default() {
+  ScrollRange.Default();
+  fScrollPos = ScrollRange.fMin;
+  fClientWidth = 0;
+  fBigStep = 10;
+  fSmallStep = 1;
+}
+
+void PWL_SCROLL_PRIVATEDATA::SetScrollRange(float min, float max) {
+  ScrollRange.Set(min, max);
+
+  if (IsFloatSmaller(fScrollPos, ScrollRange.fMin))
+    fScrollPos = ScrollRange.fMin;
+  if (IsFloatBigger(fScrollPos, ScrollRange.fMax))
+    fScrollPos = ScrollRange.fMax;
+}
+
+void PWL_SCROLL_PRIVATEDATA::SetClientWidth(float width) {
+  fClientWidth = width;
+}
+
+void PWL_SCROLL_PRIVATEDATA::SetSmallStep(float step) {
+  fSmallStep = step;
+}
+
+void PWL_SCROLL_PRIVATEDATA::SetBigStep(float step) {
+  fBigStep = step;
+}
+
+bool PWL_SCROLL_PRIVATEDATA::SetPos(float pos) {
+  if (ScrollRange.In(pos)) {
+    fScrollPos = pos;
+    return true;
+  }
+  return false;
+}
+
+void PWL_SCROLL_PRIVATEDATA::AddSmall() {
+  if (!SetPos(fScrollPos + fSmallStep))
+    SetPos(ScrollRange.fMax);
+}
+
+void PWL_SCROLL_PRIVATEDATA::SubSmall() {
+  if (!SetPos(fScrollPos - fSmallStep))
+    SetPos(ScrollRange.fMin);
+}
+
+void PWL_SCROLL_PRIVATEDATA::AddBig() {
+  if (!SetPos(fScrollPos + fBigStep))
+    SetPos(ScrollRange.fMax);
+}
+
+void PWL_SCROLL_PRIVATEDATA::SubBig() {
+  if (!SetPos(fScrollPos - fBigStep))
+    SetPos(ScrollRange.fMin);
+}
+
+CPWL_SBButton::CPWL_SBButton(PWL_SCROLLBAR_TYPE eScrollBarType,
+                             PWL_SBBUTTON_TYPE eButtonType) {
+  m_eScrollBarType = eScrollBarType;
+  m_eSBButtonType = eButtonType;
+
+  m_bMouseDown = false;
+}
+
+CPWL_SBButton::~CPWL_SBButton() {}
+
+CFX_ByteString CPWL_SBButton::GetClassName() const {
+  return "CPWL_SBButton";
+}
+
+void CPWL_SBButton::OnCreate(PWL_CREATEPARAM& cp) {
+  cp.eCursorType = FXCT_ARROW;
+}
+
+void CPWL_SBButton::GetThisAppearanceStream(CFX_ByteTextBuf& sAppStream) {
+  CPWL_Wnd::GetThisAppearanceStream(sAppStream);
+
+  if (!IsVisible())
+    return;
+
+  CFX_ByteTextBuf sButton;
+
+  CFX_FloatRect rectWnd = GetWindowRect();
+
+  if (rectWnd.IsEmpty())
+    return;
+
+  sAppStream << "q\n";
+
+  CFX_PointF ptCenter = GetCenterPoint();
+
+  switch (m_eScrollBarType) {
+    case SBT_HSCROLL:
+      switch (m_eSBButtonType) {
+        case PSBT_MIN: {
+          CFX_PointF pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f, ptCenter.y);
+          CFX_PointF pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,
+                         ptCenter.y + PWL_TRIANGLE_HALFLEN);
+          CFX_PointF pt3(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,
+                         ptCenter.y - PWL_TRIANGLE_HALFLEN);
+
+          if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 &&
+              rectWnd.top - rectWnd.bottom > PWL_TRIANGLE_HALFLEN) {
+            sButton << "0 g\n";
+            sButton << pt1.x << " " << pt1.y << " m\n";
+            sButton << pt2.x << " " << pt2.y << " l\n";
+            sButton << pt3.x << " " << pt3.y << " l\n";
+            sButton << pt1.x << " " << pt1.y << " l f\n";
+
+            sAppStream << sButton;
+          }
+        } break;
+        case PSBT_MAX: {
+          CFX_PointF pt1(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f, ptCenter.y);
+          CFX_PointF pt2(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,
+                         ptCenter.y + PWL_TRIANGLE_HALFLEN);
+          CFX_PointF pt3(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,
+                         ptCenter.y - PWL_TRIANGLE_HALFLEN);
+
+          if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 &&
+              rectWnd.top - rectWnd.bottom > PWL_TRIANGLE_HALFLEN) {
+            sButton << "0 g\n";
+            sButton << pt1.x << " " << pt1.y << " m\n";
+            sButton << pt2.x << " " << pt2.y << " l\n";
+            sButton << pt3.x << " " << pt3.y << " l\n";
+            sButton << pt1.x << " " << pt1.y << " l f\n";
+
+            sAppStream << sButton;
+          }
+        } break;
+        default:
+          break;
+      }
+      break;
+    case SBT_VSCROLL:
+      switch (m_eSBButtonType) {
+        case PSBT_MIN: {
+          CFX_PointF pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN,
+                         ptCenter.y - PWL_TRIANGLE_HALFLEN * 0.5f);
+          CFX_PointF pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN,
+                         ptCenter.y - PWL_TRIANGLE_HALFLEN * 0.5f);
+          CFX_PointF pt3(ptCenter.x, ptCenter.y + PWL_TRIANGLE_HALFLEN * 0.5f);
+
+          if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 &&
+              rectWnd.top - rectWnd.bottom > PWL_TRIANGLE_HALFLEN) {
+            sButton << "0 g\n";
+            sButton << pt1.x << " " << pt1.y << " m\n";
+            sButton << pt2.x << " " << pt2.y << " l\n";
+            sButton << pt3.x << " " << pt3.y << " l\n";
+            sButton << pt1.x << " " << pt1.y << " l f\n";
+
+            sAppStream << sButton;
+          }
+        } break;
+        case PSBT_MAX: {
+          CFX_PointF pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN,
+                         ptCenter.y + PWL_TRIANGLE_HALFLEN * 0.5f);
+          CFX_PointF pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN,
+                         ptCenter.y + PWL_TRIANGLE_HALFLEN * 0.5f);
+          CFX_PointF pt3(ptCenter.x, ptCenter.y - PWL_TRIANGLE_HALFLEN * 0.5f);
+
+          if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 &&
+              rectWnd.top - rectWnd.bottom > PWL_TRIANGLE_HALFLEN) {
+            sButton << "0 g\n";
+            sButton << pt1.x << " " << pt1.y << " m\n";
+            sButton << pt2.x << " " << pt2.y << " l\n";
+            sButton << pt3.x << " " << pt3.y << " l\n";
+            sButton << pt1.x << " " << pt1.y << " l f\n";
+
+            sAppStream << sButton;
+          }
+        } break;
+        default:
+          break;
+      }
+      break;
+    default:
+      break;
+  }
+
+  sAppStream << "Q\n";
+}
+
+void CPWL_SBButton::DrawThisAppearance(CFX_RenderDevice* pDevice,
+                                       CFX_Matrix* pUser2Device) {
+  if (!IsVisible())
+    return;
+
+  CFX_FloatRect rectWnd = GetWindowRect();
+  if (rectWnd.IsEmpty())
+    return;
+
+  CFX_PointF ptCenter = GetCenterPoint();
+  int32_t nTransparency = GetTransparency();
+
+  switch (m_eScrollBarType) {
+    case SBT_HSCROLL:
+      CPWL_Wnd::DrawThisAppearance(pDevice, pUser2Device);
+      switch (m_eSBButtonType) {
+        case PSBT_MIN: {
+          CFX_PointF pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f, ptCenter.y);
+          CFX_PointF pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,
+                         ptCenter.y + PWL_TRIANGLE_HALFLEN);
+          CFX_PointF pt3(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,
+                         ptCenter.y - PWL_TRIANGLE_HALFLEN);
+
+          if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 &&
+              rectWnd.top - rectWnd.bottom > PWL_TRIANGLE_HALFLEN) {
+            CFX_PathData path;
+            path.AppendPoint(pt1, FXPT_TYPE::MoveTo, false);
+            path.AppendPoint(pt2, FXPT_TYPE::LineTo, false);
+            path.AppendPoint(pt3, FXPT_TYPE::LineTo, false);
+            path.AppendPoint(pt1, FXPT_TYPE::LineTo, false);
+
+            pDevice->DrawPath(&path, pUser2Device, nullptr,
+                              PWL_DEFAULT_BLACKCOLOR.ToFXColor(nTransparency),
+                              0, FXFILL_ALTERNATE);
+          }
+        } break;
+        case PSBT_MAX: {
+          CFX_PointF pt1(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f, ptCenter.y);
+          CFX_PointF pt2(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,
+                         ptCenter.y + PWL_TRIANGLE_HALFLEN);
+          CFX_PointF pt3(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,
+                         ptCenter.y - PWL_TRIANGLE_HALFLEN);
+
+          if (rectWnd.right - rectWnd.left > PWL_TRIANGLE_HALFLEN * 2 &&
+              rectWnd.top - rectWnd.bottom > PWL_TRIANGLE_HALFLEN) {
+            CFX_PathData path;
+            path.AppendPoint(pt1, FXPT_TYPE::MoveTo, false);
+            path.AppendPoint(pt2, FXPT_TYPE::LineTo, false);
+            path.AppendPoint(pt3, FXPT_TYPE::LineTo, false);
+            path.AppendPoint(pt1, FXPT_TYPE::LineTo, false);
+
+            pDevice->DrawPath(&path, pUser2Device, nullptr,
+                              PWL_DEFAULT_BLACKCOLOR.ToFXColor(nTransparency),
+                              0, FXFILL_ALTERNATE);
+          }
+        } break;
+        default:
+          break;
+      }
+      break;
+    case SBT_VSCROLL:
+      switch (m_eSBButtonType) {
+        case PSBT_MIN: {
+          // draw border
+          CFX_FloatRect rcDraw = rectWnd;
+          CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
+                                     ArgbEncode(nTransparency, 100, 100, 100),
+                                     0.0f);
+
+          // draw inner border
+          rcDraw = CPWL_Utils::DeflateRect(rectWnd, 0.5f);
+          CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
+                                     ArgbEncode(nTransparency, 255, 255, 255),
+                                     1.0f);
+
+          // draw background
+
+          rcDraw = CPWL_Utils::DeflateRect(rectWnd, 1.0f);
+
+          if (IsEnabled())
+            CPWL_Utils::DrawShadow(pDevice, pUser2Device, true, false, rcDraw,
+                                   nTransparency, 80, 220);
+          else
+            CPWL_Utils::DrawFillRect(pDevice, pUser2Device, rcDraw,
+                                     ArgbEncode(255, 255, 255, 255));
+
+          // draw arrow
+
+          if (rectWnd.top - rectWnd.bottom > 6.0f) {
+            float fX = rectWnd.left + 1.5f;
+            float fY = rectWnd.bottom;
+            CFX_PointF pts[7] = {CFX_PointF(fX + 2.5f, fY + 4.0f),
+                                 CFX_PointF(fX + 2.5f, fY + 3.0f),
+                                 CFX_PointF(fX + 4.5f, fY + 5.0f),
+                                 CFX_PointF(fX + 6.5f, fY + 3.0f),
+                                 CFX_PointF(fX + 6.5f, fY + 4.0f),
+                                 CFX_PointF(fX + 4.5f, fY + 6.0f),
+                                 CFX_PointF(fX + 2.5f, fY + 4.0f)};
+
+            if (IsEnabled())
+              CPWL_Utils::DrawFillArea(
+                  pDevice, pUser2Device, pts, 7,
+                  ArgbEncode(nTransparency, 255, 255, 255));
+            else
+              CPWL_Utils::DrawFillArea(
+                  pDevice, pUser2Device, pts, 7,
+                  PWL_DEFAULT_HEAVYGRAYCOLOR.ToFXColor(255));
+          }
+        } break;
+        case PSBT_MAX: {
+          // draw border
+          CFX_FloatRect rcDraw = rectWnd;
+          CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
+                                     ArgbEncode(nTransparency, 100, 100, 100),
+                                     0.0f);
+
+          // draw inner border
+          rcDraw = CPWL_Utils::DeflateRect(rectWnd, 0.5f);
+          CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
+                                     ArgbEncode(nTransparency, 255, 255, 255),
+                                     1.0f);
+
+          // draw background
+          rcDraw = CPWL_Utils::DeflateRect(rectWnd, 1.0f);
+          if (IsEnabled())
+            CPWL_Utils::DrawShadow(pDevice, pUser2Device, true, false, rcDraw,
+                                   nTransparency, 80, 220);
+          else
+            CPWL_Utils::DrawFillRect(pDevice, pUser2Device, rcDraw,
+                                     ArgbEncode(255, 255, 255, 255));
+
+          // draw arrow
+
+          if (rectWnd.top - rectWnd.bottom > 6.0f) {
+            float fX = rectWnd.left + 1.5f;
+            float fY = rectWnd.bottom;
+
+            CFX_PointF pts[7] = {CFX_PointF(fX + 2.5f, fY + 5.0f),
+                                 CFX_PointF(fX + 2.5f, fY + 6.0f),
+                                 CFX_PointF(fX + 4.5f, fY + 4.0f),
+                                 CFX_PointF(fX + 6.5f, fY + 6.0f),
+                                 CFX_PointF(fX + 6.5f, fY + 5.0f),
+                                 CFX_PointF(fX + 4.5f, fY + 3.0f),
+                                 CFX_PointF(fX + 2.5f, fY + 5.0f)};
+
+            if (IsEnabled())
+              CPWL_Utils::DrawFillArea(
+                  pDevice, pUser2Device, pts, 7,
+                  ArgbEncode(nTransparency, 255, 255, 255));
+            else
+              CPWL_Utils::DrawFillArea(
+                  pDevice, pUser2Device, pts, 7,
+                  PWL_DEFAULT_HEAVYGRAYCOLOR.ToFXColor(255));
+          }
+        } break;
+        case PSBT_POS: {
+          // draw border
+          CFX_FloatRect rcDraw = rectWnd;
+          CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
+                                     ArgbEncode(nTransparency, 100, 100, 100),
+                                     0.0f);
+
+          // draw inner border
+          rcDraw = CPWL_Utils::DeflateRect(rectWnd, 0.5f);
+          CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
+                                     ArgbEncode(nTransparency, 255, 255, 255),
+                                     1.0f);
+
+          if (IsEnabled()) {
+            // draw shadow effect
+
+            CFX_PointF ptTop = CFX_PointF(rectWnd.left, rectWnd.top - 1.0f);
+            CFX_PointF ptBottom =
+                CFX_PointF(rectWnd.left, rectWnd.bottom + 1.0f);
+
+            ptTop.x += 1.5f;
+            ptBottom.x += 1.5f;
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
+                                       ArgbEncode(nTransparency, 210, 210, 210),
+                                       1.0f);
+
+            ptTop.x += 1.0f;
+            ptBottom.x += 1.0f;
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
+                                       ArgbEncode(nTransparency, 220, 220, 220),
+                                       1.0f);
+
+            ptTop.x += 1.0f;
+            ptBottom.x += 1.0f;
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
+                                       ArgbEncode(nTransparency, 240, 240, 240),
+                                       1.0f);
+
+            ptTop.x += 1.0f;
+            ptBottom.x += 1.0f;
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
+                                       ArgbEncode(nTransparency, 240, 240, 240),
+                                       1.0f);
+
+            ptTop.x += 1.0f;
+            ptBottom.x += 1.0f;
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
+                                       ArgbEncode(nTransparency, 210, 210, 210),
+                                       1.0f);
+
+            ptTop.x += 1.0f;
+            ptBottom.x += 1.0f;
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
+                                       ArgbEncode(nTransparency, 180, 180, 180),
+                                       1.0f);
+
+            ptTop.x += 1.0f;
+            ptBottom.x += 1.0f;
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
+                                       ArgbEncode(nTransparency, 150, 150, 150),
+                                       1.0f);
+
+            ptTop.x += 1.0f;
+            ptBottom.x += 1.0f;
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
+                                       ArgbEncode(nTransparency, 150, 150, 150),
+                                       1.0f);
+
+            ptTop.x += 1.0f;
+            ptBottom.x += 1.0f;
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
+                                       ArgbEncode(nTransparency, 180, 180, 180),
+                                       1.0f);
+
+            ptTop.x += 1.0f;
+            ptBottom.x += 1.0f;
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
+                                       ArgbEncode(nTransparency, 210, 210, 210),
+                                       1.0f);
+          } else {
+            CPWL_Utils::DrawFillRect(pDevice, pUser2Device, rcDraw,
+                                     ArgbEncode(255, 255, 255, 255));
+          }
+
+          // draw friction
+
+          if (rectWnd.Height() > 8.0f) {
+            FX_COLORREF crStroke = ArgbEncode(nTransparency, 120, 120, 120);
+            if (!IsEnabled())
+              crStroke = PWL_DEFAULT_HEAVYGRAYCOLOR.ToFXColor(255);
+
+            float nFrictionWidth = 5.0f;
+            float nFrictionHeight = 5.5f;
+
+            CFX_PointF ptLeft =
+                CFX_PointF(ptCenter.x - nFrictionWidth / 2.0f,
+                           ptCenter.y - nFrictionHeight / 2.0f + 0.5f);
+            CFX_PointF ptRight =
+                CFX_PointF(ptCenter.x + nFrictionWidth / 2.0f,
+                           ptCenter.y - nFrictionHeight / 2.0f + 0.5f);
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptLeft, ptRight,
+                                       crStroke, 1.0f);
+
+            ptLeft.y += 2.0f;
+            ptRight.y += 2.0f;
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptLeft, ptRight,
+                                       crStroke, 1.0f);
+
+            ptLeft.y += 2.0f;
+            ptRight.y += 2.0f;
+
+            CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptLeft, ptRight,
+                                       crStroke, 1.0f);
+          }
+        } break;
+        default:
+          break;
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+bool CPWL_SBButton::OnLButtonDown(const CFX_PointF& point, uint32_t nFlag) {
+  CPWL_Wnd::OnLButtonDown(point, nFlag);
+
+  if (CPWL_Wnd* pParent = GetParentWindow())
+    pParent->OnNotify(this, PNM_LBUTTONDOWN, 0, (intptr_t)&point);
+
+  m_bMouseDown = true;
+  SetCapture();
+
+  return true;
+}
+
+bool CPWL_SBButton::OnLButtonUp(const CFX_PointF& point, uint32_t nFlag) {
+  CPWL_Wnd::OnLButtonUp(point, nFlag);
+
+  if (CPWL_Wnd* pParent = GetParentWindow())
+    pParent->OnNotify(this, PNM_LBUTTONUP, 0, (intptr_t)&point);
+
+  m_bMouseDown = false;
+  ReleaseCapture();
+
+  return true;
+}
+
+bool CPWL_SBButton::OnMouseMove(const CFX_PointF& point, uint32_t nFlag) {
+  CPWL_Wnd::OnMouseMove(point, nFlag);
+
+  if (CPWL_Wnd* pParent = GetParentWindow()) {
+    pParent->OnNotify(this, PNM_MOUSEMOVE, 0, (intptr_t)&point);
+  }
+
+  return true;
+}
+
+CPWL_ScrollBar::CPWL_ScrollBar(PWL_SCROLLBAR_TYPE sbType)
+    : m_sbType(sbType),
+      m_pMinButton(nullptr),
+      m_pMaxButton(nullptr),
+      m_pPosButton(nullptr),
+      m_bMouseDown(false),
+      m_bMinOrMax(false),
+      m_bNotifyForever(true) {}
+
+CPWL_ScrollBar::~CPWL_ScrollBar() {}
+
+CFX_ByteString CPWL_ScrollBar::GetClassName() const {
+  return "CPWL_ScrollBar";
+}
+
+void CPWL_ScrollBar::OnCreate(PWL_CREATEPARAM& cp) {
+  cp.eCursorType = FXCT_ARROW;
+}
+
+void CPWL_ScrollBar::OnDestroy() {
+  // Until cleanup takes place in the virtual destructor for CPWL_Wnd
+  // subclasses, implement the virtual OnDestroy method that does the
+  // cleanup first, then invokes the superclass OnDestroy ... gee,
+  // like a dtor would.
+  m_pMinButton.Release();
+  m_pMaxButton.Release();
+  m_pPosButton.Release();
+  CPWL_Wnd::OnDestroy();
+}
+
+void CPWL_ScrollBar::RePosChildWnd() {
+  CFX_FloatRect rcClient = GetClientRect();
+  CFX_FloatRect rcMinButton, rcMaxButton;
+  float fBWidth = 0;
+
+  switch (m_sbType) {
+    case SBT_HSCROLL:
+      if (rcClient.right - rcClient.left >
+          PWL_SCROLLBAR_BUTTON_WIDTH * 2 + PWL_SCROLLBAR_POSBUTTON_MINWIDTH +
+              2) {
+        rcMinButton = CFX_FloatRect(rcClient.left, rcClient.bottom,
+                                    rcClient.left + PWL_SCROLLBAR_BUTTON_WIDTH,
+                                    rcClient.top);
+        rcMaxButton =
+            CFX_FloatRect(rcClient.right - PWL_SCROLLBAR_BUTTON_WIDTH,
+                          rcClient.bottom, rcClient.right, rcClient.top);
+      } else {
+        fBWidth = (rcClient.right - rcClient.left -
+                   PWL_SCROLLBAR_POSBUTTON_MINWIDTH - 2) /
+                  2;
+
+        if (fBWidth > 0) {
+          rcMinButton = CFX_FloatRect(rcClient.left, rcClient.bottom,
+                                      rcClient.left + fBWidth, rcClient.top);
+          rcMaxButton = CFX_FloatRect(rcClient.right - fBWidth, rcClient.bottom,
+                                      rcClient.right, rcClient.top);
+        } else {
+          SetVisible(false);
+        }
+      }
+      break;
+    case SBT_VSCROLL:
+      if (IsFloatBigger(rcClient.top - rcClient.bottom,
+                        PWL_SCROLLBAR_BUTTON_WIDTH * 2 +
+                            PWL_SCROLLBAR_POSBUTTON_MINWIDTH + 2)) {
+        rcMinButton = CFX_FloatRect(rcClient.left,
+                                    rcClient.top - PWL_SCROLLBAR_BUTTON_WIDTH,
+                                    rcClient.right, rcClient.top);
+        rcMaxButton =
+            CFX_FloatRect(rcClient.left, rcClient.bottom, rcClient.right,
+                          rcClient.bottom + PWL_SCROLLBAR_BUTTON_WIDTH);
+      } else {
+        fBWidth = (rcClient.top - rcClient.bottom -
+                   PWL_SCROLLBAR_POSBUTTON_MINWIDTH - 2) /
+                  2;
+
+        if (IsFloatBigger(fBWidth, 0)) {
+          rcMinButton = CFX_FloatRect(rcClient.left, rcClient.top - fBWidth,
+                                      rcClient.right, rcClient.top);
+          rcMaxButton =
+              CFX_FloatRect(rcClient.left, rcClient.bottom, rcClient.right,
+                            rcClient.bottom + fBWidth);
+        } else {
+          SetVisible(false);
+        }
+      }
+      break;
+  }
+
+  if (m_pMinButton)
+    m_pMinButton->Move(rcMinButton, true, false);
+  if (m_pMaxButton)
+    m_pMaxButton->Move(rcMaxButton, true, false);
+  MovePosButton(false);
+}
+
+void CPWL_ScrollBar::GetThisAppearanceStream(CFX_ByteTextBuf& sAppStream) {
+  CFX_FloatRect rectWnd = GetWindowRect();
+
+  if (IsVisible() && !rectWnd.IsEmpty()) {
+    CFX_ByteTextBuf sButton;
+
+    sButton << "q\n";
+    sButton << "0 w\n"
+            << CPWL_Utils::GetColorAppStream(GetBackgroundColor(), true)
+                   .AsStringC();
+    sButton << rectWnd.left << " " << rectWnd.bottom << " "
+            << rectWnd.right - rectWnd.left << " "
+            << rectWnd.top - rectWnd.bottom << " re b Q\n";
+
+    sAppStream << sButton;
+  }
+}
+
+void CPWL_ScrollBar::DrawThisAppearance(CFX_RenderDevice* pDevice,
+                                        CFX_Matrix* pUser2Device) {
+  CFX_FloatRect rectWnd = GetWindowRect();
+
+  if (IsVisible() && !rectWnd.IsEmpty()) {
+    CPWL_Utils::DrawFillRect(pDevice, pUser2Device, rectWnd,
+                             GetBackgroundColor(), GetTransparency());
+
+    CPWL_Utils::DrawStrokeLine(
+        pDevice, pUser2Device,
+        CFX_PointF(rectWnd.left + 2.0f, rectWnd.top - 2.0f),
+        CFX_PointF(rectWnd.left + 2.0f, rectWnd.bottom + 2.0f),
+        ArgbEncode(GetTransparency(), 100, 100, 100), 1.0f);
+
+    CPWL_Utils::DrawStrokeLine(
+        pDevice, pUser2Device,
+        CFX_PointF(rectWnd.right - 2.0f, rectWnd.top - 2.0f),
+        CFX_PointF(rectWnd.right - 2.0f, rectWnd.bottom + 2.0f),
+        ArgbEncode(GetTransparency(), 100, 100, 100), 1.0f);
+  }
+}
+
+bool CPWL_ScrollBar::OnLButtonDown(const CFX_PointF& point, uint32_t nFlag) {
+  CPWL_Wnd::OnLButtonDown(point, nFlag);
+
+  if (HasFlag(PWS_AUTOTRANSPARENT)) {
+    if (GetTransparency() != 255) {
+      SetTransparency(255);
+      InvalidateRect();
+    }
+  }
+
+  CFX_FloatRect rcMinArea, rcMaxArea;
+
+  if (m_pPosButton && m_pPosButton->IsVisible()) {
+    CFX_FloatRect rcClient = GetClientRect();
+    CFX_FloatRect rcPosButton = m_pPosButton->GetWindowRect();
+
+    switch (m_sbType) {
+      case SBT_HSCROLL:
+        rcMinArea =
+            CFX_FloatRect(rcClient.left + PWL_SCROLLBAR_BUTTON_WIDTH,
+                          rcClient.bottom, rcPosButton.left, rcClient.top);
+        rcMaxArea = CFX_FloatRect(rcPosButton.right, rcClient.bottom,
+                                  rcClient.right - PWL_SCROLLBAR_BUTTON_WIDTH,
+                                  rcClient.top);
+
+        break;
+      case SBT_VSCROLL:
+        rcMinArea =
+            CFX_FloatRect(rcClient.left, rcPosButton.top, rcClient.right,
+                          rcClient.top - PWL_SCROLLBAR_BUTTON_WIDTH);
+        rcMaxArea = CFX_FloatRect(rcClient.left,
+                                  rcClient.bottom + PWL_SCROLLBAR_BUTTON_WIDTH,
+                                  rcClient.right, rcPosButton.bottom);
+        break;
+    }
+
+    rcMinArea.Normalize();
+    rcMaxArea.Normalize();
+
+    if (rcMinArea.Contains(point)) {
+      m_sData.SubBig();
+      MovePosButton(true);
+      NotifyScrollWindow();
+    }
+
+    if (rcMaxArea.Contains(point)) {
+      m_sData.AddBig();
+      MovePosButton(true);
+      NotifyScrollWindow();
+    }
+  }
+
+  return true;
+}
+
+bool CPWL_ScrollBar::OnLButtonUp(const CFX_PointF& point, uint32_t nFlag) {
+  CPWL_Wnd::OnLButtonUp(point, nFlag);
+
+  if (HasFlag(PWS_AUTOTRANSPARENT)) {
+    if (GetTransparency() != PWL_SCROLLBAR_TRANSPARENCY) {
+      SetTransparency(PWL_SCROLLBAR_TRANSPARENCY);
+      InvalidateRect();
+    }
+  }
+
+  EndTimer();
+  m_bMouseDown = false;
+
+  return true;
+}
+
+void CPWL_ScrollBar::OnNotify(CPWL_Wnd* pWnd,
+                              uint32_t msg,
+                              intptr_t wParam,
+                              intptr_t lParam) {
+  CPWL_Wnd::OnNotify(pWnd, msg, wParam, lParam);
+
+  switch (msg) {
+    case PNM_LBUTTONDOWN:
+      if (pWnd == m_pMinButton) {
+        OnMinButtonLBDown(*(CFX_PointF*)lParam);
+      }
+
+      if (pWnd == m_pMaxButton) {
+        OnMaxButtonLBDown(*(CFX_PointF*)lParam);
+      }
+
+      if (pWnd == m_pPosButton) {
+        OnPosButtonLBDown(*(CFX_PointF*)lParam);
+      }
+      break;
+    case PNM_LBUTTONUP:
+      if (pWnd == m_pMinButton) {
+        OnMinButtonLBUp(*(CFX_PointF*)lParam);
+      }
+
+      if (pWnd == m_pMaxButton) {
+        OnMaxButtonLBUp(*(CFX_PointF*)lParam);
+      }
+
+      if (pWnd == m_pPosButton) {
+        OnPosButtonLBUp(*(CFX_PointF*)lParam);
+      }
+      break;
+    case PNM_MOUSEMOVE:
+      if (pWnd == m_pMinButton) {
+        OnMinButtonMouseMove(*(CFX_PointF*)lParam);
+      }
+
+      if (pWnd == m_pMaxButton) {
+        OnMaxButtonMouseMove(*(CFX_PointF*)lParam);
+      }
+
+      if (pWnd == m_pPosButton) {
+        OnPosButtonMouseMove(*(CFX_PointF*)lParam);
+      }
+      break;
+    case PNM_SETSCROLLINFO: {
+      PWL_SCROLL_INFO* pInfo = reinterpret_cast<PWL_SCROLL_INFO*>(lParam);
+      if (pInfo && *pInfo != m_OriginInfo) {
+        m_OriginInfo = *pInfo;
+        float fMax =
+            pInfo->fContentMax - pInfo->fContentMin - pInfo->fPlateWidth;
+        fMax = fMax > 0.0f ? fMax : 0.0f;
+        SetScrollRange(0, fMax, pInfo->fPlateWidth);
+        SetScrollStep(pInfo->fBigStep, pInfo->fSmallStep);
+      }
+    } break;
+    case PNM_SETSCROLLPOS: {
+      float fPos = *(float*)lParam;
+      switch (m_sbType) {
+        case SBT_HSCROLL:
+          fPos = fPos - m_OriginInfo.fContentMin;
+          break;
+        case SBT_VSCROLL:
+          fPos = m_OriginInfo.fContentMax - fPos;
+          break;
+      }
+      SetScrollPos(fPos);
+    } break;
+  }
+}
+
+void CPWL_ScrollBar::CreateButtons(const PWL_CREATEPARAM& cp) {
+  PWL_CREATEPARAM scp = cp;
+  scp.pParentWnd = this;
+  scp.dwBorderWidth = 2;
+  scp.nBorderStyle = BorderStyle::BEVELED;
+
+  scp.dwFlags =
+      PWS_VISIBLE | PWS_CHILD | PWS_BORDER | PWS_BACKGROUND | PWS_NOREFRESHCLIP;
+
+  if (!m_pMinButton) {
+    m_pMinButton = new CPWL_SBButton(m_sbType, PSBT_MIN);
+    m_pMinButton->Create(scp);
+  }
+
+  if (!m_pMaxButton) {
+    m_pMaxButton = new CPWL_SBButton(m_sbType, PSBT_MAX);
+    m_pMaxButton->Create(scp);
+  }
+
+  if (!m_pPosButton) {
+    m_pPosButton = new CPWL_SBButton(m_sbType, PSBT_POS);
+    m_pPosButton->SetVisible(false);
+    m_pPosButton->Create(scp);
+  }
+}
+
+float CPWL_ScrollBar::GetScrollBarWidth() const {
+  if (!IsVisible())
+    return 0;
+
+  return PWL_SCROLLBAR_WIDTH;
+}
+
+void CPWL_ScrollBar::SetScrollRange(float fMin,
+                                    float fMax,
+                                    float fClientWidth) {
+  if (m_pPosButton) {
+    m_sData.SetScrollRange(fMin, fMax);
+    m_sData.SetClientWidth(fClientWidth);
+
+    if (IsFloatSmaller(m_sData.ScrollRange.GetWidth(), 0.0f)) {
+      m_pPosButton->SetVisible(false);
+    } else {
+      m_pPosButton->SetVisible(true);
+      MovePosButton(true);
+    }
+  }
+}
+
+void CPWL_ScrollBar::SetScrollPos(float fPos) {
+  float fOldPos = m_sData.fScrollPos;
+
+  m_sData.SetPos(fPos);
+
+  if (!IsFloatEqual(m_sData.fScrollPos, fOldPos))
+    MovePosButton(true);
+}
+
+void CPWL_ScrollBar::SetScrollStep(float fBigStep, float fSmallStep) {
+  m_sData.SetBigStep(fBigStep);
+  m_sData.SetSmallStep(fSmallStep);
+}
+
+void CPWL_ScrollBar::MovePosButton(bool bRefresh) {
+  ASSERT(m_pMinButton);
+  ASSERT(m_pMaxButton);
+
+  if (m_pPosButton->IsVisible()) {
+    CFX_FloatRect rcClient;
+    CFX_FloatRect rcPosArea, rcPosButton;
+
+    rcClient = GetClientRect();
+    rcPosArea = GetScrollArea();
+
+    float fLeft, fRight, fTop, fBottom;
+
+    switch (m_sbType) {
+      case SBT_HSCROLL:
+        fLeft = TrueToFace(m_sData.fScrollPos);
+        fRight = TrueToFace(m_sData.fScrollPos + m_sData.fClientWidth);
+
+        if (fRight - fLeft < PWL_SCROLLBAR_POSBUTTON_MINWIDTH)
+          fRight = fLeft + PWL_SCROLLBAR_POSBUTTON_MINWIDTH;
+
+        if (fRight > rcPosArea.right) {
+          fRight = rcPosArea.right;
+          fLeft = fRight - PWL_SCROLLBAR_POSBUTTON_MINWIDTH;
+        }
+
+        rcPosButton =
+            CFX_FloatRect(fLeft, rcPosArea.bottom, fRight, rcPosArea.top);
+
+        break;
+      case SBT_VSCROLL:
+        fBottom = TrueToFace(m_sData.fScrollPos + m_sData.fClientWidth);
+        fTop = TrueToFace(m_sData.fScrollPos);
+
+        if (IsFloatSmaller(fTop - fBottom, PWL_SCROLLBAR_POSBUTTON_MINWIDTH))
+          fBottom = fTop - PWL_SCROLLBAR_POSBUTTON_MINWIDTH;
+
+        if (IsFloatSmaller(fBottom, rcPosArea.bottom)) {
+          fBottom = rcPosArea.bottom;
+          fTop = fBottom + PWL_SCROLLBAR_POSBUTTON_MINWIDTH;
+        }
+
+        rcPosButton =
+            CFX_FloatRect(rcPosArea.left, fBottom, rcPosArea.right, fTop);
+
+        break;
+    }
+
+    m_pPosButton->Move(rcPosButton, true, bRefresh);
+  }
+}
+
+void CPWL_ScrollBar::OnMinButtonLBDown(const CFX_PointF& point) {
+  m_sData.SubSmall();
+  MovePosButton(true);
+  NotifyScrollWindow();
+
+  m_bMinOrMax = true;
+
+  EndTimer();
+  BeginTimer(100);
+}
+
+void CPWL_ScrollBar::OnMinButtonLBUp(const CFX_PointF& point) {}
+
+void CPWL_ScrollBar::OnMinButtonMouseMove(const CFX_PointF& point) {}
+
+void CPWL_ScrollBar::OnMaxButtonLBDown(const CFX_PointF& point) {
+  m_sData.AddSmall();
+  MovePosButton(true);
+  NotifyScrollWindow();
+
+  m_bMinOrMax = false;
+
+  EndTimer();
+  BeginTimer(100);
+}
+
+void CPWL_ScrollBar::OnMaxButtonLBUp(const CFX_PointF& point) {}
+
+void CPWL_ScrollBar::OnMaxButtonMouseMove(const CFX_PointF& point) {}
+
+void CPWL_ScrollBar::OnPosButtonLBDown(const CFX_PointF& point) {
+  m_bMouseDown = true;
+
+  if (m_pPosButton) {
+    CFX_FloatRect rcPosButton = m_pPosButton->GetWindowRect();
+
+    switch (m_sbType) {
+      case SBT_HSCROLL:
+        m_nOldPos = point.x;
+        m_fOldPosButton = rcPosButton.left;
+        break;
+      case SBT_VSCROLL:
+        m_nOldPos = point.y;
+        m_fOldPosButton = rcPosButton.top;
+        break;
+    }
+  }
+}
+
+void CPWL_ScrollBar::OnPosButtonLBUp(const CFX_PointF& point) {
+  if (m_bMouseDown) {
+    if (!m_bNotifyForever)
+      NotifyScrollWindow();
+  }
+  m_bMouseDown = false;
+}
+
+void CPWL_ScrollBar::OnPosButtonMouseMove(const CFX_PointF& point) {
+  float fOldScrollPos = m_sData.fScrollPos;
+
+  float fNewPos = 0;
+
+  switch (m_sbType) {
+    case SBT_HSCROLL:
+      if (fabs(point.x - m_nOldPos) < 1)
+        return;
+      fNewPos = FaceToTrue(m_fOldPosButton + point.x - m_nOldPos);
+      break;
+    case SBT_VSCROLL:
+      if (fabs(point.y - m_nOldPos) < 1)
+        return;
+      fNewPos = FaceToTrue(m_fOldPosButton + point.y - m_nOldPos);
+      break;
+  }
+
+  if (m_bMouseDown) {
+    switch (m_sbType) {
+      case SBT_HSCROLL:
+
+        if (IsFloatSmaller(fNewPos, m_sData.ScrollRange.fMin)) {
+          fNewPos = m_sData.ScrollRange.fMin;
+        }
+
+        if (IsFloatBigger(fNewPos, m_sData.ScrollRange.fMax)) {
+          fNewPos = m_sData.ScrollRange.fMax;
+        }
+
+        m_sData.SetPos(fNewPos);
+
+        break;
+      case SBT_VSCROLL:
+
+        if (IsFloatSmaller(fNewPos, m_sData.ScrollRange.fMin)) {
+          fNewPos = m_sData.ScrollRange.fMin;
+        }
+
+        if (IsFloatBigger(fNewPos, m_sData.ScrollRange.fMax)) {
+          fNewPos = m_sData.ScrollRange.fMax;
+        }
+
+        m_sData.SetPos(fNewPos);
+
+        break;
+    }
+
+    if (!IsFloatEqual(fOldScrollPos, m_sData.fScrollPos)) {
+      MovePosButton(true);
+
+      if (m_bNotifyForever)
+        NotifyScrollWindow();
+    }
+  }
+}
+
+void CPWL_ScrollBar::NotifyScrollWindow() {
+  if (CPWL_Wnd* pParent = GetParentWindow()) {
+    float fPos;
+    switch (m_sbType) {
+      case SBT_HSCROLL:
+        fPos = m_OriginInfo.fContentMin + m_sData.fScrollPos;
+        break;
+      case SBT_VSCROLL:
+        fPos = m_OriginInfo.fContentMax - m_sData.fScrollPos;
+        break;
+    }
+    pParent->OnNotify(this, PNM_SCROLLWINDOW, (intptr_t)m_sbType,
+                      (intptr_t)&fPos);
+  }
+}
+
+CFX_FloatRect CPWL_ScrollBar::GetScrollArea() const {
+  CFX_FloatRect rcClient = GetClientRect();
+  CFX_FloatRect rcArea;
+
+  if (!m_pMinButton || !m_pMaxButton)
+    return rcClient;
+
+  CFX_FloatRect rcMin = m_pMinButton->GetWindowRect();
+  CFX_FloatRect rcMax = m_pMaxButton->GetWindowRect();
+
+  float fMinWidth = rcMin.right - rcMin.left;
+  float fMinHeight = rcMin.top - rcMin.bottom;
+  float fMaxWidth = rcMax.right - rcMax.left;
+  float fMaxHeight = rcMax.top - rcMax.bottom;
+
+  switch (m_sbType) {
+    case SBT_HSCROLL:
+      if (rcClient.right - rcClient.left > fMinWidth + fMaxWidth + 2) {
+        rcArea = CFX_FloatRect(rcClient.left + fMinWidth + 1, rcClient.bottom,
+                               rcClient.right - fMaxWidth - 1, rcClient.top);
+      } else {
+        rcArea = CFX_FloatRect(rcClient.left + fMinWidth + 1, rcClient.bottom,
+                               rcClient.left + fMinWidth + 1, rcClient.top);
+      }
+      break;
+    case SBT_VSCROLL:
+      if (rcClient.top - rcClient.bottom > fMinHeight + fMaxHeight + 2) {
+        rcArea = CFX_FloatRect(rcClient.left, rcClient.bottom + fMinHeight + 1,
+                               rcClient.right, rcClient.top - fMaxHeight - 1);
+      } else {
+        rcArea =
+            CFX_FloatRect(rcClient.left, rcClient.bottom + fMinHeight + 1,
+                          rcClient.right, rcClient.bottom + fMinHeight + 1);
+      }
+      break;
+  }
+
+  rcArea.Normalize();
+
+  return rcArea;
+}
+
+float CPWL_ScrollBar::TrueToFace(float fTrue) {
+  CFX_FloatRect rcPosArea;
+  rcPosArea = GetScrollArea();
+
+  float fFactWidth = m_sData.ScrollRange.GetWidth() + m_sData.fClientWidth;
+  fFactWidth = fFactWidth == 0 ? 1 : fFactWidth;
+
+  float fFace = 0;
+
+  switch (m_sbType) {
+    case SBT_HSCROLL:
+      fFace = rcPosArea.left +
+              fTrue * (rcPosArea.right - rcPosArea.left) / fFactWidth;
+      break;
+    case SBT_VSCROLL:
+      fFace = rcPosArea.top -
+              fTrue * (rcPosArea.top - rcPosArea.bottom) / fFactWidth;
+      break;
+  }
+
+  return fFace;
+}
+
+float CPWL_ScrollBar::FaceToTrue(float fFace) {
+  CFX_FloatRect rcPosArea;
+  rcPosArea = GetScrollArea();
+
+  float fFactWidth = m_sData.ScrollRange.GetWidth() + m_sData.fClientWidth;
+  fFactWidth = fFactWidth == 0 ? 1 : fFactWidth;
+
+  float fTrue = 0;
+
+  switch (m_sbType) {
+    case SBT_HSCROLL:
+      fTrue = (fFace - rcPosArea.left) * fFactWidth /
+              (rcPosArea.right - rcPosArea.left);
+      break;
+    case SBT_VSCROLL:
+      fTrue = (rcPosArea.top - fFace) * fFactWidth /
+              (rcPosArea.top - rcPosArea.bottom);
+      break;
+  }
+
+  return fTrue;
+}
+
+void CPWL_ScrollBar::CreateChildWnd(const PWL_CREATEPARAM& cp) {
+  CreateButtons(cp);
+}
+
+void CPWL_ScrollBar::TimerProc() {
+  PWL_SCROLL_PRIVATEDATA sTemp = m_sData;
+  if (m_bMinOrMax)
+    m_sData.SubSmall();
+  else
+    m_sData.AddSmall();
+
+  if (sTemp != m_sData) {
+    MovePosButton(true);
+    NotifyScrollWindow();
+  }
+}