blob: 4bf4b366dc5cea75d8a3353570647ef4ab3325d4 [file] [log] [blame]
// Copyright 2014 The PDFium Authors
// 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/cfwl_scrollbar.h"
#include <algorithm>
#include <memory>
#include <utility>
#include "xfa/fwl/cfwl_app.h"
#include "xfa/fwl/cfwl_messagemouse.h"
#include "xfa/fwl/cfwl_messagemousewheel.h"
#include "xfa/fwl/cfwl_notedriver.h"
#include "xfa/fwl/cfwl_themebackground.h"
#include "xfa/fwl/cfwl_themepart.h"
#include "xfa/fwl/ifwl_themeprovider.h"
namespace {
constexpr int kScrollbarElapsedMsecs = 500;
constexpr float kMinThumbSize = 5.0f;
} // namespace
CFWL_ScrollBar::CFWL_ScrollBar(CFWL_App* app,
const Properties& properties,
CFWL_Widget* pOuter)
: CFWL_Widget(app, properties, pOuter) {}
CFWL_ScrollBar::~CFWL_ScrollBar() = default;
FWL_Type CFWL_ScrollBar::GetClassID() const {
return FWL_Type::ScrollBar;
}
void CFWL_ScrollBar::Update() {
if (IsLocked())
return;
Layout();
}
void CFWL_ScrollBar::DrawWidget(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix& matrix) {
if (!pGraphics)
return;
if (HasBorder())
DrawBorder(pGraphics, CFWL_ThemePart::Part::kBorder, matrix);
DrawLowerTrack(pGraphics, matrix);
DrawUpperTrack(pGraphics, matrix);
DrawMinArrowBtn(pGraphics, matrix);
DrawMaxArrowBtn(pGraphics, matrix);
DrawThumb(pGraphics, matrix);
}
void CFWL_ScrollBar::SetTrackPos(float fTrackPos) {
m_fTrackPos = fTrackPos;
m_ThumbRect = CalcThumbButtonRect(m_ThumbRect);
m_MinTrackRect = CalcMinTrackRect(m_MinTrackRect);
m_MaxTrackRect = CalcMaxTrackRect(m_MaxTrackRect);
}
bool CFWL_ScrollBar::DoScroll(CFWL_EventScroll::Code dwCode, float fPos) {
if (dwCode == CFWL_EventScroll::Code::None)
return false;
return OnScroll(dwCode, fPos);
}
void CFWL_ScrollBar::DrawUpperTrack(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix& mtMatrix) {
CFWL_ThemeBackground param(CFWL_ThemePart::Part::kUpperTrack, this,
pGraphics);
param.m_dwStates = (m_Properties.m_dwStates & FWL_STATE_WGT_Disabled)
? CFWL_PartState::kDisabled
: m_iMaxTrackState;
param.m_matrix = mtMatrix;
param.m_PartRect = m_MaxTrackRect;
GetThemeProvider()->DrawBackground(param);
}
void CFWL_ScrollBar::DrawLowerTrack(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix& mtMatrix) {
CFWL_ThemeBackground param(CFWL_ThemePart::Part::kLowerTrack, this,
pGraphics);
param.m_dwStates = (m_Properties.m_dwStates & FWL_STATE_WGT_Disabled)
? CFWL_PartState::kDisabled
: m_iMinTrackState;
param.m_matrix = mtMatrix;
param.m_PartRect = m_MinTrackRect;
GetThemeProvider()->DrawBackground(param);
}
void CFWL_ScrollBar::DrawMaxArrowBtn(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix& mtMatrix) {
CFWL_ThemeBackground param(CFWL_ThemePart::Part::kBackArrow, this, pGraphics);
param.m_dwStates = (m_Properties.m_dwStates & FWL_STATE_WGT_Disabled)
? CFWL_PartState::kDisabled
: m_iMaxButtonState;
param.m_matrix = mtMatrix;
param.m_PartRect = m_MaxBtnRect;
if (param.m_PartRect.height > 0 && param.m_PartRect.width > 0)
GetThemeProvider()->DrawBackground(param);
}
void CFWL_ScrollBar::DrawMinArrowBtn(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix& mtMatrix) {
CFWL_ThemeBackground param(CFWL_ThemePart::Part::kForeArrow, this, pGraphics);
param.m_dwStates = (m_Properties.m_dwStates & FWL_STATE_WGT_Disabled)
? CFWL_PartState::kDisabled
: m_iMinButtonState;
param.m_matrix = mtMatrix;
param.m_PartRect = m_MinBtnRect;
if (param.m_PartRect.height > 0 && param.m_PartRect.width > 0)
GetThemeProvider()->DrawBackground(param);
}
void CFWL_ScrollBar::DrawThumb(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix& mtMatrix) {
CFWL_ThemeBackground param(CFWL_ThemePart::Part::kThumb, this, pGraphics);
param.m_dwStates = (m_Properties.m_dwStates & FWL_STATE_WGT_Disabled)
? CFWL_PartState::kDisabled
: m_iThumbButtonState;
param.m_matrix = mtMatrix;
param.m_PartRect = m_ThumbRect;
GetThemeProvider()->DrawBackground(param);
}
void CFWL_ScrollBar::Layout() {
m_ClientRect = GetClientRect();
CalcButtonLen();
m_MinBtnRect = CalcMinButtonRect();
m_MaxBtnRect = CalcMaxButtonRect();
m_ThumbRect = CalcThumbButtonRect(m_ThumbRect);
m_MinTrackRect = CalcMinTrackRect(m_MinTrackRect);
m_MaxTrackRect = CalcMaxTrackRect(m_MaxTrackRect);
}
void CFWL_ScrollBar::CalcButtonLen() {
m_fButtonLen = IsVertical() ? m_ClientRect.width : m_ClientRect.height;
float fLength = IsVertical() ? m_ClientRect.height : m_ClientRect.width;
if (fLength < m_fButtonLen * 2) {
m_fButtonLen = fLength / 2;
m_bMinSize = true;
} else {
m_bMinSize = false;
}
}
CFX_RectF CFWL_ScrollBar::CalcMinButtonRect() {
if (IsVertical())
return CFX_RectF(m_ClientRect.TopLeft(), m_ClientRect.width, m_fButtonLen);
return CFX_RectF(m_ClientRect.TopLeft(), m_fButtonLen, m_ClientRect.height);
}
CFX_RectF CFWL_ScrollBar::CalcMaxButtonRect() {
if (IsVertical()) {
return CFX_RectF(m_ClientRect.left, m_ClientRect.bottom() - m_fButtonLen,
m_ClientRect.width, m_fButtonLen);
}
return CFX_RectF(m_ClientRect.right() - m_fButtonLen, m_ClientRect.top,
m_fButtonLen, m_ClientRect.height);
}
CFX_RectF CFWL_ScrollBar::CalcThumbButtonRect(const CFX_RectF& rtThumb) {
CFX_RectF rect;
if (!IsEnabled())
return rect;
if (m_bMinSize) {
rect.left = rtThumb.left;
rect.top = rtThumb.top;
return rect;
}
float fRange = m_fRangeMax - m_fRangeMin;
if (fRange < 0) {
if (IsVertical()) {
return CFX_RectF(m_ClientRect.left, m_MaxBtnRect.bottom(),
m_ClientRect.width, 0);
}
return CFX_RectF(m_MaxBtnRect.right(), m_ClientRect.top, 0,
m_ClientRect.height);
}
CFX_RectF rtClient = m_ClientRect;
float fLength = IsVertical() ? rtClient.height : rtClient.width;
float fSize = m_fButtonLen;
fLength -= fSize * 2.0f;
if (fLength < fSize)
fLength = 0.0f;
float fThumbSize = fLength * fLength / (fRange + fLength);
fThumbSize = std::max(fThumbSize, kMinThumbSize);
float fDiff = std::max(fLength - fThumbSize, 0.0f);
float fTrackPos = std::clamp(m_fTrackPos, m_fRangeMin, m_fRangeMax);
if (!fRange)
return rect;
float iPos = fSize + fDiff * (fTrackPos - m_fRangeMin) / fRange;
rect.left = rtClient.left;
rect.top = rtClient.top;
if (IsVertical()) {
rect.top += iPos;
rect.width = rtClient.width;
rect.height = fThumbSize;
} else {
rect.left += iPos;
rect.width = fThumbSize;
rect.height = rtClient.height;
}
return rect;
}
CFX_RectF CFWL_ScrollBar::CalcMinTrackRect(const CFX_RectF& rtMinRect) {
CFX_RectF rect;
if (m_bMinSize) {
rect.left = rtMinRect.left;
rect.top = rtMinRect.top;
return rect;
}
rect.left = m_ClientRect.left;
rect.top = m_ClientRect.top;
if (IsVertical()) {
rect.width = m_ClientRect.width;
rect.height = (m_ThumbRect.top + m_ThumbRect.bottom()) / 2;
} else {
rect.width = (m_ThumbRect.left + m_ThumbRect.right()) / 2;
rect.height = m_ClientRect.height;
}
return rect;
}
CFX_RectF CFWL_ScrollBar::CalcMaxTrackRect(const CFX_RectF& rtMaxRect) {
if (m_bMinSize)
return CFX_RectF(rtMaxRect.TopLeft(), 0, 0);
if (IsVertical()) {
float iy = (m_ThumbRect.top + m_ThumbRect.bottom()) / 2;
return CFX_RectF(m_ClientRect.left, iy, m_ClientRect.width,
m_ClientRect.bottom() - iy);
}
float ix = (m_ThumbRect.left + m_ThumbRect.right()) / 2;
return CFX_RectF(ix, m_ClientRect.top, m_ClientRect.height - ix,
m_ClientRect.height);
}
float CFWL_ScrollBar::GetTrackPointPos(const CFX_PointF& point) {
CFX_PointF diff = point - m_cpTrackPoint;
float fRange = m_fRangeMax - m_fRangeMin;
float fPos;
if (IsVertical()) {
fPos = fRange * diff.y /
(m_MaxBtnRect.top - m_MinBtnRect.bottom() - m_ThumbRect.height);
} else {
fPos = fRange * diff.x /
(m_MaxBtnRect.left - m_MinBtnRect.right() - m_ThumbRect.width);
}
fPos += m_fLastTrackPos;
return std::clamp(fPos, m_fRangeMin, m_fRangeMax);
}
bool CFWL_ScrollBar::SendEvent() {
if (m_iMinButtonState == CFWL_PartState::kPressed) {
DoScroll(CFWL_EventScroll::Code::StepBackward, m_fTrackPos);
return false;
}
if (m_iMaxButtonState == CFWL_PartState::kPressed) {
DoScroll(CFWL_EventScroll::Code::StepForward, m_fTrackPos);
return false;
}
if (m_iMinTrackState == CFWL_PartState::kPressed) {
DoScroll(CFWL_EventScroll::Code::PageBackward, m_fTrackPos);
return m_ThumbRect.Contains(m_cpTrackPoint);
}
if (m_iMaxTrackState == CFWL_PartState::kPressed) {
DoScroll(CFWL_EventScroll::Code::PageForward, m_fTrackPos);
return m_ThumbRect.Contains(m_cpTrackPoint);
}
if (m_iMouseWheel) {
CFWL_EventScroll::Code dwCode = m_iMouseWheel < 0
? CFWL_EventScroll::Code::StepForward
: CFWL_EventScroll::Code::StepBackward;
DoScroll(dwCode, m_fTrackPos);
}
return true;
}
bool CFWL_ScrollBar::OnScroll(CFWL_EventScroll::Code dwCode, float fPos) {
CFWL_EventScroll ev(this, dwCode, fPos);
DispatchEvent(&ev);
return true;
}
void CFWL_ScrollBar::OnProcessMessage(CFWL_Message* pMessage) {
CFWL_Message::Type type = pMessage->GetType();
if (type == CFWL_Message::Type::kMouse) {
CFWL_MessageMouse* pMsg = static_cast<CFWL_MessageMouse*>(pMessage);
switch (pMsg->m_dwCmd) {
case CFWL_MessageMouse::MouseCommand::kLeftButtonDown:
OnLButtonDown(pMsg->m_pos);
break;
case CFWL_MessageMouse::MouseCommand::kLeftButtonUp:
OnLButtonUp(pMsg->m_pos);
break;
case CFWL_MessageMouse::MouseCommand::kMove:
OnMouseMove(pMsg->m_pos);
break;
case CFWL_MessageMouse::MouseCommand::kLeave:
OnMouseLeave();
break;
default:
break;
}
} else if (type == CFWL_Message::Type::kMouseWheel) {
auto* pMsg = static_cast<CFWL_MessageMouseWheel*>(pMessage);
OnMouseWheel(pMsg->delta());
}
}
void CFWL_ScrollBar::OnDrawWidget(CFGAS_GEGraphics* pGraphics,
const CFX_Matrix& matrix) {
DrawWidget(pGraphics, matrix);
}
void CFWL_ScrollBar::OnLButtonDown(const CFX_PointF& point) {
if (!IsEnabled())
return;
m_bMouseDown = true;
SetGrab(true);
m_cpTrackPoint = point;
m_fLastTrackPos = m_fTrackPos;
if (m_MinBtnRect.Contains(point))
DoMouseDown(0, m_MinBtnRect, &m_iMinButtonState, point);
else if (m_ThumbRect.Contains(point))
DoMouseDown(1, m_ThumbRect, &m_iThumbButtonState, point);
else if (m_MaxBtnRect.Contains(point))
DoMouseDown(2, m_MaxBtnRect, &m_iMaxButtonState, point);
else if (m_MinTrackRect.Contains(point))
DoMouseDown(3, m_MinTrackRect, &m_iMinTrackState, point);
else
DoMouseDown(4, m_MaxTrackRect, &m_iMaxTrackState, point);
if (!SendEvent()) {
m_pTimer = std::make_unique<CFX_Timer>(GetFWLApp()->GetTimerHandler(), this,
kScrollbarElapsedMsecs);
}
}
void CFWL_ScrollBar::OnLButtonUp(const CFX_PointF& point) {
m_pTimer.reset();
m_bMouseDown = false;
DoMouseUp(0, m_MinBtnRect, &m_iMinButtonState, point);
DoMouseUp(1, m_ThumbRect, &m_iThumbButtonState, point);
DoMouseUp(2, m_MaxBtnRect, &m_iMaxButtonState, point);
DoMouseUp(3, m_MinTrackRect, &m_iMinTrackState, point);
DoMouseUp(4, m_MaxTrackRect, &m_iMaxTrackState, point);
SetGrab(false);
}
void CFWL_ScrollBar::OnMouseMove(const CFX_PointF& point) {
DoMouseMove(0, m_MinBtnRect, &m_iMinButtonState, point);
DoMouseMove(1, m_ThumbRect, &m_iThumbButtonState, point);
DoMouseMove(2, m_MaxBtnRect, &m_iMaxButtonState, point);
DoMouseMove(3, m_MinTrackRect, &m_iMinTrackState, point);
DoMouseMove(4, m_MaxTrackRect, &m_iMaxTrackState, point);
}
void CFWL_ScrollBar::OnMouseLeave() {
DoMouseLeave(0, m_MinBtnRect, &m_iMinButtonState);
DoMouseLeave(1, m_ThumbRect, &m_iThumbButtonState);
DoMouseLeave(2, m_MaxBtnRect, &m_iMaxButtonState);
DoMouseLeave(3, m_MinTrackRect, &m_iMinTrackState);
DoMouseLeave(4, m_MaxTrackRect, &m_iMaxTrackState);
}
void CFWL_ScrollBar::OnMouseWheel(const CFX_Vector& delta) {
m_iMouseWheel = delta.y;
SendEvent();
m_iMouseWheel = 0;
}
void CFWL_ScrollBar::DoMouseDown(int32_t iItem,
const CFX_RectF& rtItem,
CFWL_PartState* pState,
const CFX_PointF& point) {
if (!rtItem.Contains(point))
return;
if (*pState == CFWL_PartState::kPressed)
return;
*pState = CFWL_PartState::kPressed;
RepaintRect(rtItem);
}
void CFWL_ScrollBar::DoMouseUp(int32_t iItem,
const CFX_RectF& rtItem,
CFWL_PartState* pState,
const CFX_PointF& point) {
CFWL_PartState iNewState = rtItem.Contains(point) ? CFWL_PartState::kHovered
: CFWL_PartState::kNormal;
if (*pState == iNewState)
return;
*pState = iNewState;
RepaintRect(rtItem);
OnScroll(CFWL_EventScroll::Code::EndScroll, m_fTrackPos);
}
void CFWL_ScrollBar::DoMouseMove(int32_t iItem,
const CFX_RectF& rtItem,
CFWL_PartState* pState,
const CFX_PointF& point) {
if (!m_bMouseDown) {
CFWL_PartState iNewState = rtItem.Contains(point) ? CFWL_PartState::kHovered
: CFWL_PartState::kNormal;
if (*pState == iNewState)
return;
*pState = iNewState;
RepaintRect(rtItem);
} else if ((2 == iItem) &&
(m_iThumbButtonState == CFWL_PartState::kPressed)) {
m_fTrackPos = GetTrackPointPos(point);
OnScroll(CFWL_EventScroll::Code::TrackPos, m_fTrackPos);
}
}
void CFWL_ScrollBar::DoMouseLeave(int32_t iItem,
const CFX_RectF& rtItem,
CFWL_PartState* pState) {
if (*pState == CFWL_PartState::kNormal)
return;
*pState = CFWL_PartState::kNormal;
RepaintRect(rtItem);
}
void CFWL_ScrollBar::DoMouseHover(int32_t iItem,
const CFX_RectF& rtItem,
CFWL_PartState* pState) {
if (*pState == CFWL_PartState::kHovered)
return;
*pState = CFWL_PartState::kHovered;
RepaintRect(rtItem);
}
void CFWL_ScrollBar::OnTimerFired() {
m_pTimer.reset();
if (!SendEvent()) {
m_pTimer =
std::make_unique<CFX_Timer>(GetFWLApp()->GetTimerHandler(), this, 0);
}
}