// 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 "../../include/pdfwindow/PDFWindow.h" | |
#include "../../include/pdfwindow/PWL_Wnd.h" | |
#include "../../include/pdfwindow/PWL_ScrollBar.h" | |
#include "../../include/pdfwindow/PWL_Utils.h" | |
#define IsFloatZero(f) ((f) < 0.0001 && (f) > -0.0001) | |
#define IsFloatBigger(fa,fb) ((fa) > (fb) && !IsFloatZero((fa) - (fb))) | |
#define IsFloatSmaller(fa,fb) ((fa) < (fb) && !IsFloatZero((fa) - (fb))) | |
#define IsFloatEqual(fa,fb) IsFloatZero((fa)-(fb)) | |
/* ------------------------------- PWL_FLOATRANGE ------------------------------- */ | |
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::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::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; | |
CPDF_Rect rectWnd = GetWindowRect(); | |
if (rectWnd.IsEmpty()) return; | |
sAppStream << "q\n"; | |
CPDF_Point ptCenter = this->GetCenterPoint(); | |
switch (this->m_eScrollBarType) | |
{ | |
case SBT_HSCROLL: | |
switch (this->m_eSBButtonType) | |
{ | |
case PSBT_MIN: | |
{ | |
CPDF_Point pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y); | |
CPDF_Point pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y + PWL_TRIANGLE_HALFLEN); | |
CPDF_Point 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: | |
{ | |
CPDF_Point pt1(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y); | |
CPDF_Point pt2(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y + PWL_TRIANGLE_HALFLEN); | |
CPDF_Point 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(this->m_eSBButtonType) | |
{ | |
case PSBT_MIN: | |
{ | |
CPDF_Point pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN,ptCenter.y - PWL_TRIANGLE_HALFLEN * 0.5f); | |
CPDF_Point pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN,ptCenter.y - PWL_TRIANGLE_HALFLEN * 0.5f); | |
CPDF_Point 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: | |
{ | |
CPDF_Point pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN,ptCenter.y + PWL_TRIANGLE_HALFLEN * 0.5f); | |
CPDF_Point pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN,ptCenter.y + PWL_TRIANGLE_HALFLEN * 0.5f); | |
CPDF_Point 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, CPDF_Matrix* pUser2Device) | |
{ | |
if (!IsVisible()) return; | |
CPDF_Rect rectWnd = GetWindowRect(); | |
if (rectWnd.IsEmpty()) return; | |
CPDF_Point ptCenter = this->GetCenterPoint(); | |
FX_INT32 nTransparancy = this->GetTransparency(); | |
switch (this->m_eScrollBarType) | |
{ | |
case SBT_HSCROLL: | |
CPWL_Wnd::DrawThisAppearance(pDevice,pUser2Device); | |
switch (this->m_eSBButtonType) | |
{ | |
case PSBT_MIN: | |
{ | |
CPDF_Point pt1(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y); | |
CPDF_Point pt2(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y + PWL_TRIANGLE_HALFLEN); | |
CPDF_Point 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, NULL, | |
CPWL_Utils::PWLColorToFXColor(PWL_DEFAULT_BLACKCOLOR,nTransparancy), | |
0, FXFILL_ALTERNATE); | |
} | |
} | |
break; | |
case PSBT_MAX: | |
{ | |
CPDF_Point pt1(ptCenter.x + PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y); | |
CPDF_Point pt2(ptCenter.x - PWL_TRIANGLE_HALFLEN * 0.5f,ptCenter.y + PWL_TRIANGLE_HALFLEN); | |
CPDF_Point 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, NULL, | |
CPWL_Utils::PWLColorToFXColor(PWL_DEFAULT_BLACKCOLOR,nTransparancy), | |
0, FXFILL_ALTERNATE); | |
} | |
} | |
break; | |
default: | |
break; | |
} | |
break; | |
case SBT_VSCROLL: | |
switch(this->m_eSBButtonType) | |
{ | |
case PSBT_MIN: | |
{ | |
//draw border | |
CPDF_Rect 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 (this->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; | |
CPDF_Point pts[7] = { | |
CPDF_Point(fX+2.5f, fY+4.0f), | |
CPDF_Point(fX+2.5f, fY+3.0f), | |
CPDF_Point(fX+4.5f, fY+5.0f), | |
CPDF_Point(fX+6.5f, fY+3.0f), | |
CPDF_Point(fX+6.5f, fY+4.0f), | |
CPDF_Point(fX+4.5f, fY+6.0f), | |
CPDF_Point(fX+2.5f, fY+4.0f)}; | |
if (this->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 | |
CPDF_Rect 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 (this->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; | |
CPDF_Point pts[7] = { | |
CPDF_Point(fX+2.5f, fY+5.0f), | |
CPDF_Point(fX+2.5f, fY+6.0f), | |
CPDF_Point(fX+4.5f, fY+4.0f), | |
CPDF_Point(fX+6.5f, fY+6.0f), | |
CPDF_Point(fX+6.5f, fY+5.0f), | |
CPDF_Point(fX+4.5f, fY+3.0f), | |
CPDF_Point(fX+2.5f, fY+5.0f)}; | |
if (this->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: | |
{ | |
//CPWL_Wnd::DrawThisAppearance(pDevice,pUser2Device); | |
//draw border | |
CPDF_Rect 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 (this->IsEnabled()) | |
{ | |
//draw shadow effect | |
CPDF_Point ptTop = CPDF_Point(rectWnd.left,rectWnd.top-1.0f); | |
CPDF_Point ptBottom = CPDF_Point(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 (!this->IsEnabled()) | |
crStroke = CPWL_Utils::PWLColorToFXColor(PWL_DEFAULT_HEAVYGRAYCOLOR,255); | |
FX_FLOAT nFrictionWidth = 5.0f; | |
FX_FLOAT nFrictionHeight = 5.5f; | |
CPDF_Point ptLeft = CPDF_Point(ptCenter.x - nFrictionWidth / 2.0f, ptCenter.y - nFrictionHeight / 2.0f + 0.5f); | |
CPDF_Point ptRight = CPDF_Point(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); | |
/* | |
ptLeft.y += 1.5f; | |
ptRight.y += 1.5f; | |
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, ptLeft, ptRight, | |
ArgbEncode(nTransparancy,150,150,150),1.0f); | |
*/ | |
} | |
} | |
break; | |
default: | |
break; | |
} | |
break; | |
default: | |
break; | |
} | |
} | |
FX_BOOL CPWL_SBButton::OnLButtonDown(const CPDF_Point & point, FX_DWORD nFlag) | |
{ | |
CPWL_Wnd::OnLButtonDown(point,nFlag); | |
if (CPWL_Wnd * pParent = GetParentWindow()) | |
pParent->OnNotify(this,PNM_LBUTTONDOWN,0,(FX_INTPTR)&point); | |
m_bMouseDown = TRUE; | |
SetCapture(); | |
return TRUE; | |
} | |
FX_BOOL CPWL_SBButton::OnLButtonUp(const CPDF_Point & point, FX_DWORD nFlag) | |
{ | |
CPWL_Wnd::OnLButtonUp(point,nFlag); | |
if (CPWL_Wnd * pParent = GetParentWindow()) | |
pParent->OnNotify(this,PNM_LBUTTONUP,0,(FX_INTPTR)&point); | |
m_bMouseDown = FALSE; | |
ReleaseCapture(); | |
return TRUE; | |
} | |
FX_BOOL CPWL_SBButton::OnMouseMove(const CPDF_Point & point, FX_DWORD nFlag) | |
{ | |
CPWL_Wnd::OnMouseMove(point,nFlag); | |
if (CPWL_Wnd * pParent = GetParentWindow()) | |
{ | |
pParent->OnNotify(this,PNM_MOUSEMOVE,0,(FX_INTPTR)&point); | |
/* | |
if (m_bMouseDown && (m_eSBButtonType == PSBT_MIN || m_eSBButtonType == PSBT_MAX)) | |
{ | |
if (!pParent->OnNotify(this,PNM_LBUTTONDOWN,nFlags,(FX_INTPTR)&point)) | |
return FALSE; | |
} | |
*/ | |
} | |
return TRUE; | |
} | |
/* ------------------------------- CPWL_ScrollBar ---------------------------------- */ | |
CPWL_ScrollBar::CPWL_ScrollBar(PWL_SCROLLBAR_TYPE sbType): | |
m_sbType(sbType), | |
m_pMinButton(NULL), | |
m_pMaxButton(NULL), | |
m_pPosButton(NULL), | |
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() | |
{ | |
CPDF_Rect rcClient = this->GetClientRect(); | |
/* | |
switch(m_sbType) | |
{ | |
case SBT_HSCROLL: | |
if (rcClient.right - rcClient.left < PWL_SCROLLBAR_WIDTH || | |
rcClient.top - rcClient.bottom < PWL_SCROLLBAR_WIDTH) | |
{ | |
SetVisible(FALSE); | |
} | |
break; | |
case SBT_VSCROLL: | |
if (rcClient.right - rcClient.left < PWL_SCROLLBAR_WIDTH || | |
rcClient.top - rcClient.bottom < PWL_SCROLLBAR_WIDTH) | |
{ | |
SetVisible(FALSE); | |
} | |
break; | |
} | |
*/ | |
CPDF_Rect 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 = CPDF_Rect(rcClient.left,rcClient.bottom, | |
rcClient.left + PWL_SCROLLBAR_BUTTON_WIDTH,rcClient.top); | |
rcMaxButton = CPDF_Rect(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 = CPDF_Rect(rcClient.left,rcClient.bottom, | |
rcClient.left + fBWidth,rcClient.top); | |
rcMaxButton = CPDF_Rect(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 = CPDF_Rect(rcClient.left,rcClient.top - PWL_SCROLLBAR_BUTTON_WIDTH, | |
rcClient.right,rcClient.top); | |
rcMaxButton = CPDF_Rect(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 = CPDF_Rect(rcClient.left,rcClient.top - fBWidth, | |
rcClient.right,rcClient.top); | |
rcMaxButton = CPDF_Rect(rcClient.left,rcClient.bottom, | |
rcClient.right,rcClient.bottom + fBWidth); | |
} | |
else SetVisible(FALSE); | |
} | |
break; | |
} | |
// if (IsVisible()) | |
{ | |
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) | |
{ | |
CPDF_Rect rectWnd = GetWindowRect(); | |
if (IsVisible() && !rectWnd.IsEmpty()) | |
{ | |
CFX_ByteTextBuf sButton; | |
sButton << "q\n"; | |
sButton << "0 w\n" << CPWL_Utils::GetColorAppStream(GetBackgroundColor(),TRUE); | |
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, CPDF_Matrix* pUser2Device) | |
{ | |
// CPWL_Wnd::DrawThisAppearance(pDevice,pUser2Device); | |
CPDF_Rect rectWnd = GetWindowRect(); | |
if (IsVisible() && !rectWnd.IsEmpty()) | |
{ | |
CPWL_Utils::DrawFillRect(pDevice, pUser2Device, rectWnd, this->GetBackgroundColor(), GetTransparency()); | |
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, | |
CPDF_Point(rectWnd.left+2.0f,rectWnd.top-2.0f), CPDF_Point(rectWnd.left+2.0f,rectWnd.bottom+2.0f), | |
ArgbEncode(this->GetTransparency(),100,100,100),1.0f); | |
CPWL_Utils::DrawStrokeLine(pDevice, pUser2Device, | |
CPDF_Point(rectWnd.right-2.0f,rectWnd.top-2.0f), CPDF_Point(rectWnd.right-2.0f,rectWnd.bottom+2.0f), | |
ArgbEncode(this->GetTransparency(),100,100,100),1.0f); | |
} | |
} | |
FX_BOOL CPWL_ScrollBar::OnLButtonDown(const CPDF_Point & point, FX_DWORD nFlag) | |
{ | |
CPWL_Wnd::OnLButtonDown(point,nFlag); | |
//SetFocus(); | |
if (HasFlag(PWS_AUTOTRANSPARENT)) | |
{ | |
if (GetTransparency() != 255) | |
{ | |
SetTransparency(255); | |
InvalidateRect(); | |
} | |
} | |
CPDF_Rect rcMinArea,rcMaxArea; | |
if (m_pPosButton && m_pPosButton->IsVisible()) | |
{ | |
CPDF_Rect rcClient = this->GetClientRect(); | |
CPDF_Rect rcPosButton = m_pPosButton->GetWindowRect(); | |
switch (m_sbType) | |
{ | |
case SBT_HSCROLL: | |
rcMinArea = CPDF_Rect(rcClient.left + PWL_SCROLLBAR_BUTTON_WIDTH,rcClient.bottom, | |
rcPosButton.left,rcClient.top); | |
rcMaxArea = CPDF_Rect(rcPosButton.right,rcClient.bottom, | |
rcClient.right - PWL_SCROLLBAR_BUTTON_WIDTH,rcClient.top); | |
break; | |
case SBT_VSCROLL: | |
rcMinArea = CPDF_Rect(rcClient.left,rcPosButton.top, | |
rcClient.right,rcClient.top - PWL_SCROLLBAR_BUTTON_WIDTH); | |
rcMaxArea = CPDF_Rect(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 CPDF_Point & point, FX_DWORD 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, FX_DWORD msg, FX_INTPTR wParam, FX_INTPTR lParam) | |
{ | |
CPWL_Wnd::OnNotify(pWnd,msg,wParam,lParam); | |
switch (msg) | |
{ | |
case PNM_LBUTTONDOWN: | |
if (pWnd == m_pMinButton) | |
{ | |
OnMinButtonLBDown(*(CPDF_Point*)lParam); | |
} | |
if (pWnd == m_pMaxButton) | |
{ | |
OnMaxButtonLBDown(*(CPDF_Point*)lParam); | |
} | |
if (pWnd == m_pPosButton) | |
{ | |
OnPosButtonLBDown(*(CPDF_Point*)lParam); | |
} | |
break; | |
case PNM_LBUTTONUP: | |
if (pWnd == m_pMinButton) | |
{ | |
OnMinButtonLBUp(*(CPDF_Point*)lParam); | |
} | |
if (pWnd == m_pMaxButton) | |
{ | |
OnMaxButtonLBUp(*(CPDF_Point*)lParam); | |
} | |
if (pWnd == m_pPosButton) | |
{ | |
OnPosButtonLBUp(*(CPDF_Point*)lParam); | |
} | |
break; | |
case PNM_MOUSEMOVE: | |
if (pWnd == m_pMinButton) | |
{ | |
OnMinButtonMouseMove(*(CPDF_Point*)lParam); | |
} | |
if (pWnd == m_pMaxButton) | |
{ | |
OnMaxButtonMouseMove(*(CPDF_Point*)lParam); | |
} | |
if (pWnd == m_pPosButton) | |
{ | |
OnPosButtonMouseMove(*(CPDF_Point*)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; | |
this->SetScrollRange(0,fMax, pInfo->fPlateWidth); | |
this->SetScrollStep(pInfo->fBigStep,pInfo->fSmallStep); | |
} | |
} | |
} | |
break; | |
case PNM_SETSCROLLPOS: | |
{ | |
FX_FLOAT fPos = *(FX_FLOAT*)lParam; | |
switch (this->m_sbType) | |
{ | |
case SBT_HSCROLL: | |
fPos = fPos - m_OriginInfo.fContentMin; | |
break; | |
case SBT_VSCROLL: | |
fPos = m_OriginInfo.fContentMax - fPos; | |
break; | |
} | |
this->SetScrollPos(fPos); | |
} | |
break; | |
} | |
} | |
void CPWL_ScrollBar::CreateButtons(const PWL_CREATEPARAM & cp) | |
{ | |
PWL_CREATEPARAM scp = cp; | |
scp.pParentWnd = this; | |
scp.dwBorderWidth = 2; | |
scp.nBorderStyle = PBS_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_pPosButton != NULL); | |
ASSERT (m_pMinButton != NULL); | |
ASSERT (m_pMaxButton != NULL); | |
if (m_pPosButton->IsVisible()) | |
{ | |
CPDF_Rect rcClient; | |
CPDF_Rect rcPosArea,rcPosButton; | |
rcClient = this->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 = CPDF_Rect(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 = CPDF_Rect(rcPosArea.left, | |
fBottom, | |
rcPosArea.right, | |
fTop); | |
break; | |
} | |
m_pPosButton->Move(rcPosButton,TRUE,bRefresh); | |
} | |
} | |
void CPWL_ScrollBar::OnMinButtonLBDown(const CPDF_Point & point) | |
{ | |
m_sData.SubSmall(); | |
MovePosButton(TRUE); | |
NotifyScrollWindow(); | |
m_bMinOrMax = TRUE; | |
EndTimer(); | |
BeginTimer(100); | |
} | |
void CPWL_ScrollBar::OnMinButtonLBUp(const CPDF_Point & point) | |
{ | |
} | |
void CPWL_ScrollBar::OnMinButtonMouseMove(const CPDF_Point & point) | |
{ | |
} | |
void CPWL_ScrollBar::OnMaxButtonLBDown(const CPDF_Point & point) | |
{ | |
m_sData.AddSmall(); | |
MovePosButton(TRUE); | |
NotifyScrollWindow(); | |
m_bMinOrMax = FALSE; | |
EndTimer(); | |
BeginTimer(100); | |
} | |
void CPWL_ScrollBar::OnMaxButtonLBUp(const CPDF_Point & point) | |
{ | |
} | |
void CPWL_ScrollBar::OnMaxButtonMouseMove(const CPDF_Point & point) | |
{ | |
} | |
void CPWL_ScrollBar::OnPosButtonLBDown(const CPDF_Point & point) | |
{ | |
m_bMouseDown = TRUE; | |
if (m_pPosButton) | |
{ | |
CPDF_Rect 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 CPDF_Point & point) | |
{ | |
if (m_bMouseDown) | |
{ | |
if (!m_bNotifyForever) | |
NotifyScrollWindow(); | |
} | |
m_bMouseDown = FALSE; | |
} | |
void CPWL_ScrollBar::OnPosButtonMouseMove(const CPDF_Point & 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 = this->GetParentWindow()) | |
{ | |
FX_FLOAT fPos; | |
switch (this->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,(FX_INTPTR)m_sbType,(FX_INTPTR)&fPos); | |
} | |
} | |
CPDF_Rect CPWL_ScrollBar::GetScrollArea() const | |
{ | |
CPDF_Rect rcClient = GetClientRect(); | |
CPDF_Rect rcArea; | |
if (!m_pMinButton || !m_pMaxButton)return rcClient; | |
CPDF_Rect rcMin = m_pMinButton->GetWindowRect(); | |
CPDF_Rect 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 = CPDF_Rect(rcClient.left + fMinWidth + 1,rcClient.bottom, | |
rcClient.right - fMaxWidth - 1,rcClient.top); | |
} | |
else | |
{ | |
rcArea = CPDF_Rect(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 = CPDF_Rect(rcClient.left,rcClient.bottom + fMinHeight + 1, | |
rcClient.right,rcClient.top - fMaxHeight - 1); | |
} | |
else | |
{ | |
rcArea = CPDF_Rect(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) | |
{ | |
CPDF_Rect 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) | |
{ | |
CPDF_Rect 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(); | |
} | |
} | |
/* | |
void CPWL_ScrollBar::OnSetFocus() | |
{ | |
if (GetTransparency() != 255) | |
{ | |
SetTransparency(255); | |
InvalidateRect(); | |
} | |
} | |
void CPWL_ScrollBar::OnKillFocus() | |
{ | |
if (GetTransparency() != PWL_SCROLLBAR_TRANSPARANCY) | |
{ | |
SetTransparency(PWL_SCROLLBAR_TRANSPARANCY); | |
InvalidateRect(); | |
} | |
} | |
*/ | |