blob: 50256870961ee8b555e50446dc2849a59f888a64 [file] [log] [blame] [edit]
// 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 "fpdfsdk/pwl/cpwl_wnd.h"
#include <sstream>
#include <utility>
#include <vector>
#include "build/build_config.h"
#include "core/fxcrt/check.h"
#include "core/fxcrt/check_op.h"
#include "core/fxcrt/containers/contains.h"
#include "core/fxcrt/stl_util.h"
#include "core/fxge/cfx_renderdevice.h"
#include "fpdfsdk/pwl/cpwl_scroll_bar.h"
#include "public/fpdf_fwlevent.h"
namespace {
constexpr float kDefaultFontSize = 9.0f;
} // namespace
// static
const CFX_Color CPWL_Wnd::kDefaultBlackColor =
CFX_Color(CFX_Color::Type::kGray, 0);
// static
const CFX_Color CPWL_Wnd::kDefaultWhiteColor =
CFX_Color(CFX_Color::Type::kGray, 1);
CPWL_Wnd::CreateParams::CreateParams(CFX_Timer::HandlerIface* timer_handler,
IPWL_FillerNotify* filler_notify,
ProviderIface* provider)
: pTimerHandler(timer_handler),
pFillerNotify(filler_notify),
pProvider(provider),
fFontSize(kDefaultFontSize),
sDash(3, 0, 0) {}
CPWL_Wnd::CreateParams::CreateParams(const CreateParams& other) = default;
CPWL_Wnd::CreateParams::~CreateParams() = default;
// For a compound window (a window containing a child window as occurs in a
// list box, combo box, or even a scroll bar), this class contains information
// shared amongst the parent and children.
class CPWL_Wnd::SharedCaptureFocusState final : public Observable {
public:
explicit SharedCaptureFocusState(const CPWL_Wnd* pOwnerWnd)
: m_pOwnerWnd(pOwnerWnd) {}
~SharedCaptureFocusState() = default;
bool IsOwnedByWnd(const CPWL_Wnd* pWnd) const { return m_pOwnerWnd == pWnd; }
bool IsWndCaptureMouse(const CPWL_Wnd* pWnd) const {
return pWnd && pdfium::Contains(m_MousePaths, pWnd);
}
bool IsMainCaptureKeyboard(const CPWL_Wnd* pWnd) const {
return pWnd == m_pMainKeyboardWnd;
}
bool IsWndCaptureKeyboard(const CPWL_Wnd* pWnd) const {
return pWnd && pdfium::Contains(m_KeyboardPaths, pWnd);
}
void SetCapture(CPWL_Wnd* pWnd) { m_MousePaths = pWnd->GetAncestors(); }
void ReleaseCapture() { m_MousePaths.clear(); }
void SetFocus(CPWL_Wnd* pWnd) {
m_KeyboardPaths = pWnd->GetAncestors();
m_pMainKeyboardWnd = pWnd;
// Note, pWnd may get destroyed in the OnSetFocus call.
pWnd->OnSetFocus();
}
void ReleaseFocus() {
ObservedPtr<SharedCaptureFocusState> this_observed(this);
if (!this_observed->m_KeyboardPaths.empty()) {
CPWL_Wnd* pWnd = this_observed->m_KeyboardPaths.front();
if (pWnd)
pWnd->OnKillFocus();
}
if (!this_observed) {
return;
}
this_observed->m_pMainKeyboardWnd = nullptr;
this_observed->m_KeyboardPaths.clear();
}
void RemoveWnd(CPWL_Wnd* pWnd) {
if (pWnd == m_pOwnerWnd) {
m_pOwnerWnd = nullptr;
}
if (pWnd == m_pMainKeyboardWnd) {
m_pMainKeyboardWnd = nullptr;
}
auto mouse_it = std::find(m_MousePaths.begin(), m_MousePaths.end(), pWnd);
if (mouse_it != m_MousePaths.end()) {
m_MousePaths.erase(mouse_it);
}
auto keyboard_it =
std::find(m_KeyboardPaths.begin(), m_KeyboardPaths.end(), pWnd);
if (keyboard_it != m_KeyboardPaths.end()) {
m_KeyboardPaths.erase(keyboard_it);
}
}
private:
UnownedPtr<const CPWL_Wnd> m_pOwnerWnd;
UnownedPtr<const CPWL_Wnd> m_pMainKeyboardWnd;
std::vector<UnownedPtr<CPWL_Wnd>> m_MousePaths;
std::vector<UnownedPtr<CPWL_Wnd>> m_KeyboardPaths;
};
// static
bool CPWL_Wnd::IsSHIFTKeyDown(Mask<FWL_EVENTFLAG> nFlag) {
return !!(nFlag & FWL_EVENTFLAG_ShiftKey);
}
// static
bool CPWL_Wnd::IsCTRLKeyDown(Mask<FWL_EVENTFLAG> nFlag) {
return !!(nFlag & FWL_EVENTFLAG_ControlKey);
}
// static
bool CPWL_Wnd::IsALTKeyDown(Mask<FWL_EVENTFLAG> nFlag) {
return !!(nFlag & FWL_EVENTFLAG_AltKey);
}
// static
bool CPWL_Wnd::IsMETAKeyDown(Mask<FWL_EVENTFLAG> nFlag) {
return !!(nFlag & FWL_EVENTFLAG_MetaKey);
}
// static
bool CPWL_Wnd::IsPlatformShortcutKey(Mask<FWL_EVENTFLAG> nFlag) {
#if BUILDFLAG(IS_APPLE)
return IsMETAKeyDown(nFlag);
#else
return IsCTRLKeyDown(nFlag);
#endif
}
CPWL_Wnd::CPWL_Wnd(
const CreateParams& cp,
std::unique_ptr<IPWL_FillerNotify::PerWindowData> pAttachedData)
: m_CreationParams(cp), m_pAttachedData(std::move(pAttachedData)) {}
CPWL_Wnd::~CPWL_Wnd() {
DCHECK(!m_bCreated);
}
void CPWL_Wnd::Realize() {
DCHECK(!m_bCreated);
m_CreationParams.rcRectWnd.Normalize();
m_rcWindow = m_CreationParams.rcRectWnd;
m_rcClip = m_rcWindow;
if (!m_rcClip.IsEmpty()) {
m_rcClip.Inflate(1.0f, 1.0f);
m_rcClip.Normalize();
}
CreateSharedCaptureFocusState();
CreateParams ccp = m_CreationParams;
ccp.dwFlags &= 0xFFFF0000L; // remove sub styles
CreateVScrollBar(ccp);
CreateChildWnd(ccp);
m_bVisible = HasFlag(PWS_VISIBLE);
OnCreated();
if (!RepositionChildWnd()) {
return;
}
m_bCreated = true;
}
void CPWL_Wnd::OnCreated() {}
void CPWL_Wnd::OnDestroy() {}
void CPWL_Wnd::InvalidateProvider(ProviderIface* provider) {
if (m_CreationParams.pProvider.Get() == provider)
m_CreationParams.pProvider.Reset();
}
void CPWL_Wnd::Destroy() {
KillFocus();
OnDestroy();
if (m_bCreated) {
m_pVScrollBar = nullptr;
while (!m_Children.empty()) {
std::unique_ptr<CPWL_Wnd> pChild = std::move(m_Children.back());
m_Children.pop_back();
pChild->Destroy();
}
if (m_pParent)
m_pParent->RemoveChild(this);
m_bCreated = false;
}
DestroySharedCaptureFocusState();
}
bool CPWL_Wnd::Move(const CFX_FloatRect& rcNew, bool bReset, bool bRefresh) {
if (!IsValid())
return true;
CFX_FloatRect rcOld = GetWindowRect();
m_rcWindow = rcNew;
m_rcWindow.Normalize();
if (bReset) {
if (rcOld.left != rcNew.left || rcOld.right != rcNew.right ||
rcOld.top != rcNew.top || rcOld.bottom != rcNew.bottom) {
if (!RepositionChildWnd()) {
return false;
}
}
}
if (bRefresh && !InvalidateRectMove(rcOld, rcNew))
return false;
m_CreationParams.rcRectWnd = m_rcWindow;
return true;
}
bool CPWL_Wnd::InvalidateRectMove(const CFX_FloatRect& rcOld,
const CFX_FloatRect& rcNew) {
CFX_FloatRect rcUnion = rcOld;
rcUnion.Union(rcNew);
return InvalidateRect(&rcUnion);
}
void CPWL_Wnd::DrawAppearance(CFX_RenderDevice* pDevice,
const CFX_Matrix& mtUser2Device) {
if (IsValid() && IsVisible()) {
DrawThisAppearance(pDevice, mtUser2Device);
DrawChildAppearance(pDevice, mtUser2Device);
}
}
void CPWL_Wnd::DrawThisAppearance(CFX_RenderDevice* pDevice,
const CFX_Matrix& mtUser2Device) {
CFX_FloatRect rectWnd = GetWindowRect();
if (rectWnd.IsEmpty())
return;
if (HasFlag(PWS_BACKGROUND)) {
float width = static_cast<float>(GetBorderWidth() + GetInnerBorderWidth());
pDevice->DrawFillRect(&mtUser2Device, rectWnd.GetDeflated(width, width),
GetBackgroundColor(), GetTransparency());
}
if (HasFlag(PWS_BORDER)) {
pDevice->DrawBorder(&mtUser2Device, rectWnd,
static_cast<float>(GetBorderWidth()), GetBorderColor(),
GetBorderLeftTopColor(GetBorderStyle()),
GetBorderRightBottomColor(GetBorderStyle()),
GetBorderStyle(), GetTransparency());
}
}
void CPWL_Wnd::DrawChildAppearance(CFX_RenderDevice* pDevice,
const CFX_Matrix& mtUser2Device) {
for (const auto& pChild : m_Children) {
pChild->DrawAppearance(pDevice, mtUser2Device);
}
}
bool CPWL_Wnd::InvalidateRect(const CFX_FloatRect* pRect) {
ObservedPtr<CPWL_Wnd> this_observed(this);
if (!this_observed->IsValid()) {
return true;
}
CFX_FloatRect rcRefresh = pRect ? *pRect : this_observed->GetWindowRect();
if (!this_observed->HasFlag(PWS_NOREFRESHCLIP)) {
CFX_FloatRect rcClip = this_observed->GetClipRect();
if (!rcClip.IsEmpty())
rcRefresh.Intersect(rcClip);
}
CFX_FloatRect rcWin = this_observed->PWLtoWnd(rcRefresh);
rcWin.Inflate(1, 1);
rcWin.Normalize();
this_observed->GetFillerNotify()->InvalidateRect(
this_observed->m_pAttachedData.get(), rcWin);
return !!this_observed;
}
bool CPWL_Wnd::OnKeyDown(FWL_VKEYCODE nKeyCode, Mask<FWL_EVENTFLAG> nFlag) {
if (!IsValid() || !IsVisible())
return false;
if (!IsWndCaptureKeyboard(this))
return false;
for (const auto& pChild : m_Children) {
if (IsWndCaptureKeyboard(pChild.get()))
return pChild->OnKeyDown(nKeyCode, nFlag);
}
return false;
}
bool CPWL_Wnd::OnChar(uint16_t nChar, Mask<FWL_EVENTFLAG> nFlag) {
if (!IsValid() || !IsVisible())
return false;
if (!IsWndCaptureKeyboard(this))
return false;
for (const auto& pChild : m_Children) {
if (IsWndCaptureKeyboard(pChild.get()))
return pChild->OnChar(nChar, nFlag);
}
return false;
}
#define PWL_IMPLEMENT_MOUSE_METHOD(mouse_method_name) \
bool CPWL_Wnd::mouse_method_name(Mask<FWL_EVENTFLAG> nFlag, \
const CFX_PointF& point) { \
if (!IsValid() || !IsVisible()) \
return false; \
if (IsWndCaptureMouse(this)) { \
for (const auto& pChild : m_Children) { \
if (IsWndCaptureMouse(pChild.get())) { \
return pChild->mouse_method_name(nFlag, point); \
} \
} \
SetCursor(); \
return false; \
} \
for (const auto& pChild : m_Children) { \
if (pChild->WndHitTest(point)) { \
return pChild->mouse_method_name(nFlag, point); \
} \
} \
if (WndHitTest(point)) \
SetCursor(); \
return false; \
}
PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonDblClk)
PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonDown)
PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonUp)
PWL_IMPLEMENT_MOUSE_METHOD(OnMouseMove)
#undef PWL_IMPLEMENT_MOUSE_METHOD
// Unlike their FWL counterparts, PWL windows don't handle right clicks.
bool CPWL_Wnd::OnRButtonDown(Mask<FWL_EVENTFLAG> nFlag,
const CFX_PointF& point) {
return false;
}
bool CPWL_Wnd::OnRButtonUp(Mask<FWL_EVENTFLAG> nFlag, const CFX_PointF& point) {
return false;
}
WideString CPWL_Wnd::GetText() {
return WideString();
}
WideString CPWL_Wnd::GetSelectedText() {
return WideString();
}
void CPWL_Wnd::ReplaceAndKeepSelection(const WideString& text) {}
void CPWL_Wnd::ReplaceSelection(const WideString& text) {}
bool CPWL_Wnd::SelectAllText() {
return false;
}
bool CPWL_Wnd::CanUndo() {
return false;
}
bool CPWL_Wnd::CanRedo() {
return false;
}
bool CPWL_Wnd::Undo() {
return false;
}
bool CPWL_Wnd::Redo() {
return false;
}
bool CPWL_Wnd::OnMouseWheel(Mask<FWL_EVENTFLAG> nFlag,
const CFX_PointF& point,
const CFX_Vector& delta) {
if (!IsValid() || !IsVisible())
return false;
SetCursor();
if (!IsWndCaptureKeyboard(this))
return false;
for (const auto& pChild : m_Children) {
if (IsWndCaptureKeyboard(pChild.get()))
return pChild->OnMouseWheel(nFlag, point, delta);
}
return false;
}
void CPWL_Wnd::AddChild(std::unique_ptr<CPWL_Wnd> pWnd) {
DCHECK(!pWnd->m_pParent);
pWnd->m_pParent = this;
m_Children.push_back(std::move(pWnd));
}
void CPWL_Wnd::RemoveChild(CPWL_Wnd* pWnd) {
DCHECK_EQ(pWnd->m_pParent, this);
auto it =
std::find(m_Children.begin(), m_Children.end(), MakeFakeUniquePtr(pWnd));
if (it == m_Children.end())
return;
// TODO(tsepez): murky ownership.
it->release();
m_Children.erase(it);
}
void CPWL_Wnd::SetScrollInfo(const PWL_SCROLL_INFO& info) {}
void CPWL_Wnd::SetScrollPosition(float pos) {}
void CPWL_Wnd::ScrollWindowVertically(float pos) {}
void CPWL_Wnd::NotifyLButtonDown(CPWL_Wnd* child, const CFX_PointF& pos) {}
void CPWL_Wnd::NotifyLButtonUp(CPWL_Wnd* child, const CFX_PointF& pos) {}
void CPWL_Wnd::NotifyMouseMove(CPWL_Wnd* child, const CFX_PointF& pos) {}
CFX_FloatRect CPWL_Wnd::GetWindowRect() const {
return m_rcWindow;
}
CFX_FloatRect CPWL_Wnd::GetClientRect() const {
CFX_FloatRect rcWindow = GetWindowRect();
float width = static_cast<float>(GetBorderWidth() + GetInnerBorderWidth());
CFX_FloatRect rcClient = rcWindow.GetDeflated(width, width);
if (CPWL_ScrollBar* pVSB = GetVScrollBar())
rcClient.right -= pVSB->GetScrollBarWidth();
rcClient.Normalize();
return rcWindow.Contains(rcClient) ? rcClient : CFX_FloatRect();
}
CFX_PointF CPWL_Wnd::GetCenterPoint() const {
CFX_FloatRect rcClient = GetClientRect();
return CFX_PointF((rcClient.left + rcClient.right) * 0.5f,
(rcClient.top + rcClient.bottom) * 0.5f);
}
bool CPWL_Wnd::HasFlag(uint32_t dwFlags) const {
return (m_CreationParams.dwFlags & dwFlags) != 0;
}
void CPWL_Wnd::RemoveFlag(uint32_t dwFlags) {
m_CreationParams.dwFlags &= ~dwFlags;
}
CFX_Color CPWL_Wnd::GetBackgroundColor() const {
return m_CreationParams.sBackgroundColor;
}
CFX_Color CPWL_Wnd::GetTextColor() const {
return m_CreationParams.sTextColor;
}
BorderStyle CPWL_Wnd::GetBorderStyle() const {
return m_CreationParams.nBorderStyle;
}
int32_t CPWL_Wnd::GetBorderWidth() const {
return HasFlag(PWS_BORDER) ? m_CreationParams.dwBorderWidth : 0;
}
int32_t CPWL_Wnd::GetInnerBorderWidth() const {
return 0;
}
CFX_Color CPWL_Wnd::GetBorderColor() const {
return HasFlag(PWS_BORDER) ? m_CreationParams.sBorderColor : CFX_Color();
}
const CPWL_Dash& CPWL_Wnd::GetBorderDash() const {
return m_CreationParams.sDash;
}
CPWL_ScrollBar* CPWL_Wnd::GetVScrollBar() const {
return HasFlag(PWS_VSCROLL) ? m_pVScrollBar : nullptr;
}
void CPWL_Wnd::CreateVScrollBar(const CreateParams& cp) {
if (m_pVScrollBar || !HasFlag(PWS_VSCROLL))
return;
CreateParams scp = cp;
scp.dwFlags = PWS_BACKGROUND | PWS_AUTOTRANSPARENT | PWS_NOREFRESHCLIP;
scp.sBackgroundColor = kDefaultWhiteColor;
scp.eCursorType = IPWL_FillerNotify::CursorStyle::kArrow;
scp.nTransparency = CPWL_ScrollBar::kTransparency;
auto pBar = std::make_unique<CPWL_ScrollBar>(scp, CloneAttachedData());
m_pVScrollBar = pBar.get();
AddChild(std::move(pBar));
m_pVScrollBar->Realize();
}
void CPWL_Wnd::SetCapture() {
if (SharedCaptureFocusState* pSharedState = GetSharedCaptureFocusState()) {
pSharedState->SetCapture(this);
}
}
void CPWL_Wnd::ReleaseCapture() {
for (const auto& pChild : m_Children)
pChild->ReleaseCapture();
if (SharedCaptureFocusState* pSharedState = GetSharedCaptureFocusState()) {
pSharedState->ReleaseCapture();
}
}
void CPWL_Wnd::SetFocus() {
if (SharedCaptureFocusState* pSharedState = GetSharedCaptureFocusState()) {
if (!pSharedState->IsMainCaptureKeyboard(this)) {
pSharedState->ReleaseFocus();
}
pSharedState->SetFocus(this);
}
}
void CPWL_Wnd::KillFocus() {
if (SharedCaptureFocusState* pSharedState = GetSharedCaptureFocusState()) {
if (pSharedState->IsWndCaptureKeyboard(this)) {
pSharedState->ReleaseFocus();
}
}
}
void CPWL_Wnd::OnSetFocus() {}
void CPWL_Wnd::OnKillFocus() {}
std::unique_ptr<IPWL_FillerNotify::PerWindowData> CPWL_Wnd::CloneAttachedData()
const {
return m_pAttachedData ? m_pAttachedData->Clone() : nullptr;
}
std::vector<UnownedPtr<CPWL_Wnd>> CPWL_Wnd::GetAncestors() {
std::vector<UnownedPtr<CPWL_Wnd>> results;
for (CPWL_Wnd* pWnd = this; pWnd; pWnd = pWnd->GetParentWindow()) {
results.emplace_back(pWnd);
}
return results;
}
bool CPWL_Wnd::WndHitTest(const CFX_PointF& point) const {
return IsValid() && IsVisible() && GetWindowRect().Contains(point);
}
bool CPWL_Wnd::ClientHitTest(const CFX_PointF& point) const {
return IsValid() && IsVisible() && GetClientRect().Contains(point);
}
bool CPWL_Wnd::SetVisible(bool bVisible) {
ObservedPtr<CPWL_Wnd> this_observed(this);
if (!this_observed->IsValid()) {
return true;
}
for (const auto& pChild : this_observed->m_Children) {
if (!pChild->SetVisible(bVisible)) {
return false;
}
if (!this_observed) {
return false;
}
}
if (bVisible != this_observed->m_bVisible) {
this_observed->m_bVisible = bVisible;
if (!this_observed->RepositionChildWnd()) {
return false;
}
if (!this_observed->InvalidateRect(nullptr)) {
return false;
}
}
return true;
}
void CPWL_Wnd::SetClipRect(const CFX_FloatRect& rect) {
m_rcClip = rect;
m_rcClip.Normalize();
}
const CFX_FloatRect& CPWL_Wnd::GetClipRect() const {
return m_rcClip;
}
bool CPWL_Wnd::IsReadOnly() const {
return HasFlag(PWS_READONLY);
}
bool CPWL_Wnd::RepositionChildWnd() {
ObservedPtr<CPWL_Wnd> this_observed(this);
CPWL_ScrollBar* pVSB = this_observed->GetVScrollBar();
if (!pVSB) {
return true;
}
CFX_FloatRect rcContent = this_observed->GetWindowRect();
if (!rcContent.IsEmpty()) {
float width = static_cast<float>(this_observed->GetBorderWidth() +
this_observed->GetInnerBorderWidth());
rcContent.Deflate(width, width);
rcContent.Normalize();
}
CFX_FloatRect rcVScroll =
CFX_FloatRect(rcContent.right - CPWL_ScrollBar::kWidth, rcContent.bottom,
rcContent.right - 1.0f, rcContent.top);
pVSB->Move(rcVScroll, true, false);
return !!this_observed;
}
void CPWL_Wnd::CreateChildWnd(const CreateParams& cp) {}
void CPWL_Wnd::SetCursor() {
if (IsValid())
GetFillerNotify()->SetCursor(GetCreationParams()->eCursorType);
}
void CPWL_Wnd::CreateSharedCaptureFocusState() {
if (!m_CreationParams.pSharedCaptureFocusState) {
m_CreationParams.pSharedCaptureFocusState =
new SharedCaptureFocusState(this);
}
}
void CPWL_Wnd::DestroySharedCaptureFocusState() {
SharedCaptureFocusState* pSharedCaptureFocusState =
GetSharedCaptureFocusState();
if (!pSharedCaptureFocusState) {
return;
}
const bool owned = pSharedCaptureFocusState->IsOwnedByWnd(this);
pSharedCaptureFocusState->RemoveWnd(this);
if (owned) {
delete pSharedCaptureFocusState;
}
}
CPWL_Wnd::SharedCaptureFocusState* CPWL_Wnd::GetSharedCaptureFocusState()
const {
return m_CreationParams.pSharedCaptureFocusState;
}
bool CPWL_Wnd::IsCaptureMouse() const {
return IsWndCaptureMouse(this);
}
bool CPWL_Wnd::IsWndCaptureMouse(const CPWL_Wnd* pWnd) const {
SharedCaptureFocusState* pCtrl = GetSharedCaptureFocusState();
return pCtrl && pCtrl->IsWndCaptureMouse(pWnd);
}
bool CPWL_Wnd::IsWndCaptureKeyboard(const CPWL_Wnd* pWnd) const {
SharedCaptureFocusState* pCtrl = GetSharedCaptureFocusState();
return pCtrl && pCtrl->IsWndCaptureKeyboard(pWnd);
}
bool CPWL_Wnd::IsFocused() const {
SharedCaptureFocusState* pCtrl = GetSharedCaptureFocusState();
return pCtrl && pCtrl->IsMainCaptureKeyboard(this);
}
CFX_FloatRect CPWL_Wnd::GetFocusRect() const {
CFX_FloatRect rect = GetWindowRect();
if (!rect.IsEmpty()) {
rect.Inflate(1.0f, 1.0f);
rect.Normalize();
}
return rect;
}
float CPWL_Wnd::GetFontSize() const {
return m_CreationParams.fFontSize;
}
void CPWL_Wnd::SetFontSize(float fFontSize) {
m_CreationParams.fFontSize = fFontSize;
}
CFX_Color CPWL_Wnd::GetBorderLeftTopColor(BorderStyle nBorderStyle) const {
switch (nBorderStyle) {
case BorderStyle::kBeveled:
return CFX_Color(CFX_Color::Type::kGray, 1);
case BorderStyle::kInset:
return CFX_Color(CFX_Color::Type::kGray, 0.5f);
default:
return CFX_Color();
}
}
CFX_Color CPWL_Wnd::GetBorderRightBottomColor(BorderStyle nBorderStyle) const {
switch (nBorderStyle) {
case BorderStyle::kBeveled:
return GetBackgroundColor() / 2.0f;
case BorderStyle::kInset:
return CFX_Color(CFX_Color::Type::kGray, 0.75f);
default:
return CFX_Color();
}
}
int32_t CPWL_Wnd::GetTransparency() {
return m_CreationParams.nTransparency;
}
void CPWL_Wnd::SetTransparency(int32_t nTransparency) {
for (const auto& pChild : m_Children)
pChild->SetTransparency(nTransparency);
m_CreationParams.nTransparency = nTransparency;
}
CFX_Matrix CPWL_Wnd::GetWindowMatrix() const {
CFX_Matrix mt;
if (ProviderIface* pProvider = GetProvider())
mt.Concat(pProvider->GetWindowMatrix(GetAttachedData()));
return mt;
}
CFX_FloatRect CPWL_Wnd::PWLtoWnd(const CFX_FloatRect& rect) const {
CFX_Matrix mt = GetWindowMatrix();
return mt.TransformRect(rect);
}