blob: 410be18a8dd3e70c3dfa22499f974c39a5e692a9 [file] [log] [blame]
// 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/PWL_ScrollBar.h"
#include "core/fxge/include/fx_ge.h"
#include "fpdfsdk/pdfwindow/PWL_Utils.h"
#include "fpdfsdk/pdfwindow/PWL_Wnd.h"
PWL_FLOATRANGE::PWL_FLOATRANGE() {
Default();
}
PWL_FLOATRANGE::PWL_FLOATRANGE(FX_FLOAT min, FX_FLOAT max) {
Set(min, max);
}
void PWL_FLOATRANGE::Default() {
fMin = 0;
fMax = 0;
}
void PWL_FLOATRANGE::Set(FX_FLOAT min, FX_FLOAT max) {
if (min > max) {
fMin = max;
fMax = min;
} else {
fMin = min;
fMax = max;
}
}
FX_BOOL PWL_FLOATRANGE::In(FX_FLOAT x) const {
return (IsFloatBigger(x, fMin) || IsFloatEqual(x, fMin)) &&
(IsFloatSmaller(x, fMax) || IsFloatEqual(x, fMax));
}
FX_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(FX_FLOAT min, FX_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(FX_FLOAT width) {
fClientWidth = width;
}
void PWL_SCROLL_PRIVATEDATA::SetSmallStep(FX_FLOAT step) {
fSmallStep = step;
}
void PWL_SCROLL_PRIVATEDATA::SetBigStep(FX_FLOAT step) {
fBigStep = step;
}
FX_BOOL PWL_SCROLL_PRIVATEDATA::SetPos(FX_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_FloatPoint ptCenter = GetCenterPoint();
switch (m_eScrollBarType) {
case SBT_HSCROLL:
switch (m_eSBButtonType) {
case PSBT_MIN: {
CFX_FloatPoint pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,
ptCenter.y);
CFX_FloatPoint pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,
ptCenter.y + PWL_TRIANGLE_HALFLEN);
CFX_FloatPoint 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_FloatPoint pt1(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,
ptCenter.y);
CFX_FloatPoint pt2(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,
ptCenter.y + PWL_TRIANGLE_HALFLEN);
CFX_FloatPoint 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_FloatPoint pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN,
ptCenter.y - PWL_TRIANGLE_HALFLEN * 0.5f);
CFX_FloatPoint pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN,
ptCenter.y - PWL_TRIANGLE_HALFLEN * 0.5f);
CFX_FloatPoint 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_FloatPoint pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN,
ptCenter.y + PWL_TRIANGLE_HALFLEN * 0.5f);
CFX_FloatPoint pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN,
ptCenter.y + PWL_TRIANGLE_HALFLEN * 0.5f);
CFX_FloatPoint 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_FloatPoint ptCenter = GetCenterPoint();
int32_t nTransparancy = GetTransparency();
switch (m_eScrollBarType) {
case SBT_HSCROLL:
CPWL_Wnd::DrawThisAppearance(pDevice, pUser2Device);
switch (m_eSBButtonType) {
case PSBT_MIN: {
CFX_FloatPoint pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,
ptCenter.y);
CFX_FloatPoint pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,
ptCenter.y + PWL_TRIANGLE_HALFLEN);
CFX_FloatPoint 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.SetPointCount(4);
path.SetPoint(0, pt1.x, pt1.y, FXPT_MOVETO);
path.SetPoint(1, pt2.x, pt2.y, FXPT_LINETO);
path.SetPoint(2, pt3.x, pt3.y, FXPT_LINETO);
path.SetPoint(3, pt1.x, pt1.y, FXPT_LINETO);
pDevice->DrawPath(&path, pUser2Device, nullptr,
CPWL_Utils::PWLColorToFXColor(
PWL_DEFAULT_BLACKCOLOR, nTransparancy),
0, FXFILL_ALTERNATE);
}
} break;
case PSBT_MAX: {
CFX_FloatPoint pt1(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,
ptCenter.y);
CFX_FloatPoint pt2(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,
ptCenter.y + PWL_TRIANGLE_HALFLEN);
CFX_FloatPoint 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.SetPointCount(4);
path.SetPoint(0, pt1.x, pt1.y, FXPT_MOVETO);
path.SetPoint(1, pt2.x, pt2.y, FXPT_LINETO);
path.SetPoint(2, pt3.x, pt3.y, FXPT_LINETO);
path.SetPoint(3, pt1.x, pt1.y, FXPT_LINETO);
pDevice->DrawPath(&path, pUser2Device, nullptr,
CPWL_Utils::PWLColorToFXColor(
PWL_DEFAULT_BLACKCOLOR, nTransparancy),
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(nTransparancy, 100, 100, 100),
0.0f);
// draw inner border
rcDraw = CPWL_Utils::DeflateRect(rectWnd, 0.5f);
CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
ArgbEncode(nTransparancy, 255, 255, 255),
1.0f);
// draw background
rcDraw = CPWL_Utils::DeflateRect(rectWnd, 1.0f);
if (IsEnabled())
CPWL_Utils::DrawShadow(pDevice, pUser2Device, TRUE, FALSE, rcDraw,
nTransparancy, 80, 220);
else
CPWL_Utils::DrawFillRect(pDevice, pUser2Device, rcDraw,
ArgbEncode(255, 255, 255, 255));
// draw arrow
if (rectWnd.top - rectWnd.bottom > 6.0f) {
FX_FLOAT fX = rectWnd.left + 1.5f;
FX_FLOAT fY = rectWnd.bottom;
CFX_FloatPoint pts[7] = {CFX_FloatPoint(fX + 2.5f, fY + 4.0f),
CFX_FloatPoint(fX + 2.5f, fY + 3.0f),
CFX_FloatPoint(fX + 4.5f, fY + 5.0f),
CFX_FloatPoint(fX + 6.5f, fY + 3.0f),
CFX_FloatPoint(fX + 6.5f, fY + 4.0f),
CFX_FloatPoint(fX + 4.5f, fY + 6.0f),
CFX_FloatPoint(fX + 2.5f, fY + 4.0f)};
if (IsEnabled())
CPWL_Utils::DrawFillArea(
pDevice, pUser2Device, pts, 7,
ArgbEncode(nTransparancy, 255, 255, 255));
else
CPWL_Utils::DrawFillArea(pDevice, pUser2Device, pts, 7,
CPWL_Utils::PWLColorToFXColor(
PWL_DEFAULT_HEAVYGRAYCOLOR, 255));
}
} break;
case PSBT_MAX: {
// draw border
CFX_FloatRect rcDraw = rectWnd;
CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
ArgbEncode(nTransparancy, 100, 100, 100),
0.0f);
// draw inner border
rcDraw = CPWL_Utils::DeflateRect(rectWnd, 0.5f);
CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
ArgbEncode(nTransparancy, 255, 255, 255),
1.0f);
// draw background
rcDraw = CPWL_Utils::DeflateRect(rectWnd, 1.0f);
if (IsEnabled())
CPWL_Utils::DrawShadow(pDevice, pUser2Device, TRUE, FALSE, rcDraw,
nTransparancy, 80, 220);
else
CPWL_Utils::DrawFillRect(pDevice, pUser2Device, rcDraw,
ArgbEncode(255, 255, 255, 255));
// draw arrow
if (rectWnd.top - rectWnd.bottom > 6.0f) {
FX_FLOAT fX = rectWnd.left + 1.5f;
FX_FLOAT fY = rectWnd.bottom;
CFX_FloatPoint pts[7] = {CFX_FloatPoint(fX + 2.5f, fY + 5.0f),
CFX_FloatPoint(fX + 2.5f, fY + 6.0f),
CFX_FloatPoint(fX + 4.5f, fY + 4.0f),
CFX_FloatPoint(fX + 6.5f, fY + 6.0f),
CFX_FloatPoint(fX + 6.5f, fY + 5.0f),
CFX_FloatPoint(fX + 4.5f, fY + 3.0f),
CFX_FloatPoint(fX + 2.5f, fY + 5.0f)};
if (IsEnabled())
CPWL_Utils::DrawFillArea(
pDevice, pUser2Device, pts, 7,
ArgbEncode(nTransparancy, 255, 255, 255));
else
CPWL_Utils::DrawFillArea(pDevice, pUser2Device, pts, 7,
CPWL_Utils::PWLColorToFXColor(
PWL_DEFAULT_HEAVYGRAYCOLOR, 255));
}
} break;
case PSBT_POS: {
// draw border
CFX_FloatRect rcDraw = rectWnd;
CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
ArgbEncode(nTransparancy, 100, 100, 100),
0.0f);
// draw inner border
rcDraw = CPWL_Utils::DeflateRect(rectWnd, 0.5f);
CPWL_Utils::DrawStrokeRect(pDevice, pUser2Device, rcDraw,
ArgbEncode(nTransparancy, 255, 255, 255),
1.0f);
if (IsEnabled()) {
// draw shadow effect
CFX_FloatPoint ptTop =
CFX_FloatPoint(rectWnd.left, rectWnd.top - 1.0f);
CFX_FloatPoint ptBottom =
CFX_FloatPoint(rectWnd.left, rectWnd.bottom + 1.0f);
ptTop.x += 1.5f;
ptBottom.x += 1.5f;
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
ArgbEncode(nTransparancy, 210, 210, 210),
1.0f);
ptTop.x += 1.0f;
ptBottom.x += 1.0f;
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
ArgbEncode(nTransparancy, 220, 220, 220),
1.0f);
ptTop.x += 1.0f;
ptBottom.x += 1.0f;
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
ArgbEncode(nTransparancy, 240, 240, 240),
1.0f);
ptTop.x += 1.0f;
ptBottom.x += 1.0f;
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
ArgbEncode(nTransparancy, 240, 240, 240),
1.0f);
ptTop.x += 1.0f;
ptBottom.x += 1.0f;
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
ArgbEncode(nTransparancy, 210, 210, 210),
1.0f);
ptTop.x += 1.0f;
ptBottom.x += 1.0f;
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
ArgbEncode(nTransparancy, 180, 180, 180),
1.0f);
ptTop.x += 1.0f;
ptBottom.x += 1.0f;
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
ArgbEncode(nTransparancy, 150, 150, 150),
1.0f);
ptTop.x += 1.0f;
ptBottom.x += 1.0f;
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
ArgbEncode(nTransparancy, 150, 150, 150),
1.0f);
ptTop.x += 1.0f;
ptBottom.x += 1.0f;
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
ArgbEncode(nTransparancy, 180, 180, 180),
1.0f);
ptTop.x += 1.0f;
ptBottom.x += 1.0f;
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptTop, ptBottom,
ArgbEncode(nTransparancy, 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(nTransparancy, 120, 120, 120);
if (!IsEnabled())
crStroke = CPWL_Utils::PWLColorToFXColor(
PWL_DEFAULT_HEAVYGRAYCOLOR, 255);
FX_FLOAT nFrictionWidth = 5.0f;
FX_FLOAT nFrictionHeight = 5.5f;
CFX_FloatPoint ptLeft =
CFX_FloatPoint(ptCenter.x - nFrictionWidth / 2.0f,
ptCenter.y - nFrictionHeight / 2.0f + 0.5f);
CFX_FloatPoint ptRight =
CFX_FloatPoint(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;
}
}
FX_BOOL CPWL_SBButton::OnLButtonDown(const CFX_FloatPoint& 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;
}
FX_BOOL CPWL_SBButton::OnLButtonUp(const CFX_FloatPoint& 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;
}
FX_BOOL CPWL_SBButton::OnMouseMove(const CFX_FloatPoint& 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::RePosChildWnd() {
CFX_FloatRect rcClient = GetClientRect();
CFX_FloatRect rcMinButton, rcMaxButton;
FX_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_FloatPoint(rectWnd.left + 2.0f, rectWnd.top - 2.0f),
CFX_FloatPoint(rectWnd.left + 2.0f, rectWnd.bottom + 2.0f),
ArgbEncode(GetTransparency(), 100, 100, 100), 1.0f);
CPWL_Utils::DrawStrokeLine(
pDevice, pUser2Device,
CFX_FloatPoint(rectWnd.right - 2.0f, rectWnd.top - 2.0f),
CFX_FloatPoint(rectWnd.right - 2.0f, rectWnd.bottom + 2.0f),
ArgbEncode(GetTransparency(), 100, 100, 100), 1.0f);
}
}
FX_BOOL CPWL_ScrollBar::OnLButtonDown(const CFX_FloatPoint& 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.x, point.y)) {
m_sData.SubBig();
MovePosButton(TRUE);
NotifyScrollWindow();
}
if (rcMaxArea.Contains(point.x, point.y)) {
m_sData.AddBig();
MovePosButton(TRUE);
NotifyScrollWindow();
}
}
return TRUE;
}
FX_BOOL CPWL_ScrollBar::OnLButtonUp(const CFX_FloatPoint& point,
uint32_t nFlag) {
CPWL_Wnd::OnLButtonUp(point, nFlag);
if (HasFlag(PWS_AUTOTRANSPARENT)) {
if (GetTransparency() != PWL_SCROLLBAR_TRANSPARANCY) {
SetTransparency(PWL_SCROLLBAR_TRANSPARANCY);
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_FloatPoint*)lParam);
}
if (pWnd == m_pMaxButton) {
OnMaxButtonLBDown(*(CFX_FloatPoint*)lParam);
}
if (pWnd == m_pPosButton) {
OnPosButtonLBDown(*(CFX_FloatPoint*)lParam);
}
break;
case PNM_LBUTTONUP:
if (pWnd == m_pMinButton) {
OnMinButtonLBUp(*(CFX_FloatPoint*)lParam);
}
if (pWnd == m_pMaxButton) {
OnMaxButtonLBUp(*(CFX_FloatPoint*)lParam);
}
if (pWnd == m_pPosButton) {
OnPosButtonLBUp(*(CFX_FloatPoint*)lParam);
}
break;
case PNM_MOUSEMOVE:
if (pWnd == m_pMinButton) {
OnMinButtonMouseMove(*(CFX_FloatPoint*)lParam);
}
if (pWnd == m_pMaxButton) {
OnMaxButtonMouseMove(*(CFX_FloatPoint*)lParam);
}
if (pWnd == m_pPosButton) {
OnPosButtonMouseMove(*(CFX_FloatPoint*)lParam);
}
break;
case PNM_SETSCROLLINFO: {
if (PWL_SCROLL_INFO* pInfo = (PWL_SCROLL_INFO*)lParam) {
if (FXSYS_memcmp(&m_OriginInfo, pInfo, sizeof(PWL_SCROLL_INFO)) != 0) {
m_OriginInfo = *pInfo;
FX_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: {
FX_FLOAT fPos = *(FX_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);
}
}
FX_FLOAT CPWL_ScrollBar::GetScrollBarWidth() const {
if (!IsVisible())
return 0;
return PWL_SCROLLBAR_WIDTH;
}
void CPWL_ScrollBar::SetScrollRange(FX_FLOAT fMin,
FX_FLOAT fMax,
FX_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(FX_FLOAT fPos) {
FX_FLOAT fOldPos = m_sData.fScrollPos;
m_sData.SetPos(fPos);
if (!IsFloatEqual(m_sData.fScrollPos, fOldPos))
MovePosButton(TRUE);
}
void CPWL_ScrollBar::SetScrollStep(FX_FLOAT fBigStep, FX_FLOAT fSmallStep) {
m_sData.SetBigStep(fBigStep);
m_sData.SetSmallStep(fSmallStep);
}
void CPWL_ScrollBar::MovePosButton(FX_BOOL bRefresh) {
ASSERT(m_pMinButton);
ASSERT(m_pMaxButton);
if (m_pPosButton->IsVisible()) {
CFX_FloatRect rcClient;
CFX_FloatRect rcPosArea, rcPosButton;
rcClient = GetClientRect();
rcPosArea = GetScrollArea();
FX_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_FloatPoint& point) {
m_sData.SubSmall();
MovePosButton(TRUE);
NotifyScrollWindow();
m_bMinOrMax = TRUE;
EndTimer();
BeginTimer(100);
}
void CPWL_ScrollBar::OnMinButtonLBUp(const CFX_FloatPoint& point) {}
void CPWL_ScrollBar::OnMinButtonMouseMove(const CFX_FloatPoint& point) {}
void CPWL_ScrollBar::OnMaxButtonLBDown(const CFX_FloatPoint& point) {
m_sData.AddSmall();
MovePosButton(TRUE);
NotifyScrollWindow();
m_bMinOrMax = FALSE;
EndTimer();
BeginTimer(100);
}
void CPWL_ScrollBar::OnMaxButtonLBUp(const CFX_FloatPoint& point) {}
void CPWL_ScrollBar::OnMaxButtonMouseMove(const CFX_FloatPoint& point) {}
void CPWL_ScrollBar::OnPosButtonLBDown(const CFX_FloatPoint& 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_FloatPoint& point) {
if (m_bMouseDown) {
if (!m_bNotifyForever)
NotifyScrollWindow();
}
m_bMouseDown = FALSE;
}
void CPWL_ScrollBar::OnPosButtonMouseMove(const CFX_FloatPoint& point) {
FX_FLOAT fOldScrollPos = m_sData.fScrollPos;
FX_FLOAT fNewPos = 0;
switch (m_sbType) {
case SBT_HSCROLL:
if (FXSYS_fabs(point.x - m_nOldPos) < 1)
return;
fNewPos = FaceToTrue(m_fOldPosButton + point.x - m_nOldPos);
break;
case SBT_VSCROLL:
if (FXSYS_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()) {
FX_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();
FX_FLOAT fMinWidth = rcMin.right - rcMin.left;
FX_FLOAT fMinHeight = rcMin.top - rcMin.bottom;
FX_FLOAT fMaxWidth = rcMax.right - rcMax.left;
FX_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;
}
FX_FLOAT CPWL_ScrollBar::TrueToFace(FX_FLOAT fTrue) {
CFX_FloatRect rcPosArea;
rcPosArea = GetScrollArea();
FX_FLOAT fFactWidth = m_sData.ScrollRange.GetWidth() + m_sData.fClientWidth;
fFactWidth = fFactWidth == 0 ? 1 : fFactWidth;
FX_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;
}
FX_FLOAT CPWL_ScrollBar::FaceToTrue(FX_FLOAT fFace) {
CFX_FloatRect rcPosArea;
rcPosArea = GetScrollArea();
FX_FLOAT fFactWidth = m_sData.ScrollRange.GetWidth() + m_sData.fClientWidth;
fFactWidth = fFactWidth == 0 ? 1 : fFactWidth;
FX_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 (FXSYS_memcmp(&m_sData, &sTemp, sizeof(PWL_SCROLL_PRIVATEDATA)) != 0) {
MovePosButton(TRUE);
NotifyScrollWindow();
}
}