From 1770c021cf998ff1b33855b1397f6ea8ff9f7cd7 Mon Sep 17 00:00:00 2001 From: Dan Sinclair Date: Mon, 14 Mar 2016 14:14:16 -0400 Subject: Move xfa/src up to xfa/. This CL moves the xfa/src files up to the xfa/ directory and fixes the includes, include guards, and build files. R=tsepez@chromium.org Review URL: https://codereview.chromium.org/1803723002 . --- xfa/fwl/theme/barcodetp.cpp | 42 ++ xfa/fwl/theme/carettp.cpp | 49 ++ xfa/fwl/theme/checkboxtp.cpp | 532 ++++++++++++++++++++++ xfa/fwl/theme/comboboxtp.cpp | 156 +++++++ xfa/fwl/theme/datetimepickertp.cpp | 138 ++++++ xfa/fwl/theme/edittp.cpp | 89 ++++ xfa/fwl/theme/formtp.cpp | 893 +++++++++++++++++++++++++++++++++++++ xfa/fwl/theme/listboxtp.cpp | 101 +++++ xfa/fwl/theme/monthcalendartp.cpp | 582 ++++++++++++++++++++++++ xfa/fwl/theme/pictureboxtp.cpp | 36 ++ xfa/fwl/theme/pushbuttontp.cpp | 157 +++++++ xfa/fwl/theme/scrollbartp.cpp | 377 ++++++++++++++++ xfa/fwl/theme/widgettp.cpp | 840 ++++++++++++++++++++++++++++++++++ 13 files changed, 3992 insertions(+) create mode 100644 xfa/fwl/theme/barcodetp.cpp create mode 100644 xfa/fwl/theme/carettp.cpp create mode 100644 xfa/fwl/theme/checkboxtp.cpp create mode 100644 xfa/fwl/theme/comboboxtp.cpp create mode 100644 xfa/fwl/theme/datetimepickertp.cpp create mode 100644 xfa/fwl/theme/edittp.cpp create mode 100644 xfa/fwl/theme/formtp.cpp create mode 100644 xfa/fwl/theme/listboxtp.cpp create mode 100644 xfa/fwl/theme/monthcalendartp.cpp create mode 100644 xfa/fwl/theme/pictureboxtp.cpp create mode 100644 xfa/fwl/theme/pushbuttontp.cpp create mode 100644 xfa/fwl/theme/scrollbartp.cpp create mode 100644 xfa/fwl/theme/widgettp.cpp (limited to 'xfa/fwl/theme') diff --git a/xfa/fwl/theme/barcodetp.cpp b/xfa/fwl/theme/barcodetp.cpp new file mode 100644 index 0000000000..477ce99d9b --- /dev/null +++ b/xfa/fwl/theme/barcodetp.cpp @@ -0,0 +1,42 @@ +// 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 "xfa/include/fwl/theme/barcodetp.h" + +#include "xfa/include/fwl/basewidget/fwl_barcode.h" +#include "xfa/include/fwl/core/fwl_theme.h" +#include "xfa/include/fwl/core/fwl_widget.h" + +CFWL_BarcodeTP::CFWL_BarcodeTP() {} +CFWL_BarcodeTP::~CFWL_BarcodeTP() {} + +FX_BOOL CFWL_BarcodeTP::IsValidWidget(IFWL_Widget* pWidget) { + if (!pWidget) + return FALSE; + return pWidget->GetClassID() == FWL_CLASSHASH_Barcode; +} +FX_BOOL CFWL_BarcodeTP::DrawBackground(CFWL_ThemeBackground* pParams) { + if (!pParams) + return FALSE; + switch (pParams->m_iPart) { + case FWL_PART_BCD_Border: { + DrawBorder(pParams->m_pGraphics, &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_BCD_Edge: { + DrawEdge(pParams->m_pGraphics, pParams->m_pWidget->GetStyles(), + &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_BCD_Background: { + FillBackground(pParams->m_pGraphics, &pParams->m_rtPart, + &pParams->m_matrix); + break; + } + default: {} + } + return TRUE; +} diff --git a/xfa/fwl/theme/carettp.cpp b/xfa/fwl/theme/carettp.cpp new file mode 100644 index 0000000000..88b01d9f3d --- /dev/null +++ b/xfa/fwl/theme/carettp.cpp @@ -0,0 +1,49 @@ +// 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 "xfa/include/fwl/theme/carettp.h" + +#include "xfa/include/fwl/basewidget/fwl_caret.h" +#include "xfa/include/fwl/core/fwl_widget.h" + +CFWL_CaretTP::CFWL_CaretTP() {} +CFWL_CaretTP::~CFWL_CaretTP() {} + +FX_BOOL CFWL_CaretTP::IsValidWidget(IFWL_Widget* pWidget) { + if (!pWidget) + return FALSE; + return pWidget->GetClassID() == FWL_CLASSHASH_Caret; +} +FX_BOOL CFWL_CaretTP::DrawBackground(CFWL_ThemeBackground* pParams) { + if (!pParams) + return FALSE; + switch (pParams->m_iPart) { + case FWL_PART_CAT_Background: { + if (!(pParams->m_dwStates & FWL_PARTSTATE_CAT_HightLight)) { + return TRUE; + } + DrawCaretBK(pParams->m_pGraphics, pParams->m_dwStates, + &(pParams->m_rtPart), (CFX_Color*)pParams->m_pData, + &(pParams->m_matrix)); + break; + } + } + return TRUE; +} +void CFWL_CaretTP::DrawCaretBK(CFX_Graphics* pGraphics, + FX_DWORD dwStates, + const CFX_RectF* pRect, + CFX_Color* crFill, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + CFX_Color crFilltemp; + crFill ? crFilltemp = *crFill : crFilltemp = ArgbEncode(255, 0, 0, 0); + CFX_RectF rect = *pRect; + path.AddRectangle(rect.left, rect.top, rect.width, rect.height); + pGraphics->SetFillColor(&crFilltemp); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); +} diff --git a/xfa/fwl/theme/checkboxtp.cpp b/xfa/fwl/theme/checkboxtp.cpp new file mode 100644 index 0000000000..b65a550936 --- /dev/null +++ b/xfa/fwl/theme/checkboxtp.cpp @@ -0,0 +1,532 @@ +// 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 "xfa/include/fwl/theme/checkboxtp.h" + +#include "xfa/fde/tto/fde_textout.h" +#include "xfa/include/fwl/basewidget/fwl_checkbox.h" +#include "xfa/include/fwl/core/fwl_widget.h" + +#define CHECKBOX_SIZE_SIGNMARGIN 3 +#define CHECKBOX_SIZE_SIGNBORDER 2 +#define CHECKBOX_SIZE_SIGNPATH 100 +#define CHECKBOX_COLOR_BOXLT1 (ArgbEncode(255, 172, 168, 153)) +#define CHECKBOX_COLOR_BOXLT2 (ArgbEncode(255, 113, 111, 100)) +#define CHECKBOX_COLOR_BOXRB1 (ArgbEncode(255, 241, 239, 226)) +#define CHECKBOX_COLOR_BOXRB2 (ArgbEncode(255, 255, 255, 255)) +#define CHECKBOX_FXGE_CoordinatesAdjust + +CFWL_CheckBoxTP::CFWL_CheckBoxTP() : m_pCheckPath(NULL) { + m_pThemeData = new CKBThemeData; + SetThemeData(0); +} +CFWL_CheckBoxTP::~CFWL_CheckBoxTP() { + if (m_pThemeData) { + delete m_pThemeData; + m_pThemeData = NULL; + } + if (m_pCheckPath) { + m_pCheckPath->Clear(); + delete m_pCheckPath; + m_pCheckPath = NULL; + } +} +FX_BOOL CFWL_CheckBoxTP::IsValidWidget(IFWL_Widget* pWidget) { + return pWidget && pWidget->GetClassID() == FWL_CLASSHASH_CheckBox; +} +FX_DWORD CFWL_CheckBoxTP::SetThemeID(IFWL_Widget* pWidget, + FX_DWORD dwThemeID, + FX_BOOL bChildren) { + if (m_pThemeData) { + SetThemeData(FWL_GetThemeColor(dwThemeID)); + } + return CFWL_WidgetTP::SetThemeID(pWidget, dwThemeID, bChildren); +} +FX_BOOL CFWL_CheckBoxTP::DrawText(CFWL_ThemeText* pParams) { + if (!m_pTextOut) + return FALSE; + m_pTextOut->SetTextColor((pParams->m_dwStates & FWL_PARTSTATE_CKB_Mask1) == + FWL_PARTSTATE_CKB_Disabled + ? FWLTHEME_CAPACITY_TextDisColor + : FWLTHEME_CAPACITY_TextColor); + return CFWL_WidgetTP::DrawText(pParams); +} +FX_BOOL CFWL_CheckBoxTP::DrawBackground(CFWL_ThemeBackground* pParams) { + if (!pParams) + return FALSE; + switch (pParams->m_iPart) { + case FWL_PART_CKB_Border: { + DrawBorder(pParams->m_pGraphics, &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_CKB_Edge: { + DrawEdge(pParams->m_pGraphics, pParams->m_pWidget->GetStyles(), + &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_CKB_Background: { + FillBackground(pParams->m_pGraphics, &pParams->m_rtPart, + &pParams->m_matrix); + if (pParams->m_dwStates & FWL_PARTSTATE_CKB_Focused) { + pParams->m_rtPart = *(CFX_RectF*)pParams->m_pData; + DrawFocus(pParams->m_pGraphics, &pParams->m_rtPart, &pParams->m_matrix); + } + break; + } + case FWL_PART_CKB_CheckBox: { + DrawBoxBk(pParams->m_pWidget, pParams->m_pGraphics, &pParams->m_rtPart, + pParams->m_dwStates, &pParams->m_matrix); + if (((pParams->m_dwStates & FWL_PARTSTATE_CKB_Mask2) == + FWL_PARTSTATE_CKB_Checked) | + ((pParams->m_dwStates & FWL_PARTSTATE_CKB_Mask2) == + FWL_PARTSTATE_CKB_Neutral)) { + DrawSign(pParams->m_pWidget, pParams->m_pGraphics, &pParams->m_rtPart, + pParams->m_dwStates, &pParams->m_matrix); + } + FX_BOOL bDisable = (pParams->m_dwStates & FWL_PARTSTATE_CKB_Mask1) == + FWL_PARTSTATE_CKB_Disabled; + DrawSignBorder(pParams->m_pWidget, pParams->m_pGraphics, + &pParams->m_rtPart, bDisable, &pParams->m_matrix); + break; + } + default: { return FALSE; } + } + return TRUE; +} +FWL_ERR CFWL_CheckBoxTP::Initialize() { + InitTTO(); + return CFWL_WidgetTP::Initialize(); +} +FWL_ERR CFWL_CheckBoxTP::Finalize() { + FinalizeTTO(); + return CFWL_WidgetTP::Finalize(); +} +void CFWL_CheckBoxTP::DrawBoxBk(IFWL_Widget* pWidget, + CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FX_DWORD dwStates, + CFX_Matrix* pMatrix) { + dwStates &= 0x03; + int32_t fillMode = FXFILL_WINDING; + FX_DWORD dwStyleEx = pWidget->GetStylesEx(); + dwStyleEx &= FWL_STYLEEXT_CKB_ShapeMask; + CFX_Path path; + path.Create(); + FX_FLOAT fRight = pRect->right(); + FX_FLOAT fBottom = pRect->bottom(); + FX_BOOL bClipSign = + (dwStates & FWL_PARTSTATE_CKB_Mask1) == FWL_PARTSTATE_CKB_Hovered; + if ((dwStyleEx == FWL_STYLEEXT_CKB_ShapeSolidSquare) || + (dwStyleEx == FWL_STYLEEXT_CKB_ShapeSunkenSquare)) { + path.AddRectangle(pRect->left, pRect->top, pRect->width, pRect->height); + if (bClipSign) { + fillMode = FXFILL_ALTERNATE; + path.AddRectangle(pRect->left + CHECKBOX_SIZE_SIGNMARGIN, + pRect->top + CHECKBOX_SIZE_SIGNMARGIN, + pRect->width - CHECKBOX_SIZE_SIGNMARGIN * 2, + pRect->height - CHECKBOX_SIZE_SIGNMARGIN * 2); + } + } else { +#ifdef CHECKBOX_FXGE_CoordinatesAdjust + CFX_RectF rect(*pRect); + rect.Deflate(0, 0, 1, 1); + path.AddEllipse(rect); +#else + path.AddEllipse(*pRect); +#endif + if (bClipSign) { + fillMode = FXFILL_ALTERNATE; +#ifdef CHECKBOX_FXGE_CoordinatesAdjust + CFX_RectF rtClip(rect); +#else + CFX_RectF rtClip(*pRect); +#endif + rtClip.Deflate(CHECKBOX_SIZE_SIGNMARGIN - 1, + CHECKBOX_SIZE_SIGNMARGIN - 1); + path.AddEllipse(rtClip); + } + } + int32_t iTheme = 1; + if ((dwStates & FWL_PARTSTATE_CKB_Mask1) == FWL_PARTSTATE_CKB_Hovered) { + iTheme = 2; + } else if ((dwStates & FWL_PARTSTATE_CKB_Mask1) == + FWL_PARTSTATE_CKB_Pressed) { + iTheme = 3; + } else if ((dwStates & FWL_PARTSTATE_CKB_Mask1) == + FWL_PARTSTATE_CKB_Disabled) { + iTheme = 4; + } + if ((dwStates & FWL_PARTSTATE_CKB_Mask2) == FWL_PARTSTATE_CKB_Checked) { + iTheme += 4; + } else if ((dwStates & FWL_PARTSTATE_CKB_Mask2) == + FWL_PARTSTATE_CKB_Neutral) { + iTheme += 8; + } + DrawAxialShading(pGraphics, pRect->left - 1, pRect->top - 1, fRight, fBottom, + m_pThemeData->clrBoxBk[iTheme][0], + m_pThemeData->clrBoxBk[iTheme][1], &path, fillMode, pMatrix); +} +void CFWL_CheckBoxTP::DrawSign(IFWL_Widget* pWidget, + CFX_Graphics* pGraphics, + const CFX_RectF* pRtBox, + FX_DWORD dwStates, + CFX_Matrix* pMatrix) { + CFX_RectF rtSign(*pRtBox); + rtSign.Deflate(CHECKBOX_SIZE_SIGNMARGIN, CHECKBOX_SIZE_SIGNMARGIN); + FX_DWORD dwColor = m_pThemeData->clrSignCheck; + FX_BOOL bCheck = TRUE; + if (((dwStates & FWL_PARTSTATE_CKB_Mask1) == FWL_PARTSTATE_CKB_Disabled) && + ((dwStates & FWL_PARTSTATE_CKB_Mask2) == FWL_PARTSTATE_CKB_Checked)) { + dwColor = m_pThemeData->clrSignBorderDisable; + } else if ((dwStates & FWL_PARTSTATE_CKB_Mask2) == + FWL_PARTSTATE_CKB_Neutral) { + switch (dwStates & FWL_PARTSTATE_CKB_Mask1) { + case FWL_PARTSTATE_CKB_Normal: { + bCheck = FALSE; + dwColor = m_pThemeData->clrSignNeutralNormal; + break; + } + case FWL_PARTSTATE_CKB_Hovered: { + bCheck = FALSE; + dwColor = m_pThemeData->clrSignNeutralHover; + break; + } + case FWL_PARTSTATE_CKB_Pressed: { + bCheck = FALSE, dwColor = m_pThemeData->clrSignNeutralPressed; + break; + } + case FWL_PARTSTATE_CKB_Disabled: { + bCheck = FALSE, dwColor = m_pThemeData->clrSignBorderDisable; + break; + } + } + } + if (bCheck) { + FX_DWORD dwStyle = pWidget->GetStylesEx(); + switch (dwStyle & FWL_STYLEEXT_CKB_SignShapeMask) { + case FWL_STYLEEXT_CKB_SignShapeCheck: { + DrawSignCheck(pGraphics, &rtSign, dwColor, pMatrix); + break; + } + case FWL_STYLEEXT_CKB_SignShapeCircle: { + rtSign.Deflate(1, 1); + DrawSignCircle(pGraphics, &rtSign, dwColor, pMatrix); + break; + } + case FWL_STYLEEXT_CKB_SignShapeCross: { + DrawSignCross(pGraphics, &rtSign, dwColor, pMatrix); + break; + } + case FWL_STYLEEXT_CKB_SignShapeDiamond: { + DrawSignDiamond(pGraphics, &rtSign, dwColor, pMatrix); + break; + } + case FWL_STYLEEXT_CKB_SignShapeSquare: { + DrawSignSquare(pGraphics, &rtSign, dwColor, pMatrix); + break; + } + case FWL_STYLEEXT_CKB_SignShapeStar: { + DrawSignStar(pGraphics, &rtSign, dwColor, pMatrix); + break; + } + } + } else { + FillSoildRect(pGraphics, ArgbEncode(255, 33, 161, 33), &rtSign, pMatrix); + } +} +void CFWL_CheckBoxTP::DrawSignNeutral(CFX_Graphics* pGraphics, + const CFX_RectF* pRtSign, + CFX_Matrix* pMatrix) { + ((CFX_RectF*)pRtSign)->Inflate(-3, -3); + FillSoildRect(pGraphics, m_pThemeData->clrSignNeutral, pRtSign, pMatrix); +} +void CFWL_CheckBoxTP::DrawSignCheck(CFX_Graphics* pGraphics, + const CFX_RectF* pRtSign, + FX_ARGB argbFill, + CFX_Matrix* pMatrix) { + if (!m_pCheckPath) { + initCheckPath(pRtSign->width); + } + CFX_Matrix mt; + mt.SetIdentity(); + mt.Translate(pRtSign->left, pRtSign->top); + mt.Concat(*pMatrix); + CFX_Color crFill(argbFill); + pGraphics->SaveGraphState(); + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(m_pCheckPath, FXFILL_WINDING, &mt); + pGraphics->RestoreGraphState(); +} +void CFWL_CheckBoxTP::DrawSignCircle(CFX_Graphics* pGraphics, + const CFX_RectF* pRtSign, + FX_ARGB argbFill, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + path.AddEllipse(*pRtSign); + CFX_Color crFill(argbFill); + pGraphics->SaveGraphState(); + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_CheckBoxTP::DrawSignCross(CFX_Graphics* pGraphics, + const CFX_RectF* pRtSign, + FX_ARGB argbFill, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + FX_FLOAT fRight = pRtSign->right(); + FX_FLOAT fBottom = pRtSign->bottom(); + path.AddLine(pRtSign->left, pRtSign->top, fRight, fBottom); + path.AddLine(pRtSign->left, fBottom, fRight, pRtSign->top); + CFX_Color crFill(argbFill); + pGraphics->SaveGraphState(); + pGraphics->SetStrokeColor(&crFill); + pGraphics->SetLineWidth(1.0f); + pGraphics->StrokePath(&path, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_CheckBoxTP::DrawSignDiamond(CFX_Graphics* pGraphics, + const CFX_RectF* pRtSign, + FX_ARGB argbFill, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + FX_FLOAT fWidth = pRtSign->width; + FX_FLOAT fHeight = pRtSign->height; + FX_FLOAT fBottom = pRtSign->bottom(); + path.MoveTo(pRtSign->left + fWidth / 2, pRtSign->top); + path.LineTo(pRtSign->left, pRtSign->top + fHeight / 2); + path.LineTo(pRtSign->left + fWidth / 2, fBottom); + path.LineTo(pRtSign->right(), pRtSign->top + fHeight / 2); + path.LineTo(pRtSign->left + fWidth / 2, pRtSign->top); + CFX_Color crFill(argbFill); + pGraphics->SaveGraphState(); + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_CheckBoxTP::DrawSignSquare(CFX_Graphics* pGraphics, + const CFX_RectF* pRtSign, + FX_ARGB argbFill, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + path.AddRectangle(pRtSign->left, pRtSign->top, pRtSign->width, + pRtSign->height); + CFX_Color crFill(argbFill); + pGraphics->SaveGraphState(); + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_CheckBoxTP::DrawSignStar(CFX_Graphics* pGraphics, + const CFX_RectF* pRtSign, + FX_ARGB argbFill, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + FX_FLOAT fBottom = pRtSign->bottom(); + FX_FLOAT fRadius = + (pRtSign->top - fBottom) / (1 + (FX_FLOAT)cos(FX_PI / 5.0f)); + CFX_PointF ptCenter((pRtSign->left + pRtSign->right()) / 2.0f, + (pRtSign->top + fBottom) / 2.0f); + FX_FLOAT px[5], py[5]; + FX_FLOAT fAngel = FX_PI / 10.0f; + for (int32_t i = 0; i < 5; i++) { + px[i] = ptCenter.x + fRadius * (FX_FLOAT)cos(fAngel); + py[i] = ptCenter.y + fRadius * (FX_FLOAT)sin(fAngel); + fAngel += FX_PI * 2 / 5.0f; + } + path.MoveTo(px[0], py[0]); + int32_t nNext = 0; + for (int32_t j = 0; j < 5; j++) { + nNext += 2; + if (nNext >= 5) { + nNext -= 5; + } + path.LineTo(px[nNext], py[nNext]); + } + CFX_Color crFill(argbFill); + pGraphics->SaveGraphState(); + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_CheckBoxTP::DrawSignBorder(IFWL_Widget* pWidget, + CFX_Graphics* pGraphics, + const CFX_RectF* pRtBox, + FX_BOOL bDisable, + CFX_Matrix* pMatrix) { + switch (pWidget->GetStylesEx() & FWL_STYLEEXT_CKB_ShapeMask) { + case FWL_STYLEEXT_CKB_ShapeSolidSquare: { + DrawAnnulusRect(pGraphics, bDisable ? m_pThemeData->clrSignBorderDisable + : m_pThemeData->clrSignBorderNormal, + pRtBox, 1, pMatrix); + break; + } + case FWL_STYLEEXT_CKB_ShapeSunkenSquare: { + Draw3DRect(pGraphics, FWLTHEME_EDGE_Sunken, CHECKBOX_SIZE_SIGNBORDER, + pRtBox, CHECKBOX_COLOR_BOXLT1, CHECKBOX_COLOR_BOXLT2, + CHECKBOX_COLOR_BOXRB1, CHECKBOX_COLOR_BOXRB2, pMatrix); + break; + } + case FWL_STYLEEXT_CKB_ShapeSolidCircle: { + DrawAnnulusCircle(pGraphics, bDisable ? m_pThemeData->clrSignBorderDisable + : m_pThemeData->clrSignBorderNormal, + pRtBox, 1, pMatrix); + break; + } + case FWL_STYLEEXT_CKB_ShapeSunkenCircle: { + Draw3DCircle(pGraphics, FWLTHEME_EDGE_Sunken, CHECKBOX_SIZE_SIGNBORDER, + pRtBox, CHECKBOX_COLOR_BOXLT1, CHECKBOX_COLOR_BOXLT2, + CHECKBOX_COLOR_BOXRB1, CHECKBOX_COLOR_BOXRB2, pMatrix); + break; + } + } +} +void CFWL_CheckBoxTP::SetThemeData(FX_DWORD dwID) { + FX_DWORD* pData = (FX_DWORD*)&m_pThemeData->clrBoxBk; + if (dwID) { + *pData++ = 0, *pData++ = 0, *pData++ = ArgbEncode(255, 220, 220, 215), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 240, 207), + *pData++ = ArgbEncode(255, 248, 179, 48), + *pData++ = ArgbEncode(255, 176, 176, 167), + *pData++ = ArgbEncode(255, 241, 239, 239), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 220, 220, 215), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 240, 207), + *pData++ = ArgbEncode(255, 248, 179, 48), + *pData++ = ArgbEncode(255, 176, 176, 167), + *pData++ = ArgbEncode(255, 241, 239, 239), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 220, 220, 215), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 240, 207), + *pData++ = ArgbEncode(255, 248, 179, 48), + *pData++ = ArgbEncode(255, 176, 176, 167), + *pData++ = ArgbEncode(255, 241, 239, 239), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 255, 255); + m_pThemeData->clrSignBorderNormal = ArgbEncode(255, 154, 167, 114); + m_pThemeData->clrSignBorderDisable = ArgbEncode(255, 202, 200, 187); + m_pThemeData->clrSignCheck = ArgbEncode(255, 164, 180, 138); + m_pThemeData->clrSignNeutral = ArgbEncode(2255, 28, 134, 26); + m_pThemeData->clrSignNeutralNormal = ArgbEncode(255, 114, 192, 113); + m_pThemeData->clrSignNeutralHover = ArgbEncode(255, 33, 161, 33); + m_pThemeData->clrSignNeutralPressed = ArgbEncode(255, 28, 134, 26); + } else { + *pData++ = 0, *pData++ = 0, *pData++ = ArgbEncode(255, 220, 220, 215), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 240, 207), + *pData++ = ArgbEncode(255, 248, 179, 48), + *pData++ = ArgbEncode(255, 176, 176, 167), + *pData++ = ArgbEncode(255, 241, 239, 239), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 220, 220, 215), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 240, 207), + *pData++ = ArgbEncode(255, 248, 179, 48), + *pData++ = ArgbEncode(255, 176, 176, 167), + *pData++ = ArgbEncode(255, 241, 239, 239), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 220, 220, 215), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 240, 207), + *pData++ = ArgbEncode(255, 248, 179, 48), + *pData++ = ArgbEncode(255, 176, 176, 167), + *pData++ = ArgbEncode(255, 241, 239, 239), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 255, 255); + m_pThemeData->clrSignBorderNormal = ArgbEncode(255, 28, 81, 128); + m_pThemeData->clrSignBorderDisable = ArgbEncode(255, 202, 200, 187); + m_pThemeData->clrSignCheck = ArgbEncode(255, 28, 81, 128); + m_pThemeData->clrSignNeutral = ArgbEncode(255, 28, 134, 26); + m_pThemeData->clrSignNeutralNormal = ArgbEncode(255, 114, 192, 113); + m_pThemeData->clrSignNeutralHover = ArgbEncode(255, 33, 161, 33); + m_pThemeData->clrSignNeutralPressed = ArgbEncode(255, 28, 134, 26); + } +} +void CFWL_CheckBoxTP::initCheckPath(FX_FLOAT fCheckLen) { + if (!m_pCheckPath) { + m_pCheckPath = new CFX_Path; + m_pCheckPath->Create(); + FX_FLOAT fWidth = CHECKBOX_SIZE_SIGNPATH; + FX_FLOAT fHeight = -CHECKBOX_SIZE_SIGNPATH; + FX_FLOAT fBottom = CHECKBOX_SIZE_SIGNPATH; + CFX_PointF pt1(fWidth / 15.0f, fBottom + fHeight * 2 / 5.0f); + CFX_PointF pt2(fWidth / 4.5f, fBottom + fHeight / 16.0f); + CFX_PointF pt3(fWidth / 3.0f, fBottom); + CFX_PointF pt4(fWidth * 14 / 15.0f, fBottom + fHeight * 15 / 16.0f); + CFX_PointF pt5(fWidth / 3.6f, fBottom + fHeight / 3.5f); + CFX_PointF pt12(fWidth / 7.0f, fBottom + fHeight * 2 / 7.0f); + CFX_PointF pt21(fWidth / 5.0f, fBottom + fHeight / 5.0f); + CFX_PointF pt23(fWidth / 4.4f, fBottom + fHeight * 0 / 16.0f); + CFX_PointF pt32(fWidth / 4.0f, fBottom); + CFX_PointF pt34(fWidth * (1 / 7.0f + 7 / 15.0f), + fBottom + fHeight * 4 / 5.0f); + CFX_PointF pt43(fWidth * (1 / 7.0f + 7 / 15.0f), + fBottom + fHeight * 4 / 5.0f); + CFX_PointF pt45(fWidth * 7 / 15.0f, fBottom + fHeight * 8 / 7.0f); + CFX_PointF pt54(fWidth / 3.4f, fBottom + fHeight / 3.5f); + CFX_PointF pt51(fWidth / 3.6f, fBottom + fHeight / 4.0f); + CFX_PointF pt15(fWidth / 3.5f, fBottom + fHeight * 3.5f / 5.0f); + m_pCheckPath->MoveTo(pt1.x, pt1.y); + FX_FLOAT px1 = pt12.x - pt1.x; + FX_FLOAT py1 = pt12.y - pt1.y; + FX_FLOAT px2 = pt21.x - pt2.x; + FX_FLOAT py2 = pt21.y - pt2.y; + m_pCheckPath->BezierTo(pt1.x + px1 * FWLTHEME_BEZIER, + pt1.y + py1 * FWLTHEME_BEZIER, + pt2.x + px2 * FWLTHEME_BEZIER, + pt2.y + py2 * FWLTHEME_BEZIER, pt2.x, pt2.y); + px1 = pt23.x - pt2.x; + py1 = pt23.y - pt2.y; + px2 = pt32.x - pt3.x; + py2 = pt32.y - pt3.y; + m_pCheckPath->BezierTo(pt2.x + px1 * FWLTHEME_BEZIER, + pt2.y + py1 * FWLTHEME_BEZIER, + pt3.x + px2 * FWLTHEME_BEZIER, + pt3.y + py2 * FWLTHEME_BEZIER, pt3.x, pt3.y); + px1 = pt34.x - pt3.x; + py1 = pt34.y - pt3.y; + px2 = pt43.x - pt4.x; + py2 = pt43.y - pt4.y; + m_pCheckPath->BezierTo(pt3.x + px1 * FWLTHEME_BEZIER, + pt3.y + py1 * FWLTHEME_BEZIER, + pt4.x + px2 * FWLTHEME_BEZIER, + pt4.y + py2 * FWLTHEME_BEZIER, pt4.x, pt4.y); + px1 = pt45.x - pt4.x; + py1 = pt45.y - pt4.y; + px2 = pt54.x - pt5.x; + py2 = pt54.y - pt5.y; + m_pCheckPath->BezierTo(pt4.x + px1 * FWLTHEME_BEZIER, + pt4.y + py1 * FWLTHEME_BEZIER, + pt5.x + px2 * FWLTHEME_BEZIER, + pt5.y + py2 * FWLTHEME_BEZIER, pt5.x, pt5.y); + px1 = pt51.x - pt5.x; + py1 = pt51.y - pt5.y; + px2 = pt15.x - pt1.x; + py2 = pt15.y - pt1.y; + m_pCheckPath->BezierTo(pt5.x + px1 * FWLTHEME_BEZIER, + pt5.y + py1 * FWLTHEME_BEZIER, + pt1.x + px2 * FWLTHEME_BEZIER, + pt1.y + py2 * FWLTHEME_BEZIER, pt1.x, pt1.y); + FX_FLOAT fScale = fCheckLen / CHECKBOX_SIZE_SIGNPATH; + CFX_Matrix mt; + mt.Set(1, 0, 0, 1, 0, 0); + mt.Scale(fScale, fScale); + CFX_PathData* pData = m_pCheckPath->GetPathData(); + pData->Transform(&mt); + } +} diff --git a/xfa/fwl/theme/comboboxtp.cpp b/xfa/fwl/theme/comboboxtp.cpp new file mode 100644 index 0000000000..33be07d44c --- /dev/null +++ b/xfa/fwl/theme/comboboxtp.cpp @@ -0,0 +1,156 @@ +// 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 "xfa/include/fwl/theme/comboboxtp.h" + +#include "xfa/include/fwl/basewidget/fwl_combobox.h" +#include "xfa/include/fwl/core/fwl_widget.h" + +#define FWLTHEME_CAPACITY_ComboFormHandler 8.0f + +CFWL_ComboBoxTP::CFWL_ComboBoxTP() { + m_dwThemeID = 0; +} +CFWL_ComboBoxTP::~CFWL_ComboBoxTP() {} +FX_BOOL CFWL_ComboBoxTP::IsValidWidget(IFWL_Widget* pWidget) { + if (!pWidget) + return FALSE; + return pWidget->GetClassID() == FWL_CLASSHASH_ComboBox; +} +FX_BOOL CFWL_ComboBoxTP::DrawBackground(CFWL_ThemeBackground* pParams) { + if (!pParams) + return FALSE; + switch (pParams->m_iPart) { + case FWL_PART_CMB_Border: { + DrawBorder(pParams->m_pGraphics, &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_CMB_Edge: { + DrawEdge(pParams->m_pGraphics, pParams->m_pWidget->GetStyles(), + &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_CMB_Background: { + CFX_Path path; + path.Create(); + CFX_RectF& rect = pParams->m_rtPart; + path.AddRectangle(rect.left, rect.top, rect.width, rect.height); + CFX_Color cr; + switch (pParams->m_dwStates) { + case FWL_PARTSTATE_CMB_Selected: + cr = FWLTHEME_COLOR_BKSelected; + break; + case FWL_PARTSTATE_CMB_Disabled: + cr = FWLTHEME_COLOR_EDGERB1; + break; + default: + cr = 0xFFFFFFFF; + } + pParams->m_pGraphics->SaveGraphState(); + pParams->m_pGraphics->SetFillColor(&cr); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, &pParams->m_matrix); + pParams->m_pGraphics->RestoreGraphState(); + break; + } + case FWL_PART_CMB_DropDownButton: { + DrawDropDownButton(pParams, pParams->m_dwStates, &pParams->m_matrix); + break; + } + case FWL_PART_CMB_StretcgHandler: { + DrawStrethHandler(pParams, 0, &pParams->m_matrix); + break; + } + default: { return FALSE; } + } + return TRUE; +} +void CFWL_ComboBoxTP::DrawStrethHandler(CFWL_ThemeBackground* pParams, + FX_DWORD dwStates, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + path.AddRectangle(pParams->m_rtPart.left, pParams->m_rtPart.top, + pParams->m_rtPart.width - 1, pParams->m_rtPart.height); + CFX_Color cr(ArgbEncode(0xff, 0xff, 0, 0)); + pParams->m_pGraphics->SetFillColor(&cr); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, &pParams->m_matrix); +} +void* CFWL_ComboBoxTP::GetCapacity(CFWL_ThemePart* pThemePart, + FX_DWORD dwCapacity) { + if (dwCapacity == FWL_WGTCAPACITY_CMB_ComboFormHandler) { + m_fValue = FWLTHEME_CAPACITY_ComboFormHandler; + return &m_fValue; + } + return CFWL_WidgetTP::GetCapacity(pThemePart, dwCapacity); +} +#ifdef THEME_XPSimilar +void CFWL_ComboBoxTP::DrawDropDownButton(CFWL_ThemeBackground* pParams, + FX_DWORD dwStates, + CFX_Matrix* pMatrix) { + FWLTHEME_STATE eState = FWLTHEME_STATE_Normal; + switch (dwStates) { + case FWL_PARTSTATE_CMB_Normal: { + eState = FWLTHEME_STATE_Normal; + break; + } + case FWL_PARTSTATE_CMB_Hovered: { + eState = FWLTHEME_STATE_Hover; + break; + } + case FWL_PARTSTATE_CMB_Pressed: { + eState = FWLTHEME_STATE_Pressed; + break; + } + case FWL_PARTSTATE_CMB_Disabled: { + eState = FWLTHEME_STATE_Disabale; + break; + } + default: {} + } + DrawArrowBtn(pParams->m_pGraphics, &pParams->m_rtPart, + FWLTHEME_DIRECTION_Down, eState, &pParams->m_matrix); +} +#else +void CFWL_ComboBoxTP::DrawDropDownButton(CFWL_ThemeBackground* pParams, + FX_DWORD dwStates, + CFX_Matrix* pMatrix) { + FX_BOOL bPressed = ((pParams->m_dwStates & FWL_CMBPARTSTATE_Pressed) == + FWL_CMBPARTSTATE_Pressed); + FX_FLOAT fWidth = bPressed ? 1.0f : 2.0f; + FWLTHEME_EDGE eType = bPressed ? FWLTHEME_EDGE_Flat : FWLTHEME_EDGE_Raised; + Draw3DRect(pParams->m_pGraphics, eType, fWidth, &pParams->m_rtPart, + FWLTHEME_COLOR_EDGELT1, FWLTHEME_COLOR_EDGELT2, + FWLTHEME_COLOR_EDGERB1, FWLTHEME_COLOR_EDGERB2, pMatrix); + CFX_Path path; + path.Create(); + path.AddRectangle(pParams->m_rtPart.left + fWidth, + pParams->m_rtPart.top + fWidth, + pParams->m_rtPart.width - 2 * fWidth, + pParams->m_rtPart.height - 2 * fWidth); + pParams->m_pGraphics->SaveGraphState(); + CFX_Color crFill(FWLTHEME_COLOR_Background); + pParams->m_pGraphics->SetFillColor(&crFill); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, &pParams->m_matrix); + pParams->m_pGraphics->RestoreGraphState(); + FX_ARGB argbFill = ArgbEncode(255, 77, 97, 133); + switch (pParams->m_dwStates & 0x03) { + case FWL_CMBPARTSTATE_Normal: { + } + case FWL_CMBPARTSTATE_Hovered: { + } + case FWL_CMBPARTSTATE_Pressed: { + argbFill = 0xFF000000; + break; + } + case FWL_CMBPARTSTATE_Disabled: { + argbFill = 0xFFF0F0F0; + break; + } + } + DrawArrow(pParams->m_pGraphics, &pParams->m_rtPart, FWLTHEME_DIRECTION_Down, + argbFill, bPressed, &pParams->m_matrix); +} +#endif diff --git a/xfa/fwl/theme/datetimepickertp.cpp b/xfa/fwl/theme/datetimepickertp.cpp new file mode 100644 index 0000000000..5efe0b850e --- /dev/null +++ b/xfa/fwl/theme/datetimepickertp.cpp @@ -0,0 +1,138 @@ +// 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 "xfa/include/fwl/theme/datetimepickertp.h" + +#include "xfa/include/fwl/basewidget/fwl_datetimepicker.h" + +CFWL_DateTimePickerTP::CFWL_DateTimePickerTP() { + m_pThemeData = new DTPThemeData; + initThemeData(); +} +CFWL_DateTimePickerTP::~CFWL_DateTimePickerTP() { + delete m_pThemeData; +} +FX_BOOL CFWL_DateTimePickerTP::IsValidWidget(IFWL_Widget* pWidget) { + if (!pWidget) + return FALSE; + return pWidget->GetClassID() == FWL_CLASSHASH_DateTimePicker; +} +FX_BOOL CFWL_DateTimePickerTP::DrawBackground(CFWL_ThemeBackground* pParams) { + if (!pParams) + return FALSE; + switch (pParams->m_iPart) { + case FWL_PART_DTP_Border: { + DrawBorder(pParams->m_pGraphics, &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_DTP_Edge: { + DrawEdge(pParams->m_pGraphics, pParams->m_pWidget->GetStyles(), + &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_DTP_DropDownButton: { + DrawDropDownButton(pParams, &pParams->m_matrix); + break; + } + default: {} + } + return TRUE; +} +#ifdef THEME_XPSimilar +void CFWL_DateTimePickerTP::DrawDropDownButton(CFWL_ThemeBackground* pParams, + CFX_Matrix* pMatrix) { + FX_DWORD dwStates = pParams->m_dwStates; + dwStates &= 0x03; + FWLTHEME_STATE eState = FWLTHEME_STATE_Normal; + switch (eState & dwStates) { + case FWL_PARTSTATE_DTP_Normal: { + eState = FWLTHEME_STATE_Normal; + break; + } + case FWL_PARTSTATE_DTP_Hovered: { + eState = FWLTHEME_STATE_Hover; + break; + } + case FWL_PARTSTATE_DTP_Pressed: { + eState = FWLTHEME_STATE_Pressed; + break; + } + case FWL_PARTSTATE_DTP_Disabled: { + eState = FWLTHEME_STATE_Disabale; + break; + } + default: {} + } + DrawArrowBtn(pParams->m_pGraphics, &pParams->m_rtPart, + FWLTHEME_DIRECTION_Down, eState, pMatrix); +} +#else +void CFWL_DateTimePickerTP::DrawDropDownButton(CFWL_ThemeBackground* pParams, + CFX_Matrix* pMatrix) { + FX_BOOL bPressed = ((pParams->m_dwStates & FWL_PARTSTATE_DTP_Pressed) == + FWL_PARTSTATE_DTP_Pressed); + FX_FLOAT fWidth = bPressed ? 1.0f : 2.0f; + FWLTHEME_EDGE eType = bPressed ? FWLTHEME_EDGE_Flat : FWLTHEME_EDGE_Raised; + Draw3DRect(pParams->m_pGraphics, eType, fWidth, &pParams->m_rtPart, + FWLTHEME_COLOR_EDGELT1, FWLTHEME_COLOR_EDGELT2, + FWLTHEME_COLOR_EDGERB1, FWLTHEME_COLOR_EDGERB2, pMatrix); + CFX_Path path; + path.Create(); + path.AddRectangle(pParams->m_rtPart.left + fWidth, + pParams->m_rtPart.top + fWidth, + pParams->m_rtPart.width - 2 * fWidth, + pParams->m_rtPart.height - 2 * fWidth); + pParams->m_pGraphics->SaveGraphState(); + CFX_Color crFill(FWLTHEME_COLOR_Background); + pParams->m_pGraphics->SetFillColor(&crFill); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pParams->m_pGraphics->RestoreGraphState(); + FX_ARGB argbFill = ArgbEncode(255, 77, 97, 133); + switch (pParams->m_dwStates & 0x03) { + case FWL_PARTSTATE_DTP_Normal: { + } + case FWL_PARTSTATE_DTP_Hovered: { + } + case FWL_PARTSTATE_DTP_Pressed: { + argbFill = 0xFF000000; + break; + } + case FWL_PARTSTATE_DTP_Disabled: { + argbFill = 0xFFF0F0F0; + break; + } + } + DrawArrow(pParams->m_pGraphics, &pParams->m_rtPart, FWLTHEME_DIRECTION_Down, + argbFill, bPressed, pMatrix); +} +#endif +void CFWL_DateTimePickerTP::initThemeData() { + FX_DWORD* pData = (FX_DWORD*)&m_pThemeData->BoxBkColor; + *pData++ = 0, *pData++ = 0, *pData++ = ArgbEncode(255, 220, 220, 215), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 240, 207), + *pData++ = ArgbEncode(255, 248, 179, 48), + *pData++ = ArgbEncode(255, 176, 176, 167), + *pData++ = ArgbEncode(255, 241, 239, 239), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 220, 220, 215), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 240, 207), + *pData++ = ArgbEncode(255, 248, 179, 48), + *pData++ = ArgbEncode(255, 176, 176, 167), + *pData++ = ArgbEncode(255, 241, 239, 239), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 220, 220, 215), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 240, 207), + *pData++ = ArgbEncode(255, 248, 179, 48), + *pData++ = ArgbEncode(255, 176, 176, 167), + *pData++ = ArgbEncode(255, 241, 239, 239), + *pData++ = ArgbEncode(255, 255, 255, 255), + *pData++ = ArgbEncode(255, 255, 255, 255); +} diff --git a/xfa/fwl/theme/edittp.cpp b/xfa/fwl/theme/edittp.cpp new file mode 100644 index 0000000000..a206faffe8 --- /dev/null +++ b/xfa/fwl/theme/edittp.cpp @@ -0,0 +1,89 @@ +// 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 "xfa/include/fwl/theme/edittp.h" + +#include "xfa/include/fwl/basewidget/fwl_edit.h" +#include "xfa/include/fwl/core/fwl_widget.h" + +CFWL_EditTP::CFWL_EditTP() {} +CFWL_EditTP::~CFWL_EditTP() {} + +FX_BOOL CFWL_EditTP::IsValidWidget(IFWL_Widget* pWidget) { + if (!pWidget) + return FALSE; + return pWidget->GetClassID() == FWL_CLASSHASH_Edit; +} +FX_BOOL CFWL_EditTP::DrawBackground(CFWL_ThemeBackground* pParams) { + switch (pParams->m_iPart) { + case FWL_PART_EDT_Border: { + DrawBorder(pParams->m_pGraphics, &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_EDT_Edge: { + DrawEdge(pParams->m_pGraphics, pParams->m_pWidget->GetStyles(), + &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_EDT_Background: { + if (pParams->m_pPath) { + CFX_Graphics* pGraphics = pParams->m_pGraphics; + pGraphics->SaveGraphState(); + CFX_Color crSelected(FWL_GetThemeColor(m_dwThemeID) == 0 + ? FWLTHEME_COLOR_BKSelected + : FWLTHEME_COLOR_Green_BKSelected); + pGraphics->SetFillColor(&crSelected); + pGraphics->FillPath(pParams->m_pPath, FXFILL_WINDING, + &pParams->m_matrix); + pGraphics->RestoreGraphState(); + } else { + FX_BOOL bStatic = + pParams->m_dwData == FWL_PARTDATA_EDT_StaticBackground; + CFX_Path path; + path.Create(); + path.AddRectangle(pParams->m_rtPart.left, pParams->m_rtPart.top, + pParams->m_rtPart.width, pParams->m_rtPart.height); + CFX_Color cr(FWLTHEME_COLOR_Background); + if (!bStatic) { + if ((pParams->m_dwStates & FWL_PARTSTATE_EDT_Disable) == + FWL_PARTSTATE_EDT_Disable) { + cr.Set(FWLTHEME_COLOR_EDGERB1); + } else if ((pParams->m_dwStates & FWL_PARTSTATE_EDT_ReadOnly) == + FWL_PARTSTATE_EDT_ReadOnly) { + cr.Set(ArgbEncode(255, 236, 233, 216)); + } else { + cr.Set(0xFFFFFFFF); + } + } + pParams->m_pGraphics->SaveGraphState(); + pParams->m_pGraphics->SetFillColor(&cr); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, + &pParams->m_matrix); + pParams->m_pGraphics->RestoreGraphState(); + } + break; + } + case FWL_PART_EDT_CombTextLine: { + FX_ARGB cr = 0xFF000000; + FX_FLOAT fWidth = 1.0f; + CFX_Color crLine(cr); + pParams->m_pGraphics->SetStrokeColor(&crLine); + pParams->m_pGraphics->SetLineWidth(fWidth); + pParams->m_pGraphics->StrokePath(pParams->m_pPath, &pParams->m_matrix); + break; + } + default: { break; } + } + return TRUE; +} +FWL_ERR CFWL_EditTP::Initialize() { + InitTTO(); + return CFWL_WidgetTP::Initialize(); +} +FWL_ERR CFWL_EditTP::Finalize() { + FinalizeTTO(); + return CFWL_WidgetTP::Finalize(); +} diff --git a/xfa/fwl/theme/formtp.cpp b/xfa/fwl/theme/formtp.cpp new file mode 100644 index 0000000000..5f75535f3b --- /dev/null +++ b/xfa/fwl/theme/formtp.cpp @@ -0,0 +1,893 @@ +// 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 "xfa/include/fwl/theme/formtp.h" + +#include "xfa/fde/tto/fde_textout.h" +#include "xfa/include/fwl/core/fwl_form.h" +#include "xfa/include/fwl/core/fwl_widget.h" + +#define FWLTHEME_CAPACITY_CXFormBorder 3 +#define FWLTHEME_CAPACITY_CYFormBorder 3 +#define FWLTHEME_CAPACITY_CYNarrowCaption 18 +#define FWLTHEME_CAPACITY_CYCaption 29 +#define FWLTHEME_CAPACITY_BigIconSize 32 +#define FWLTHEME_CAPACITY_SmallIconSize 16 +#define FWLTHEME_CAPACITY_FormTextColor 0xFFFFFFFF +#define FWLTHEME_FORMBTN_Margin 5 +#define FWLTHEME_FORMBTN_Span 2 +#define FWLTHEME_FORMBTN_Size 21 + +CFWL_FormTP::CFWL_FormTP() : m_pActiveBitmap(NULL), m_pDeactivebitmap(NULL) { + m_pThemeData = new SBThemeData; + SetThemeData(0); + m_rtDisLBorder.Reset(); + m_rtDisRBorder.Reset(); + m_rtDisBBorder.Reset(); + m_rtDisCaption.Reset(); +} +CFWL_FormTP::~CFWL_FormTP() { + if (m_pThemeData) { + delete m_pThemeData; + m_pThemeData = NULL; + } +} +FWL_ERR CFWL_FormTP::Initialize() { + InitTTO(); + InitCaption(TRUE); + InitCaption(FALSE); + return CFWL_WidgetTP::Initialize(); +} +FWL_ERR CFWL_FormTP::Finalize() { + FinalizeTTO(); + if (m_pActiveBitmap) { + delete m_pActiveBitmap; + m_pActiveBitmap = NULL; + } + if (m_pDeactivebitmap) { + delete m_pDeactivebitmap; + m_pDeactivebitmap = NULL; + } + return CFWL_WidgetTP::Finalize(); +} +FX_BOOL CFWL_FormTP::IsValidWidget(IFWL_Widget* pWidget) { + if (!pWidget) + return FALSE; + FX_DWORD dwHash = pWidget->GetClassID(); + return dwHash == FWL_CLASSHASH_Form; +} +FX_DWORD CFWL_FormTP::SetThemeID(IFWL_Widget* pWidget, + FX_DWORD dwThemeID, + FX_BOOL bChildren) { + if (m_pThemeData) { + SetThemeData(FWL_GetThemeColor(dwThemeID)); + } + InitCaption(TRUE); + InitCaption(FALSE); + return CFWL_WidgetTP::SetThemeID(pWidget, dwThemeID, bChildren); +} +FX_BOOL CFWL_FormTP::DrawBackground(CFWL_ThemeBackground* pParams) { + if (!pParams) + return FALSE; + int32_t iActive = 0; + if (pParams->m_dwStates & FWL_PARTSTATE_FRM_Inactive) { + iActive = 1; + } + FWLTHEME_STATE eState = FWLTHEME_STATE_Normal; + switch (pParams->m_dwStates & 0x03) { + case FWL_PARTSTATE_FRM_Hover: { + eState = FWLTHEME_STATE_Hover; + break; + } + case FWL_PARTSTATE_FRM_Pressed: { + eState = FWLTHEME_STATE_Pressed; + break; + } + case FWL_PARTSTATE_FRM_Disabled: { + eState = FWLTHEME_STATE_Disabale; + break; + } + default: {} + } + switch (pParams->m_iPart) { + case FWL_PART_FRM_Border: { + DrawFormBorder(pParams->m_pGraphics, &pParams->m_rtPart, eState, + &pParams->m_matrix, iActive); + break; + } + case FWL_PART_FRM_Edge: { + DrawEdge(pParams->m_pGraphics, pParams->m_pWidget->GetStyles(), + &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_FRM_Background: { + FillBackground(pParams->m_pGraphics, &pParams->m_rtPart, + &pParams->m_matrix); + break; + } + case FWL_PART_FRM_Caption: { + DrawCaption(pParams->m_pGraphics, &pParams->m_rtPart, eState, + &pParams->m_matrix, iActive); + break; + } + case FWL_PART_FRM_NarrowCaption: { + DrawNarrowCaption(pParams->m_pGraphics, &pParams->m_rtPart, eState, + &pParams->m_matrix, iActive); + break; + } + case FWL_PART_FRM_CloseBox: { + DrawCloseBox(pParams->m_pGraphics, &pParams->m_rtPart, eState, + &pParams->m_matrix, iActive); + break; + } + case FWL_PART_FRM_MinimizeBox: { + DrawMinimizeBox(pParams->m_pGraphics, &pParams->m_rtPart, eState, + &pParams->m_matrix, iActive); + break; + } + case FWL_PART_FRM_MaximizeBox: { + DrawMaximizeBox(pParams->m_pGraphics, &pParams->m_rtPart, eState, + pParams->m_dwData, &pParams->m_matrix, iActive); + break; + } + case FWL_PART_FRM_Icon: { + DrawIconImage(pParams->m_pGraphics, pParams->m_pImage, &pParams->m_rtPart, + eState, &pParams->m_matrix, iActive); + break; + } + default: {} + } + return TRUE; +} +FX_BOOL CFWL_FormTP::DrawText(CFWL_ThemeText* pParams) { + if (!m_pTextOut) + return FALSE; + if (pParams->m_iPart == FWL_PART_FRM_Caption) { + m_pTextOut->SetTextColor(0xFFFFFFFF); + } else { + m_pTextOut->SetTextColor(0xFF000000); + } + return CFWL_WidgetTP::DrawText(pParams); +} +void* CFWL_FormTP::GetCapacity(CFWL_ThemePart* pThemePart, + FX_DWORD dwCapacity) { + FX_BOOL bDefPro = FALSE; + FX_BOOL bDwordVal = FALSE; + switch (dwCapacity) { + case FWL_WGTCAPACITY_CXBorder: { + m_fValue = FWLTHEME_CAPACITY_CXFormBorder; + break; + } + case FWL_WGTCAPACITY_CYBorder: { + m_fValue = FWLTHEME_CAPACITY_CYFormBorder; + break; + } + case FWL_WGTCAPACITY_FRM_CYCaption: { + m_fValue = FWLTHEME_CAPACITY_CYCaption; + break; + } + case FWL_WGTCAPACITY_FRM_CYNarrowCaption: { + m_fValue = FWLTHEME_CAPACITY_CYCaption; + break; + } + case FWL_WGTCAPACITY_TextColor: { + bDwordVal = TRUE; + m_dwValue = FWLTHEME_CAPACITY_FormTextColor; + break; + } + case FWL_WGTCAPACITY_FRM_BigIcon: { + m_fValue = FWLTHEME_CAPACITY_BigIconSize; + break; + } + case FWL_WGTCAPACITY_FRM_SmallIcon: { + m_fValue = FWLTHEME_CAPACITY_SmallIconSize; + break; + } + default: { bDefPro = TRUE; } + } + if (!bDefPro) { + if (bDwordVal) { + return &m_dwValue; + } + return &m_fValue; + } + return CFWL_WidgetTP::GetCapacity(pThemePart, dwCapacity); +} +FWL_ERR CFWL_FormTP::GetPartRect(CFWL_ThemePart* pThemePart, + CFX_RectF& rtPart) { + switch (pThemePart->m_iPart) { + case FWL_PART_FRM_CloseBox: { + CalCloseBox(pThemePart->m_pWidget, rtPart); + break; + } + case FWL_PART_FRM_MaximizeBox: { + CalMaxBox(pThemePart->m_pWidget, rtPart); + break; + } + case FWL_PART_FRM_MinimizeBox: { + CalMinBox(pThemePart->m_pWidget, rtPart); + break; + } + case FWL_PART_FRM_HeadText: { + CalCaption(pThemePart->m_pWidget, rtPart); + break; + } + case FWL_PART_FRM_Icon: { + CalIcon(pThemePart->m_pWidget, rtPart); + break; + } + default: {} + } + return FWL_ERR_Succeeded; +} +void CFWL_FormTP::CalCloseBox(IFWL_Widget* pWidget, CFX_RectF& rect) { + FX_DWORD dwStyles = pWidget->GetStyles(); + CFX_RectF rtWidget; + pWidget->GetWidgetRect(rtWidget); + rtWidget.Offset(-rtWidget.left, -rtWidget.top); + if (dwStyles & FWL_WGTSTYLE_CloseBox) { + rect.Set(rtWidget.left + FWLTHEME_FORMBTN_Margin + FWLTHEME_FORMBTN_Span, + rtWidget.top + FWLTHEME_FORMBTN_Margin, FWLTHEME_FORMBTN_Size, + FWLTHEME_FORMBTN_Size); + } else { + rect.Set(rtWidget.left + FWLTHEME_FORMBTN_Margin + FWLTHEME_FORMBTN_Span, + rtWidget.top + FWLTHEME_FORMBTN_Margin, 0, 0); + } +} +void CFWL_FormTP::CalMaxBox(IFWL_Widget* pWidget, CFX_RectF& rect) { + FX_DWORD dwStyles = pWidget->GetStyles(); + CFX_RectF rtWidget; + pWidget->GetWidgetRect(rtWidget); + rtWidget.Offset(-rtWidget.left, -rtWidget.top); + if (dwStyles & FWL_WGTSTYLE_MaximizeBox) { + rect.Set(rtWidget.left + FWLTHEME_FORMBTN_Margin + FWLTHEME_FORMBTN_Size + + FWLTHEME_FORMBTN_Span * 2, + rtWidget.top + FWLTHEME_FORMBTN_Margin, FWLTHEME_FORMBTN_Size, + FWLTHEME_FORMBTN_Size); + } else { + rect.Set(rtWidget.left + FWLTHEME_FORMBTN_Margin + FWLTHEME_FORMBTN_Size + + FWLTHEME_FORMBTN_Span * 2, + rtWidget.top + FWLTHEME_FORMBTN_Margin, 0, 0); + } +} +void CFWL_FormTP::CalMinBox(IFWL_Widget* pWidget, CFX_RectF& rect) { + FX_DWORD dwStyles = pWidget->GetStyles(); + CFX_RectF rtWidget; + pWidget->GetWidgetRect(rtWidget); + rtWidget.Offset(-rtWidget.left, -rtWidget.top); + if (dwStyles & FWL_WGTSTYLE_MinimizeBox) { + rect.Set(rtWidget.left + FWLTHEME_FORMBTN_Margin + + FWLTHEME_FORMBTN_Size * 2 + FWLTHEME_FORMBTN_Span * 3, + rtWidget.top + FWLTHEME_FORMBTN_Margin, FWLTHEME_FORMBTN_Size, + FWLTHEME_FORMBTN_Size); + } else { + rect.Set(rtWidget.left + FWLTHEME_FORMBTN_Margin + + FWLTHEME_FORMBTN_Size * 2 + FWLTHEME_FORMBTN_Span * 3, + rtWidget.top + FWLTHEME_FORMBTN_Margin, 0, 0); + } +} +void CFWL_FormTP::CalCaption(IFWL_Widget* pWidget, CFX_RectF& rect) { + CFX_RectF rtWidget; + pWidget->GetWidgetRect(rtWidget); + rtWidget.Offset(-rtWidget.left, -rtWidget.top); + rect.Set(rtWidget.left + FWLTHEME_FORMBTN_Margin, + rtWidget.top + FWLTHEME_FORMBTN_Margin - 2, + rtWidget.width - FWLTHEME_FORMBTN_Margin * 2, + FWLTHEME_FORMBTN_Size + 2 * FWLTHEME_FORMBTN_Margin + 4); +} +void CFWL_FormTP::CalIcon(IFWL_Widget* pWidget, CFX_RectF& rect) {} +void CFWL_FormTP::DrawFormBorder(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_STATE eState, + CFX_Matrix* pMatrix, + int32_t iActive) { + CFX_RectF rt; + rt.Set(pRect->left, pRect->top, 1, pRect->height); + FX_FLOAT fBottom, fRight; + fBottom = pRect->bottom(); + fRight = pRect->right(); + CFX_Path path; + path.Create(); + CFX_Color clrLine; + path.Clear(); + path.MoveTo(pRect->left, pRect->top); + path.LineTo(pRect->left, fBottom - 1); + path.LineTo(fRight - 1, fBottom - 1); + path.LineTo(fRight - 1, pRect->top); + clrLine = m_pThemeData->clrFormBorder[iActive][2]; + pGraphics->SetStrokeColor(&clrLine); + pGraphics->StrokePath(&path, pMatrix); + path.Clear(); + path.MoveTo(pRect->left + 1, pRect->top); + path.LineTo(pRect->left + 1, fBottom - 2); + path.LineTo(fRight - 2, fBottom - 2); + path.LineTo(fRight - 2, pRect->top); + clrLine = m_pThemeData->clrFormBorder[iActive][1]; + pGraphics->SetStrokeColor(&clrLine); + pGraphics->StrokePath(&path, pMatrix); + path.Clear(); + path.MoveTo(pRect->left + 2, pRect->top); + path.LineTo(pRect->left + 2, fBottom - 3); + path.LineTo(fRight - 3, fBottom - 3); + path.LineTo(fRight - 3, pRect->top); + clrLine = m_pThemeData->clrFormBorder[iActive][0]; + pGraphics->SetStrokeColor(&clrLine); + pGraphics->StrokePath(&path, pMatrix); + path.Clear(); + path.MoveTo(pRect->left + 3, pRect->top); + path.LineTo(pRect->left + 3, fBottom - 4); + path.LineTo(fRight - 4, fBottom - 4); + path.LineTo(fRight - 4, pRect->top); + clrLine = m_pThemeData->clrFormBorder[iActive][4]; + pGraphics->SetStrokeColor(&clrLine); + pGraphics->StrokePath(&path, pMatrix); + m_rtDisLBorder.Set(pRect->left, pRect->top + 29, 4, pRect->height - 29); + m_rtDisRBorder.Set(pRect->right() - 4, pRect->top + 29, 4, + pRect->height - 29); + m_rtDisBBorder.Set(pRect->left, pRect->bottom() - 4, pRect->width, 4); + m_rtDisCaption.Set(pRect->left, pRect->top, pRect->width, 29); +} +void CFWL_FormTP::DrawCaption(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_STATE eState, + CFX_Matrix* pMatrix, + int32_t iActive) { + CFX_RectF rt; + FX_FLOAT fBottom, fRight; + fBottom = pRect->bottom(); + fRight = pRect->right(); + rt.Set(pRect->left, pRect->top, pRect->width, 1); + FillSoildRect(pGraphics, m_pThemeData->clrHeadEdgeTop[iActive][0], &rt, + pMatrix); + rt.Offset(0, 1); + FillSoildRect(pGraphics, m_pThemeData->clrHeadEdgeTop[iActive][1], &rt, + pMatrix); + rt.Offset(0, 1); + FillSoildRect(pGraphics, m_pThemeData->clrHeadEdgeTop[iActive][2], &rt, + pMatrix); + rt.Set(pRect->left, pRect->bottom() - 1, pRect->width, 1); + FillSoildRect(pGraphics, m_pThemeData->clrHeadEdgeBottom[iActive][2], &rt, + pMatrix); + rt.Offset(0, -1); + FillSoildRect(pGraphics, m_pThemeData->clrHeadEdgeBottom[iActive][1], &rt, + pMatrix); + rt.Set(pRect->left, pRect->top, 1, pRect->height); + FillSoildRect(pGraphics, m_pThemeData->clrHeadEdgeLeft[iActive][2], &rt, + pMatrix); + rt.Set(pRect->left + 1, pRect->top + 1, 1, fBottom - 1); + FillSoildRect(pGraphics, m_pThemeData->clrHeadEdgeLeft[iActive][1], &rt, + pMatrix); + rt.Set(pRect->left + 2, pRect->top + 2, 1, fBottom - 2); + FillSoildRect(pGraphics, m_pThemeData->clrHeadEdgeLeft[iActive][0], &rt, + pMatrix); + rt.Set(fRight - 1, pRect->top, pRect->width, pRect->height); + FillSoildRect(pGraphics, m_pThemeData->clrHeadEdgeRight[iActive][2], &rt, + pMatrix); + rt.Set(fRight - 2, pRect->top + 1, 1, fBottom - 1); + FillSoildRect(pGraphics, m_pThemeData->clrHeadEdgeRight[iActive][1], &rt, + pMatrix); + rt.Set(fRight - 3, pRect->top + 2, 1, fBottom - 2); + FillSoildRect(pGraphics, m_pThemeData->clrHeadEdgeRight[iActive][0], &rt, + pMatrix); + CFX_RectF rect(*pRect); + rect.Set(rect.left + 3, rect.top + 3, rect.width - 6, rect.height - 5); + if (iActive == 0) { + pGraphics->StretchImage(m_pActiveBitmap, rect, pMatrix); + } else { + pGraphics->StretchImage(m_pDeactivebitmap, rect, pMatrix); + } +} +void CFWL_FormTP::DrawNarrowCaption(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_STATE eState, + CFX_Matrix* pMatrix, + int32_t iActive) {} +void CFWL_FormTP::DrawCloseBox(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_STATE eState, + CFX_Matrix* pMatrix, + int32_t iActive) { + FX_FLOAT fRight = pRect->right(); + FX_FLOAT fBottom = pRect->bottom(); + FX_FLOAT fWidth = pRect->width; + FX_FLOAT fHeight = pRect->height; + pGraphics->SaveGraphState(); + CFX_RectF rt(*pRect); + pGraphics->SetLineWidth(1.0f); + CFX_Path path; + path.Create(); + path.AddRectangle(rt.left + 1, rt.top, fWidth - 2, 1); + path.AddRectangle(rt.left, rt.top + 1, 1, fHeight - 2); + path.AddRectangle(fRight - 1, rt.top + 1, 1, fHeight - 2); + path.AddRectangle(rt.left + 1, fBottom - 1, fWidth - 2, 1); + CFX_Color crFill; + crFill = m_pThemeData->clrBtnEdgeOut[iActive]; + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + path.Clear(); + path.AddRectangle(rt.left + 1, rt.top + 1, 1, 1); + path.AddRectangle(fRight - 2, rt.top + 1, 1, 1); + path.AddRectangle(rt.left + 1, fBottom - 2, 1, 1); + path.AddRectangle(fRight - 2, fBottom - 2, 1, 1); + crFill = m_pThemeData->clrBtnCornerLight[iActive][eState - 1]; + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + path.Clear(); + path.AddRectangle(rt.left + 2, rt.top + 1, fWidth - 4, 1); + path.AddRectangle(rt.left + 1, rt.top + 2, 1, fHeight - 4); + crFill = m_pThemeData->clrCloseBtEdgeLight[iActive][eState - 1]; + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + path.Clear(); + path.AddRectangle(fRight - 2, rt.top + 2, 1, fHeight - 4); + path.AddRectangle(rt.left + 2, fBottom - 2, fWidth - 4, 1); + crFill = m_pThemeData->clrCloseBtEdgeDark[iActive][eState - 1]; + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + path.Clear(); + path.AddRectangle(pRect->left + 2, pRect->top + 2, fWidth - 4, fHeight - 4); + DrawAxialShading(pGraphics, pRect->left + 2, pRect->top + 2, fRight - 2, + fBottom - 2, + m_pThemeData->clrCloseBtBKStart[iActive][eState - 1], + m_pThemeData->clrCloseBtBKEnd[iActive][eState - 1], &path, + FXFILL_WINDING, pMatrix); + CFX_RectF rtX(*pRect); + rtX.Inflate(-5, -5); + path.Clear(); + FX_FLOAT frtXRight = rtX.right(); + FX_FLOAT frtXBottom = rtX.bottom(); + path.AddLine(rtX.left, rtX.top + 1, frtXRight - 1, frtXBottom); + path.AddLine(rtX.left, rtX.top, frtXRight, frtXBottom); + path.AddLine(rtX.left + 1, rtX.top, frtXRight, frtXBottom - 1); + path.AddLine(rtX.left, frtXBottom - 1, frtXRight - 1, rtX.top); + path.AddLine(rtX.left, frtXBottom, frtXRight, rtX.top); + path.AddLine(rtX.left + 1, frtXBottom, frtXRight, rtX.top + 1); + CFX_Color clrLine(0xffffffff); + pGraphics->SetLineWidth(1.0f); + pGraphics->SetStrokeColor(&clrLine); + pGraphics->StrokePath(&path, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_FormTP::DrawMinMaxBoxCommon(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_STATE eState, + CFX_Matrix* pMatrix, + int32_t iActive) { + pGraphics->SaveGraphState(); + FX_FLOAT fRight = pRect->right(); + FX_FLOAT fBottom = pRect->bottom(); + FX_FLOAT fWidth = pRect->width; + FX_FLOAT fHeight = pRect->height; + CFX_RectF rt(*pRect); + pGraphics->SetLineWidth(1.0f); + CFX_Path path; + path.Create(); + path.AddRectangle(rt.left + 1, rt.top, fWidth - 2, 1); + path.AddRectangle(rt.left, rt.top + 1, 1, fHeight - 2); + path.AddRectangle(fRight - 1, rt.top + 1, 1, fHeight - 2); + path.AddRectangle(rt.left + 1, fBottom - 1, fWidth - 2, 1); + CFX_Color crFill; + crFill = m_pThemeData->clrBtnEdgeOut[iActive]; + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + path.Clear(); + path.AddRectangle(rt.left + 1, rt.top + 1, 1, 1); + path.AddRectangle(fRight - 2, rt.top + 1, 1, 1); + path.AddRectangle(rt.left + 1, fBottom - 2, 1, 1); + path.AddRectangle(fRight - 2, fBottom - 2, 1, 1); + crFill = m_pThemeData->clrBtnCornerLight[iActive][eState - 1]; + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + path.Clear(); + path.AddRectangle(rt.left + 2, rt.top + 1, fWidth - 4, 1); + path.AddRectangle(rt.left + 1, rt.top + 2, 1, fHeight - 4); + crFill = m_pThemeData->clrNormalBtEdgeLight[iActive][eState - 1]; + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + path.Clear(); + path.AddRectangle(fRight - 2, rt.top + 2, 1, fHeight - 4); + path.AddRectangle(rt.left + 2, fBottom - 2, fWidth - 4, 1); + crFill = m_pThemeData->clrNormalBtEdgeDark[iActive][eState - 1]; + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pGraphics->RestoreGraphState(); + path.Clear(); + path.AddRectangle(pRect->left + 2, pRect->top + 2, fWidth - 4, fHeight - 4); + DrawAxialShading(pGraphics, pRect->left + 2, pRect->top + 2, fRight - 2, + fBottom - 2, + m_pThemeData->clrNormalBtBKStart[iActive][eState - 1], + m_pThemeData->clrNormalBtBKEnd[iActive][eState - 1], &path, + FXFILL_WINDING, pMatrix); +} +void CFWL_FormTP::DrawMinimizeBox(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_STATE eState, + CFX_Matrix* pMatrix, + int32_t iActive) { + DrawMinMaxBoxCommon(pGraphics, pRect, eState, pMatrix); + CFX_RectF rtMin; + rtMin.Set(pRect->left + 5, pRect->top + 13, pRect->width - 14, + pRect->height - 18); + FillSoildRect(pGraphics, 0xFFFFFFFF, &rtMin, pMatrix); +} +void CFWL_FormTP::DrawMaximizeBox(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_STATE eState, + FX_BOOL bMax, + CFX_Matrix* pMatrix, + int32_t iActive) { + DrawMinMaxBoxCommon(pGraphics, pRect, eState, pMatrix); + FX_FLOAT fWidth = pRect->width; + FX_FLOAT fHeight = pRect->height; + if (bMax) { + CFX_Path path; + path.Create(); + path.AddLine(pRect->left + 7, pRect->top + 6, pRect->left + 14, + pRect->top + 6); + path.AddLine(pRect->left + 4, pRect->top + 9, pRect->left + 11, + pRect->top + 9); + pGraphics->SaveGraphState(); + pGraphics->SetLineWidth(2); + CFX_Color crStroke(0xFFFFFFFF); + pGraphics->SetStrokeColor(&crStroke); + pGraphics->StrokePath(&path, pMatrix); + pGraphics->SetLineWidth(1); + path.Clear(); + path.AddLine(pRect->left + 4, pRect->top + 10, pRect->left + 4, + pRect->top + 14); + path.AddLine(pRect->left + 10, pRect->top + 10, pRect->left + 10, + pRect->top + 14); + path.AddLine(pRect->left + 13, pRect->top + 7, pRect->left + 13, + pRect->top + 11); + path.AddLine(pRect->left + 4, pRect->top + 14, pRect->left + 10, + pRect->top + 14); + path.AddLine(pRect->left + 12, pRect->top + 11, pRect->left + 12, + pRect->top + 11); + pGraphics->StrokePath(&path, pMatrix); + pGraphics->RestoreGraphState(); + } else { + CFX_RectF rtMax(*pRect); + rtMax.Inflate(-5, -5); + CFX_Path path; + path.Create(); + path.AddRectangle(pRect->left + 5, pRect->top + 5, fWidth - 10, + fHeight - 10); + path.AddRectangle(pRect->left + 6, pRect->top + 8, fWidth - 12, + fHeight - 14); + pGraphics->SaveGraphState(); + CFX_Color crFill(0xFFFFFFFF); + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_ALTERNATE, pMatrix); + pGraphics->RestoreGraphState(); + } +} +void CFWL_FormTP::DrawIconImage(CFX_Graphics* pGraphics, + CFX_DIBitmap* pDIBitmap, + const CFX_RectF* pRect, + FWLTHEME_STATE eState, + CFX_Matrix* pMatrix, + int32_t iActive) { + pGraphics->StretchImage(pDIBitmap, *pRect, pMatrix); +} +void CFWL_FormTP::SetThemeData(FX_DWORD dwID) { + m_pThemeData->clrTransWhite = ArgbEncode(0x65, 255, 255, 255); + m_pThemeData->clrCloseBtBKStart[0][0] = ArgbEncode(0xff, 240, 166, 148); + m_pThemeData->clrCloseBtBKEnd[0][0] = ArgbEncode(0xff, 228, 61, 5); + m_pThemeData->clrCloseBtBKStart[0][1] = ArgbEncode(0xff, 255, 184, 176); + m_pThemeData->clrCloseBtBKEnd[0][1] = ArgbEncode(0xff, 252, 107, 71); + m_pThemeData->clrCloseBtBKStart[0][2] = ArgbEncode(0xff, 141, 44, 20); + m_pThemeData->clrCloseBtBKEnd[0][2] = ArgbEncode(0xff, 202, 72, 33); + m_pThemeData->clrCloseBtEdgeLight[0][0] = ArgbEncode(0xff, 255, 122, 107); + m_pThemeData->clrCloseBtEdgeDark[0][0] = ArgbEncode(0xff, 218, 77, 54); + m_pThemeData->clrCloseBtEdgeLight[0][1] = ArgbEncode(0xff, 255, 93, 74); + m_pThemeData->clrCloseBtEdgeDark[0][1] = ArgbEncode(0xff, 218, 74, 51); + m_pThemeData->clrCloseBtEdgeLight[0][2] = ArgbEncode(0xff, 191, 61, 28); + m_pThemeData->clrCloseBtEdgeDark[0][2] = ArgbEncode(0xff, 93, 30, 13); + if (dwID) { + m_pThemeData->clrHeadBK[0][0] = ArgbEncode(0xff, 194, 205, 149); + m_pThemeData->clrHeadBK[0][1] = ArgbEncode(0xff, 170, 184, 131); + m_pThemeData->clrHeadBK[0][2] = ArgbEncode(0xff, 168, 182, 128); + m_pThemeData->clrHeadBK[0][3] = ArgbEncode(0xff, 194, 205, 149); + m_pThemeData->clrHeadEdgeLeft[0][0] = ArgbEncode(0xff, 117, 141, 94); + m_pThemeData->clrHeadEdgeLeft[0][1] = ArgbEncode(0xff, 139, 161, 105); + m_pThemeData->clrHeadEdgeLeft[0][2] = ArgbEncode(0xff, 171, 189, 133); + m_pThemeData->clrHeadEdgeRight[0][0] = ArgbEncode(0xff, 155, 175, 125); + m_pThemeData->clrHeadEdgeRight[0][1] = ArgbEncode(0xff, 128, 146, 103); + m_pThemeData->clrHeadEdgeRight[0][2] = ArgbEncode(0xff, 94, 118, 79); + m_pThemeData->clrHeadEdgeTop[0][0] = ArgbEncode(0xff, 139, 161, 105); + m_pThemeData->clrHeadEdgeTop[0][1] = ArgbEncode(0xff, 234, 245, 201); + m_pThemeData->clrHeadEdgeTop[0][2] = ArgbEncode(0xff, 194, 205, 149); + m_pThemeData->clrHeadEdgeBottom[0][0] = ArgbEncode(0xff, 175, 189, 133); + m_pThemeData->clrHeadEdgeBottom[0][1] = ArgbEncode(0xff, 153, 168, 121); + m_pThemeData->clrHeadEdgeBottom[0][2] = ArgbEncode(0xff, 150, 168, 103); + m_pThemeData->clrNormalBtBKStart[0][0] = ArgbEncode(0xff, 182, 195, 162); + m_pThemeData->clrNormalBtBKEnd[0][0] = ArgbEncode(0xff, 128, 144, 84); + m_pThemeData->clrNormalBtBKStart[0][1] = ArgbEncode(0xff, 234, 241, 208); + m_pThemeData->clrNormalBtBKEnd[0][1] = ArgbEncode(0xff, 169, 186, 112); + m_pThemeData->clrNormalBtBKStart[0][2] = ArgbEncode(0xff, 199, 199, 190); + m_pThemeData->clrNormalBtBKEnd[0][2] = ArgbEncode(0xff, 133, 148, 88); + m_pThemeData->clrNormalBtEdgeLight[0][0] = ArgbEncode(0xff, 163, 176, 137); + m_pThemeData->clrNormalBtEdgeDark[0][0] = ArgbEncode(0xff, 118, 135, 83); + m_pThemeData->clrNormalBtEdgeLight[0][1] = ArgbEncode(0xff, 154, 174, 105); + m_pThemeData->clrNormalBtEdgeDark[0][1] = ArgbEncode(0xff, 154, 174, 105); + m_pThemeData->clrNormalBtEdgeLight[0][2] = ArgbEncode(0xff, 172, 193, 123); + m_pThemeData->clrNormalBtEdgeDark[0][2] = ArgbEncode(0xff, 154, 174, 105); + m_pThemeData->clrBtnCornerLight[0][0] = ArgbEncode(0xff, 220, 220, 220); + m_pThemeData->clrBtnCornerLight[0][1] = ArgbEncode(0xff, 255, 255, 255); + m_pThemeData->clrBtnCornerLight[0][2] = ArgbEncode(0xff, 225, 225, 225); + m_pThemeData->clrBtnEdgeOut[0] = ArgbEncode(0xff, 255, 255, 255); + m_pThemeData->clrFormBorder[0][0] = ArgbEncode(0xff, 117, 141, 94); + m_pThemeData->clrFormBorder[0][1] = ArgbEncode(0xff, 139, 161, 105); + m_pThemeData->clrFormBorder[0][2] = ArgbEncode(0xff, 171, 189, 133); + m_pThemeData->clrFormBorder[0][3] = ArgbEncode(0xff, 164, 178, 127); + m_pThemeData->clrFormBorder[0][4] = ArgbEncode(0xff, 255, 255, 255); + m_pThemeData->clrFormBorderLight[0] = ArgbEncode(0xff, 171, 189, 133); + } else { + m_pThemeData->clrHeadBK[0][0] = ArgbEncode(0xff, 3, 114, 255); + m_pThemeData->clrHeadBK[0][1] = ArgbEncode(0xff, 0, 85, 226); + m_pThemeData->clrHeadBK[0][2] = ArgbEncode(0xff, 0, 85, 226); + m_pThemeData->clrHeadBK[0][3] = ArgbEncode(0xff, 3, 114, 255); + m_pThemeData->clrHeadEdgeLeft[0][2] = ArgbEncode(0xff, 0, 32, 200); + m_pThemeData->clrHeadEdgeLeft[0][1] = ArgbEncode(0xff, 0, 61, 220); + m_pThemeData->clrHeadEdgeLeft[0][0] = ArgbEncode(0xff, 0, 54, 210); + m_pThemeData->clrHeadEdgeRight[0][0] = ArgbEncode(0xff, 0, 56, 234); + m_pThemeData->clrHeadEdgeRight[0][1] = ArgbEncode(0xff, 0, 50, 193); + m_pThemeData->clrHeadEdgeRight[0][2] = ArgbEncode(0xff, 0, 19, 139); + m_pThemeData->clrHeadEdgeTop[0][0] = ArgbEncode(0xff, 0, 88, 238); + m_pThemeData->clrHeadEdgeTop[0][1] = ArgbEncode(0xff, 63, 151, 255); + m_pThemeData->clrHeadEdgeTop[0][2] = ArgbEncode(0xff, 3, 114, 255); + m_pThemeData->clrHeadEdgeBottom[0][0] = ArgbEncode(0xff, 0, 96, 252); + m_pThemeData->clrHeadEdgeBottom[0][1] = ArgbEncode(0xff, 63, 151, 255); + m_pThemeData->clrHeadEdgeBottom[0][2] = ArgbEncode(0xff, 0, 67, 207); + m_pThemeData->clrNormalBtBKStart[0][2] = ArgbEncode(0xff, 0, 49, 112); + m_pThemeData->clrNormalBtBKEnd[0][2] = ArgbEncode(0xff, 0, 87, 188); + m_pThemeData->clrNormalBtBKStart[0][0] = ArgbEncode(0xff, 154, 183, 250); + m_pThemeData->clrNormalBtBKEnd[0][0] = ArgbEncode(0xff, 17, 110, 248); + m_pThemeData->clrNormalBtBKStart[0][1] = ArgbEncode(0xff, 164, 194, 255); + m_pThemeData->clrNormalBtBKEnd[0][1] = ArgbEncode(0xff, 29, 158, 255); + m_pThemeData->clrNormalBtEdgeLight[0][0] = ArgbEncode(0xff, 68, 120, 245); + m_pThemeData->clrNormalBtEdgeDark[0][0] = ArgbEncode(0xff, 24, 72, 187); + m_pThemeData->clrNormalBtEdgeLight[0][1] = ArgbEncode(0xff, 72, 122, 245); + m_pThemeData->clrNormalBtEdgeDark[0][1] = ArgbEncode(0xff, 35, 87, 195); + m_pThemeData->clrNormalBtEdgeLight[0][2] = ArgbEncode(0xff, 60, 114, 244); + m_pThemeData->clrNormalBtEdgeDark[0][2] = ArgbEncode(0xff, 21, 70, 185); + m_pThemeData->clrBtnCornerLight[0][0] = ArgbEncode(0xff, 220, 220, 220); + m_pThemeData->clrBtnCornerLight[0][1] = ArgbEncode(0xff, 255, 255, 255); + m_pThemeData->clrBtnCornerLight[0][2] = ArgbEncode(0xff, 225, 225, 225); + m_pThemeData->clrBtnEdgeOut[0] = ArgbEncode(0xff, 255, 255, 255); + m_pThemeData->clrFormBorder[0][0] = ArgbEncode(0xff, 0, 72, 241); + m_pThemeData->clrFormBorder[0][1] = ArgbEncode(0xff, 0, 61, 220); + m_pThemeData->clrFormBorder[0][2] = ArgbEncode(0xff, 0, 30, 160); + m_pThemeData->clrFormBorder[0][3] = ArgbEncode(0xff, 0, 19, 140); + m_pThemeData->clrFormBorder[0][4] = ArgbEncode(0xff, 255, 255, 255); + m_pThemeData->clrFormBorderLight[0] = ArgbEncode(0xff, 22, 106, 239); + } + m_pThemeData->clrCloseBtBKStart[1][0] = m_pThemeData->clrCloseBtBKStart[0][0]; + m_pThemeData->clrCloseBtBKEnd[1][0] = m_pThemeData->clrCloseBtBKEnd[0][0]; + m_pThemeData->clrCloseBtBKStart[1][1] = m_pThemeData->clrCloseBtBKStart[0][1]; + m_pThemeData->clrCloseBtBKEnd[1][1] = m_pThemeData->clrCloseBtBKEnd[0][1]; + m_pThemeData->clrCloseBtBKStart[1][2] = m_pThemeData->clrCloseBtBKStart[0][2]; + m_pThemeData->clrCloseBtBKEnd[1][2] = m_pThemeData->clrCloseBtBKEnd[0][2]; + m_pThemeData->clrCloseBtEdgeLight[1][0] = + m_pThemeData->clrCloseBtEdgeLight[0][0]; + m_pThemeData->clrCloseBtEdgeDark[1][0] = + m_pThemeData->clrCloseBtEdgeDark[0][0]; + m_pThemeData->clrCloseBtEdgeLight[1][1] = + m_pThemeData->clrCloseBtEdgeLight[0][1]; + m_pThemeData->clrCloseBtEdgeDark[1][1] = + m_pThemeData->clrCloseBtEdgeDark[0][1]; + m_pThemeData->clrCloseBtEdgeLight[1][2] = + m_pThemeData->clrCloseBtEdgeLight[0][2]; + m_pThemeData->clrCloseBtEdgeDark[1][2] = + m_pThemeData->clrCloseBtEdgeDark[0][2]; + m_pThemeData->clrHeadBK[1][0] = m_pThemeData->clrHeadBK[0][0]; + m_pThemeData->clrHeadBK[1][1] = m_pThemeData->clrHeadBK[0][1]; + m_pThemeData->clrHeadBK[1][2] = m_pThemeData->clrHeadBK[0][2]; + m_pThemeData->clrHeadBK[1][3] = m_pThemeData->clrHeadBK[0][3]; + m_pThemeData->clrHeadEdgeLeft[1][2] = m_pThemeData->clrHeadEdgeLeft[0][2]; + m_pThemeData->clrHeadEdgeLeft[1][1] = m_pThemeData->clrHeadEdgeLeft[0][1]; + m_pThemeData->clrHeadEdgeLeft[1][0] = m_pThemeData->clrHeadEdgeLeft[0][0]; + m_pThemeData->clrHeadEdgeRight[1][0] = m_pThemeData->clrHeadEdgeRight[0][0]; + m_pThemeData->clrHeadEdgeRight[1][1] = m_pThemeData->clrHeadEdgeRight[0][1]; + m_pThemeData->clrHeadEdgeRight[1][2] = m_pThemeData->clrHeadEdgeRight[0][2]; + m_pThemeData->clrHeadEdgeTop[1][0] = m_pThemeData->clrHeadEdgeTop[0][0]; + m_pThemeData->clrHeadEdgeTop[1][1] = m_pThemeData->clrHeadEdgeTop[0][1]; + m_pThemeData->clrHeadEdgeTop[1][2] = m_pThemeData->clrHeadEdgeTop[0][2]; + m_pThemeData->clrHeadEdgeBottom[1][0] = m_pThemeData->clrHeadEdgeBottom[0][0]; + m_pThemeData->clrHeadEdgeBottom[1][1] = m_pThemeData->clrHeadEdgeBottom[0][1]; + m_pThemeData->clrHeadEdgeBottom[1][2] = m_pThemeData->clrHeadEdgeBottom[0][2]; + m_pThemeData->clrNormalBtBKStart[1][2] = + m_pThemeData->clrNormalBtBKStart[0][2]; + m_pThemeData->clrNormalBtBKEnd[1][2] = m_pThemeData->clrNormalBtBKEnd[0][2]; + m_pThemeData->clrNormalBtBKStart[1][0] = + m_pThemeData->clrNormalBtBKStart[0][0]; + m_pThemeData->clrNormalBtBKEnd[1][0] = m_pThemeData->clrNormalBtBKEnd[1][0]; + m_pThemeData->clrNormalBtBKStart[1][1] = + m_pThemeData->clrNormalBtBKStart[0][1]; + m_pThemeData->clrNormalBtBKEnd[1][1] = m_pThemeData->clrNormalBtBKEnd[0][1]; + m_pThemeData->clrNormalBtEdgeLight[1][0] = + m_pThemeData->clrNormalBtEdgeLight[0][0]; + m_pThemeData->clrNormalBtEdgeDark[1][0] = + m_pThemeData->clrNormalBtEdgeDark[0][0]; + m_pThemeData->clrNormalBtEdgeLight[1][1] = + m_pThemeData->clrNormalBtEdgeLight[0][1]; + m_pThemeData->clrNormalBtEdgeDark[1][1] = + m_pThemeData->clrNormalBtEdgeDark[0][1]; + m_pThemeData->clrNormalBtEdgeLight[1][2] = + m_pThemeData->clrNormalBtEdgeLight[0][2]; + m_pThemeData->clrNormalBtEdgeDark[1][2] = + m_pThemeData->clrNormalBtEdgeDark[0][2]; + m_pThemeData->clrBtnCornerLight[1][0] = m_pThemeData->clrBtnCornerLight[0][0]; + m_pThemeData->clrBtnCornerLight[1][1] = m_pThemeData->clrBtnCornerLight[0][1]; + m_pThemeData->clrBtnCornerLight[1][2] = m_pThemeData->clrBtnCornerLight[0][2]; + m_pThemeData->clrBtnEdgeOut[1] = m_pThemeData->clrBtnEdgeOut[0]; + m_pThemeData->clrFormBorder[1][0] = m_pThemeData->clrFormBorder[0][0]; + m_pThemeData->clrFormBorder[1][1] = m_pThemeData->clrFormBorder[0][1]; + m_pThemeData->clrFormBorder[1][2] = m_pThemeData->clrFormBorder[0][2]; + m_pThemeData->clrFormBorder[1][3] = m_pThemeData->clrFormBorder[0][3]; + m_pThemeData->clrFormBorder[1][4] = m_pThemeData->clrFormBorder[0][4]; + m_pThemeData->clrFormBorderLight[1] = m_pThemeData->clrFormBorderLight[0]; + DeactiveForm(); +} +void CFWL_FormTP::DeactiveForm() { + TransModeColor(m_pThemeData->clrTransWhite, m_pThemeData->clrHeadBK[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, m_pThemeData->clrHeadBK[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, m_pThemeData->clrHeadBK[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, m_pThemeData->clrHeadBK[1][3]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrHeadEdgeLeft[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrHeadEdgeLeft[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrHeadEdgeLeft[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrHeadEdgeRight[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrHeadEdgeRight[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrHeadEdgeRight[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrHeadEdgeTop[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrHeadEdgeTop[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrHeadEdgeTop[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrHeadEdgeBottom[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrHeadEdgeBottom[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrHeadEdgeBottom[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrNormalBtBKStart[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrNormalBtBKStart[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrNormalBtBKStart[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrNormalBtBKEnd[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrNormalBtBKEnd[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrNormalBtBKEnd[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrNormalBtEdgeLight[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrNormalBtEdgeLight[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrNormalBtEdgeLight[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrNormalBtEdgeDark[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrNormalBtEdgeDark[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrNormalBtEdgeDark[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrBtnCornerLight[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrBtnCornerLight[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrBtnCornerLight[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, m_pThemeData->clrBtnEdgeOut[1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrFormBorder[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrFormBorder[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrFormBorder[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrFormBorder[1][3]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrFormBorder[1][4]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrFormBorderLight[1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrCloseBtBKStart[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrCloseBtBKStart[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrCloseBtBKStart[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrCloseBtBKEnd[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrCloseBtBKEnd[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrCloseBtBKEnd[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrCloseBtEdgeLight[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrCloseBtEdgeLight[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrCloseBtEdgeLight[1][2]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrCloseBtEdgeDark[1][0]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrCloseBtEdgeDark[1][1]); + TransModeColor(m_pThemeData->clrTransWhite, + m_pThemeData->clrCloseBtEdgeDark[1][2]); +} +void CFWL_FormTP::TransModeColor(FX_ARGB clrFore, FX_ARGB& clrBack) { + int32_t iAlfaF, iRF, iGF, iBF; + int32_t iAlfaB, iRB, iGB, iBB; + ArgbDecode(clrFore, iAlfaF, iRF, iGF, iBF); + ArgbDecode(clrBack, iAlfaB, iRB, iGB, iBB); + clrBack = ArgbEncode(0xff, iRB + (iRF - iRB) * iAlfaF / 255, + iGB + (iGF - iGB) * iAlfaF / 255, + iBB + (iBF - iBB) * iAlfaF / 255); +} +void CFWL_FormTP::InitCaption(FX_BOOL bActive) { + if (bActive) { + CFX_FxgeDevice dev; + CFX_Graphics gs; + CFX_Path path; + path.Create(); + if (m_pActiveBitmap) { + delete m_pActiveBitmap; + m_pActiveBitmap = NULL; + } + m_pActiveBitmap = new CFX_DIBitmap; + m_pActiveBitmap->Create(1, FWLTHEME_CAPACITY_CYCaption, FXDIB_Argb); + dev.Attach(m_pActiveBitmap); + gs.Create(&dev); + path.AddRectangle(0, 0, 1, 5); + DrawAxialShading(&gs, 0, 0, 0, 5, m_pThemeData->clrHeadBK[0][0], + m_pThemeData->clrHeadBK[0][1], &path); + path.Clear(); + path.AddRectangle(0, 5, 1, 15); + DrawAxialShading(&gs, 0, 5, 0, 20, m_pThemeData->clrHeadBK[0][1], + m_pThemeData->clrHeadBK[0][2], &path); + path.Clear(); + path.AddRectangle(0, 20, 1, FWLTHEME_CAPACITY_CYCaption - 19); + DrawAxialShading(&gs, 0, 20, 0, FWLTHEME_CAPACITY_CYCaption, + m_pThemeData->clrHeadBK[0][2], + m_pThemeData->clrHeadBK[0][3], &path); + } else { + CFX_FxgeDevice dev; + CFX_Graphics gs; + CFX_Path path; + path.Create(); + if (m_pDeactivebitmap) { + delete m_pDeactivebitmap; + m_pDeactivebitmap = NULL; + } + m_pDeactivebitmap = new CFX_DIBitmap; + m_pDeactivebitmap->Create(1, FWLTHEME_CAPACITY_CYCaption, FXDIB_Argb); + dev.Attach(m_pDeactivebitmap); + gs.Create(&dev); + path.AddRectangle(0, 0, 1, 5); + DrawAxialShading(&gs, 0, 0, 0, 5, m_pThemeData->clrHeadBK[1][0], + m_pThemeData->clrHeadBK[1][1], &path); + path.Clear(); + path.AddRectangle(0, 5, 1, 15); + DrawAxialShading(&gs, 0, 5, 0, 20, m_pThemeData->clrHeadBK[1][1], + m_pThemeData->clrHeadBK[1][2], &path); + path.Clear(); + path.AddRectangle(0, 20, 1, FWLTHEME_CAPACITY_CYCaption - 19); + DrawAxialShading(&gs, 0, 20, 0, FWLTHEME_CAPACITY_CYCaption, + m_pThemeData->clrHeadBK[1][2], + m_pThemeData->clrHeadBK[1][3], &path); + } +} diff --git a/xfa/fwl/theme/listboxtp.cpp b/xfa/fwl/theme/listboxtp.cpp new file mode 100644 index 0000000000..8ffe669835 --- /dev/null +++ b/xfa/fwl/theme/listboxtp.cpp @@ -0,0 +1,101 @@ +// 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 "xfa/include/fwl/theme/listboxtp.h" + +#include "xfa/include/fwl/basewidget/fwl_listbox.h" +#include "xfa/include/fwl/core/fwl_widget.h" + +CFWL_ListBoxTP::CFWL_ListBoxTP() {} +CFWL_ListBoxTP::~CFWL_ListBoxTP() {} + +FX_BOOL CFWL_ListBoxTP::IsValidWidget(IFWL_Widget* pWidget) { + if (!pWidget) + return FALSE; + return pWidget->GetClassID() == FWL_CLASSHASH_ListBox; +} +FX_BOOL CFWL_ListBoxTP::DrawBackground(CFWL_ThemeBackground* pParams) { + if (!pParams) + return FALSE; + switch (pParams->m_iPart) { + case FWL_PART_LTB_Border: { + DrawBorder(pParams->m_pGraphics, &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_LTB_Edge: { + DrawEdge(pParams->m_pGraphics, pParams->m_pWidget->GetStyles(), + &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_LTB_Background: { + FillSoildRect(pParams->m_pGraphics, ArgbEncode(255, 255, 255, 255), + &pParams->m_rtPart, &pParams->m_matrix); + if (pParams->m_pData) { + FillSoildRect(pParams->m_pGraphics, FWLTHEME_COLOR_Background, + (CFX_RectF*)pParams->m_pData, &pParams->m_matrix); + } + break; + } + case FWL_PART_LTB_ListItem: { + DrawListBoxItem(pParams->m_pGraphics, pParams->m_dwStates, + &pParams->m_rtPart, pParams->m_pData, &pParams->m_matrix); + break; + } + case FWL_PART_LTB_Icon: { + pParams->m_pGraphics->StretchImage(pParams->m_pImage, pParams->m_rtPart, + &pParams->m_matrix); + break; + } + case FWL_PART_LTB_Check: { + FX_DWORD color = 0xFF000000; + if (pParams->m_dwStates == FWL_PARTSTATE_LTB_Checked) { + color = 0xFFFF0000; + } else if (pParams->m_dwStates == FWL_PARTSTATE_LTB_UnChecked) { + color = 0xFF0000FF; + } + FillSoildRect(pParams->m_pGraphics, color, &pParams->m_rtPart, + &pParams->m_matrix); + } + default: {} + } + return TRUE; +} +FWL_ERR CFWL_ListBoxTP::Initialize() { + InitTTO(); + return CFWL_WidgetTP::Initialize(); +} +FWL_ERR CFWL_ListBoxTP::Finalize() { + FinalizeTTO(); + return CFWL_WidgetTP::Finalize(); +} +void CFWL_ListBoxTP::DrawListBoxItem(CFX_Graphics* pGraphics, + FX_DWORD dwStates, + const CFX_RectF* prtItem, + void* pData, + CFX_Matrix* pMatrix) { + if (dwStates & FWL_PARTSTATE_LTB_Selected) { + pGraphics->SaveGraphState(); + CFX_Color crFill(FWL_GetThemeColor(m_dwThemeID) == 0 + ? FWLTHEME_COLOR_BKSelected + : FWLTHEME_COLOR_Green_BKSelected); + pGraphics->SetFillColor(&crFill); + CFX_RectF rt(*prtItem); + CFX_Path path; + path.Create(); +#if (_FX_OS_ == _FX_MACOSX_) + path.AddRectangle(rt.left, rt.top, rt.width - 1, rt.height - 1); +#else + path.AddRectangle(rt.left, rt.top, rt.width, rt.height); +#endif + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pGraphics->RestoreGraphState(); + } + if (dwStates & FWL_PARTSTATE_LTB_Focused) { + if (pData) { + DrawFocus(pGraphics, (CFX_RectF*)pData, pMatrix); + } + } +} diff --git a/xfa/fwl/theme/monthcalendartp.cpp b/xfa/fwl/theme/monthcalendartp.cpp new file mode 100644 index 0000000000..6ab99ae439 --- /dev/null +++ b/xfa/fwl/theme/monthcalendartp.cpp @@ -0,0 +1,582 @@ +// 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 "xfa/include/fwl/theme/monthcalendartp.h" + +#include "xfa/fde/tto/fde_textout.h" +#include "xfa/include/fwl/basewidget/fwl_monthcalendar.h" +#include "xfa/include/fwl/core/fwl_widget.h" + +#define FWL_THEMECAPACITY_MC_HEADER_WIDTH 200 +#define FWL_THEMECAPACITY_MC_HEADER_HEIGHT 30 +#define FWL_THEMECAPACITY_MC_HEADER_BTN_WIDTH 18 +#define FWL_THEMECAPACITY_MC_HEADER_BTN_HEIGHT 16 +#define FWL_THEMECAPACITY_MC_HEADER_BTN_HMARGIN 5 +#define FWL_THEMECAPACITY_MC_HEADER_BTN_VMARGIN \ + (FWL_THEMECAPACITY_MC_HEADER_HEIGHT - \ + FWL_THEMECAPACITY_MC_HEADER_BTN_HEIGHT) / \ + 2 +#define FWL_THEMECAPACITY_MC_HEADER_TEXTWIDHT 100 +#define FWL_THEMECAPACITY_MC_HEADER_TEXTHEIGHT 20 +#define FWL_THEMECAPACITY_MC_HEADER_TEXT_HMARGIN \ + (FWL_THEMECAPACITY_MC_HEADER_WIDTH - \ + FWL_THEMECAPACITY_MC_HEADER_TEXTWIDHT) / \ + 2 +#define FWL_THEMECAPACITY_MC_HEADER_TEXT_VMARGIN \ + (FWL_THEMECAPACITY_MC_HEADER_HEIGHT - \ + FWL_THEMECAPACITY_MC_HEADER_TEXTHEIGHT) / \ + 2 +#define FWL_THEMECAPACITY_MC_HSEP_WIDTH (FWL_THEMECAPACITY_MC_WEEK_WIDTH - 10) +#define FWL_THEMECAPACITY_MC_HSEP_HEIGHT 1 +#define FWL_THEMECAPACITY_MC_VSEP_WIDTH 1 +#define FWL_THEMECAPACITY_MC_VSEP_HEIGHT FWL_THEMECAPACITY_MC_WEEKNUM_HEIGHT +#define FWL_THEMECAPACITY_MC_WEEKNUM_WIDTH 26 +#define FWL_THEMECAPACITY_MC_SEP_DOFFSET -4 +#define FWL_THEMECAPACITY_MC_SEP_X 3 +#define FWL_THEMECAPACITY_MC_SEP_Y \ + (FWL_THEMECAPACITY_MC_HEADER_HEIGHT + FWL_THEMECAPACITY_MC_WEEK_HEIGHT + \ + FWL_THEMECAPACITY_MC_SEP_DOFFSET) +#define FWL_THEMECAPACITY_MC_WEEKNUM_HEIGHT \ + (6 * FWL_THEMECAPACITY_MC_DATES_CELL_HEIGHT) +#define FWL_THEMECAPACITY_MC_WEEK_WIDTH \ + (FWL_THEMECAPACITY_MC_DATES_CELL_WIDTH * 7) +#define FWL_THEMECAPACITY_MC_WEEK_HEIGHT FWL_THEMECAPACITY_MC_DATES_CELL_HEIGHT +#define FWL_THEMECAPACITY_MC_DATES_CELL_WIDTH \ + (FWL_THEMECAPACITY_MC_HEADER_WIDTH / 7) +#define FWL_THEMECAPACITY_MC_DATES_CELL_HEIGHT 16 +#define FWL_THEMECAPACITY_MC_TODAY_WIDHT FWL_THEMECAPACITY_MC_HEADER_WIDTH +#define FWL_THEMECAPACITY_MC_TODAY_HEIGHT FWL_THEMECAPACITY_MC_DATES_CELL_HEIGHT +#define FWL_THEMECAPACITY_MC_TODAY_FLAG_WIDHT \ + FWL_THEMECAPACITY_MC_DATES_CELL_WIDTH +#define FWL_MC_WIDTH 200 +#define FWL_MC_HEIGHT 160 + +CFWL_MonthCalendarTP::CFWL_MonthCalendarTP() { + m_pThemeData = new MCThemeData; + SetThemeData(0); +} +CFWL_MonthCalendarTP::~CFWL_MonthCalendarTP() { + delete m_pThemeData; +} +FX_BOOL CFWL_MonthCalendarTP::IsValidWidget(IFWL_Widget* pWidget) { + if (!pWidget) + return FALSE; + return pWidget->GetClassID() == FWL_CLASSHASH_MonthCalendar; +} +FX_DWORD CFWL_MonthCalendarTP::SetThemeID(IFWL_Widget* pWidget, + FX_DWORD dwThemeID, + FX_BOOL bChildren) { + if (m_pThemeData) { + SetThemeData(FWL_GetThemeColor(dwThemeID)); + } + return CFWL_WidgetTP::SetThemeID(pWidget, dwThemeID, bChildren); +} +FX_BOOL CFWL_MonthCalendarTP::DrawBackground(CFWL_ThemeBackground* pParams) { + if (!pParams) + return FALSE; + switch (pParams->m_iPart) { + case FWL_PART_MCD_Border: { + DrawBorder(pParams->m_pGraphics, &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_MCD_Edge: { + DrawEdge(pParams->m_pGraphics, pParams->m_pWidget->GetStyles(), + &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_MCD_Background: { + DrawTotalBK(pParams, &pParams->m_matrix); + break; + } + case FWL_PART_MCD_Header: { + DrawHeadBk(pParams, &pParams->m_matrix); + break; + } + case FWL_PART_MCD_LBtn: { +#ifdef THEME_XPSimilar + FWLTHEME_STATE eState = GetState(pParams->m_dwStates); + DrawArrowBtn(pParams->m_pGraphics, &pParams->m_rtPart, + FWLTHEME_DIRECTION_Left, eState, &pParams->m_matrix); +#else + DrawLButton(pParams, &pParams->m_matrix); +#endif + break; + } + case FWL_PART_MCD_RBtn: { +#ifdef THEME_XPSimilar + FWLTHEME_STATE eState = GetState(pParams->m_dwStates); + DrawArrowBtn(pParams->m_pGraphics, &pParams->m_rtPart, + FWLTHEME_DIRECTION_Right, eState, &pParams->m_matrix); +#else + DrawRButton(pParams, &pParams->m_matrix); +#endif + break; + } + case FWL_PART_MCD_HSeparator: { + DrawHSeperator(pParams, &pParams->m_matrix); + break; + } + case FWL_PART_MCD_DatesIn: { + DrawDatesInBK(pParams, &pParams->m_matrix); + break; + } + case FWL_PART_MCD_TodayCircle: { + DrawTodayCircle(pParams, &pParams->m_matrix); + break; + } + case FWL_PART_MCD_DateInCircle: { + DrawDatesInCircle(pParams, &pParams->m_matrix); + break; + } + case FWL_PART_MCD_WeekNumSep: { + DrawWeekNumSep(pParams, &pParams->m_matrix); + break; + } + default: {} + } + return TRUE; +} +FX_BOOL CFWL_MonthCalendarTP::DrawText(CFWL_ThemeText* pParams) { + if (!m_pTextOut) + return FALSE; + if ((pParams->m_iPart == FWL_PART_MCD_DatesIn) && + !(pParams->m_dwStates & FWL_ITEMSTATE_MCD_Flag) && + (pParams->m_dwStates & + (FWL_PARTSTATE_MCD_Hovered | FWL_PARTSTATE_MCD_Selected))) { + m_pTextOut->SetTextColor(0xFFFFFFFF); + } else if (pParams->m_iPart == FWL_PART_MCD_Caption) { + m_pTextOut->SetTextColor(m_pThemeData->clrCaption); + } else { + m_pTextOut->SetTextColor(0xFF000000); + } + return CFWL_WidgetTP::DrawText(pParams); +} +void* CFWL_MonthCalendarTP::GetCapacity(CFWL_ThemePart* pThemePart, + FX_DWORD dwCapacity) { + FX_BOOL bDefPro = FALSE; + FX_BOOL bDwordVal = FALSE; + switch (dwCapacity) { + case FWL_WGTCAPACITY_MC_HEADER_WIDTH: { + m_fValue = FWL_THEMECAPACITY_MC_HEADER_WIDTH; + break; + } + case FWL_WGTCAPACITY_MC_HEADER_Height: { + m_fValue = FWL_THEMECAPACITY_MC_HEADER_HEIGHT; + break; + } + case FWL_WGTCAPACITY_MC_HEADER_BTN_WIDTH: { + m_fValue = FWL_THEMECAPACITY_MC_HEADER_BTN_WIDTH; + break; + } + case FWL_WGTCAPACITY_MC_HEADER_BTN_HEIGHT: { + m_fValue = FWL_THEMECAPACITY_MC_HEADER_BTN_HEIGHT; + break; + } + case FWL_WGTCAPACITY_MC_HEADER_BTN_HMARGIN: { + bDwordVal = TRUE; + m_dwValue = FWL_THEMECAPACITY_MC_HEADER_BTN_HMARGIN; + break; + } + case FWL_WGTCAPACITY_MC_HEADER_BTN_VMARGIN: { + m_fValue = FWL_THEMECAPACITY_MC_HEADER_BTN_VMARGIN; + break; + } + case FWL_WGTCAPACITY_MC_HEADER_TEXTWIDHT: { + m_fValue = FWL_THEMECAPACITY_MC_HEADER_TEXTWIDHT; + break; + } + case FWL_WGTCAPACITY_MC_HEADER_TEXTHEIGHT: { + m_fValue = FWL_THEMECAPACITY_MC_HEADER_TEXTHEIGHT; + break; + } + case FWL_WGTCAPACITY_MC_HEADER_TEXT_HMARGIN: { + m_fValue = FWL_THEMECAPACITY_MC_HEADER_TEXT_HMARGIN; + break; + } + case FWL_WGTCAPACITY_MC_HEADER_TEXT_VMARGIN: { + m_fValue = FWL_THEMECAPACITY_MC_HEADER_TEXT_VMARGIN; + break; + } + case FWL_WGTCAPACITY_MC_HSEP_WIDTH: { + m_fValue = FWL_THEMECAPACITY_MC_HSEP_WIDTH; + break; + } + case FWL_WGTCAPACITY_MC_HSEP_HEIGHT: { + m_fValue = FWL_THEMECAPACITY_MC_HSEP_HEIGHT; + break; + } + case FWL_WGTCAPACITY_MC_VSEP_WIDTH: { + m_fValue = FWL_THEMECAPACITY_MC_VSEP_WIDTH; + break; + } + case FWL_WGTCAPACITY_MC_VSEP_HEIGHT: { + m_fValue = FWL_THEMECAPACITY_MC_VSEP_HEIGHT; + break; + } + case FWL_WGTCAPACITY_MC_WEEKNUM_WIDTH: { + m_fValue = FWL_THEMECAPACITY_MC_WEEKNUM_WIDTH; + break; + } + case FWL_WGTCAPACITY_MC_WEEKNUM_HEIGHT: { + m_fValue = FWL_THEMECAPACITY_MC_WEEKNUM_HEIGHT; + break; + } + case FWL_WGTCAPACITY_MC_WEEK_WIDTH: { + m_fValue = FWL_THEMECAPACITY_MC_WEEK_WIDTH; + break; + } + case FWL_WGTCAPACITY_MC_WEEK_HEIGHT: { + m_fValue = FWL_THEMECAPACITY_MC_WEEK_HEIGHT; + break; + } + case FWL_WGTCAPACITY_MC_SEP_DOFFSET: { + m_fValue = FWL_THEMECAPACITY_MC_SEP_DOFFSET; + break; + } + case FWL_WGTCAPACITY_MC_SEP_X: { + m_fValue = FWL_THEMECAPACITY_MC_SEP_X; + break; + } + case FWL_WGTCAPACITY_MC_SEP_Y: { + m_fValue = FWL_THEMECAPACITY_MC_SEP_Y; + break; + } + case FWL_WGTCAPACITY_MC_DATES_CELL_WIDTH: { + m_fValue = FWL_THEMECAPACITY_MC_DATES_CELL_WIDTH; + break; + } + case FWL_WGTCAPACITY_MC_DATES_CELL_HEIGHT: { + m_fValue = FWL_THEMECAPACITY_MC_DATES_CELL_HEIGHT; + break; + } + case FWL_WGTCAPACITY_MC_TODAY_WIDHT: { + m_fValue = FWL_THEMECAPACITY_MC_TODAY_WIDHT; + break; + } + case FWL_WGTCAPACITY_MC_TODAY_HEIGHT: { + m_fValue = FWL_THEMECAPACITY_MC_TODAY_HEIGHT; + break; + } + case FWL_WGTCAPACITY_MC_TODAY_FLAG_WIDHT: { + m_fValue = FWL_THEMECAPACITY_MC_TODAY_FLAG_WIDHT; + break; + } + case FWL_WGTCAPACITY_MC_WIDTH: { + m_fValue = FWL_MC_WIDTH; + break; + } + case FWL_WGTCAPACITY_MC_HEIGHT: { + m_fValue = FWL_MC_HEIGHT; + break; + } + case FWL_MCCAPACITY_Sun: { + wsResource = L"Sun"; + return &wsResource; + } + case FWL_MCCAPACITY_Mon: { + wsResource = L"Mon"; + return &wsResource; + } + case FWL_MCCAPACITY_Tue: { + wsResource = L"Tue"; + return &wsResource; + } + case FWL_MCCAPACITY_Wed: { + wsResource = L"Wed"; + return &wsResource; + } + case FWL_MCCAPACITY_Thu: { + wsResource = L"Thu"; + return &wsResource; + } + case FWL_MCCAPACITY_Fri: { + wsResource = L"Fri"; + return &wsResource; + } + case FWL_MCCAPACITY_Sat: { + wsResource = L"Sat"; + return &wsResource; + } + case FWL_MCCAPACITY_January: { + wsResource = L"January"; + return &wsResource; + } + case FWL_MCCAPACITY_February: { + wsResource = L"February"; + return &wsResource; + } + case FWL_MCCAPACITY_March: { + wsResource = L"March"; + return &wsResource; + } + case FWL_MCCAPACITY_April: { + wsResource = L"April"; + return &wsResource; + } + case FWL_MCCAPACITY_May: { + wsResource = L"May"; + return &wsResource; + } + case FWL_MCCAPACITY_June: { + wsResource = L"June"; + return &wsResource; + } + case FWL_MCCAPACITY_July: { + wsResource = L"July"; + return &wsResource; + } + case FWL_MCCAPACITY_August: { + wsResource = L"August"; + return &wsResource; + } + case FWL_MCCAPACITY_September: { + wsResource = L"September"; + return &wsResource; + } + case FWL_MCCAPACITY_October: { + wsResource = L"October"; + return &wsResource; + } + case FWL_MCCAPACITY_November: { + wsResource = L"November"; + return &wsResource; + } + case FWL_MCCAPACITY_December: { + wsResource = L"December"; + return &wsResource; + } + case FWL_MCCAPACITY_Today: { + wsResource = L"Today"; + return &wsResource; + } + default: { bDefPro = TRUE; } + } + if (!bDefPro) { + if (bDwordVal) { + return &m_dwValue; + } + return &m_fValue; + } + return CFWL_WidgetTP::GetCapacity(pThemePart, dwCapacity); +} +FWL_ERR CFWL_MonthCalendarTP::Initialize() { + InitTTO(); + return CFWL_WidgetTP::Initialize(); +} +FWL_ERR CFWL_MonthCalendarTP::Finalize() { + FinalizeTTO(); + return CFWL_WidgetTP::Finalize(); +} +FX_BOOL CFWL_MonthCalendarTP::DrawTotalBK(CFWL_ThemeBackground* pParams, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + CFX_RectF rtTotal(pParams->m_rtPart); + path.AddRectangle(rtTotal.left, rtTotal.top, rtTotal.width, rtTotal.height); + pParams->m_pGraphics->SaveGraphState(); + CFX_Color clrBK(m_pThemeData->clrBK); + pParams->m_pGraphics->SetFillColor(&clrBK); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pParams->m_pGraphics->RestoreGraphState(); + return TRUE; +} +FX_BOOL CFWL_MonthCalendarTP::DrawHeadBk(CFWL_ThemeBackground* pParams, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + CFX_RectF rtHead = pParams->m_rtPart; + path.AddRectangle(rtHead.left, rtHead.top, rtHead.width, rtHead.height); + pParams->m_pGraphics->SaveGraphState(); + CFX_Color clrHeadBK(m_pThemeData->clrBK); + pParams->m_pGraphics->SetFillColor(&clrHeadBK); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pParams->m_pGraphics->RestoreGraphState(); + return TRUE; +} +FX_BOOL CFWL_MonthCalendarTP::DrawLButton(CFWL_ThemeBackground* pParams, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + CFX_RectF rtLBtn; + rtLBtn = pParams->m_rtPart; + path.AddRectangle(rtLBtn.left, rtLBtn.top, rtLBtn.width, rtLBtn.height); + pParams->m_pGraphics->SaveGraphState(); + CFX_Color clrLBtnEdge(ArgbEncode(0xff, 205, 219, 243)); + pParams->m_pGraphics->SetStrokeColor(&clrLBtnEdge); + pParams->m_pGraphics->StrokePath(&path, pMatrix); + if ((pParams->m_dwStates & FWL_PARTSTATE_MCD_Pressed) == + FWL_PARTSTATE_MCD_Pressed) { + CFX_Color clrLBtnFill(ArgbEncode(0xff, 174, 198, 242)); + pParams->m_pGraphics->SetFillColor(&clrLBtnFill); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + } else { + CFX_Color clrLBtnFill(ArgbEncode(0xff, 227, 235, 249)); + pParams->m_pGraphics->SetFillColor(&clrLBtnFill); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + } + path.Clear(); + path.MoveTo(rtLBtn.left + rtLBtn.Width() / 3 * 2, + rtLBtn.top + rtLBtn.height / 4); + path.LineTo(rtLBtn.left + rtLBtn.Width() / 3, rtLBtn.top + rtLBtn.height / 2); + path.LineTo(rtLBtn.left + rtLBtn.Width() / 3 * 2, + rtLBtn.bottom() - rtLBtn.height / 4); + CFX_Color clrFlag(ArgbEncode(0xff, 50, 104, 205)); + pParams->m_pGraphics->SetStrokeColor(&clrFlag); + pParams->m_pGraphics->StrokePath(&path, pMatrix); + pParams->m_pGraphics->RestoreGraphState(); + return TRUE; +} +FX_BOOL CFWL_MonthCalendarTP::DrawRButton(CFWL_ThemeBackground* pParams, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + CFX_RectF rtRBtn; + rtRBtn = pParams->m_rtPart; + path.AddRectangle(rtRBtn.left, rtRBtn.top, rtRBtn.width, rtRBtn.height); + pParams->m_pGraphics->SaveGraphState(); + CFX_Color clrRBtnEdge(ArgbEncode(0xff, 205, 219, 243)); + pParams->m_pGraphics->SetStrokeColor(&clrRBtnEdge); + pParams->m_pGraphics->StrokePath(&path, pMatrix); + if ((pParams->m_dwStates & FWL_PARTSTATE_MCD_Pressed) == + FWL_PARTSTATE_MCD_Pressed) { + CFX_Color clrRBtnFill(ArgbEncode(0xff, 174, 198, 242)); + pParams->m_pGraphics->SetFillColor(&clrRBtnFill); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + } else { + CFX_Color clrRBtnFill(ArgbEncode(0xff, 227, 235, 249)); + pParams->m_pGraphics->SetFillColor(&clrRBtnFill); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + } + path.Clear(); + path.MoveTo(rtRBtn.left + rtRBtn.Width() / 3, rtRBtn.top + rtRBtn.height / 4); + path.LineTo(rtRBtn.left + rtRBtn.Width() / 3 * 2, + rtRBtn.top + rtRBtn.height / 2); + path.LineTo(rtRBtn.left + rtRBtn.Width() / 3, + rtRBtn.bottom() - rtRBtn.height / 4); + CFX_Color clrFlag(ArgbEncode(0xff, 50, 104, 205)); + pParams->m_pGraphics->SetStrokeColor(&clrFlag); + pParams->m_pGraphics->StrokePath(&path, pMatrix); + pParams->m_pGraphics->RestoreGraphState(); + return TRUE; +} +FX_BOOL CFWL_MonthCalendarTP::DrawHSeperator(CFWL_ThemeBackground* pParams, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + CFX_RectF rtHSep; + rtHSep = pParams->m_rtPart; + path.MoveTo(rtHSep.left, rtHSep.top + rtHSep.height / 2); + path.LineTo(rtHSep.right(), rtHSep.top + rtHSep.height / 2); + pParams->m_pGraphics->SaveGraphState(); + CFX_Color clrHSep(m_pThemeData->clrSeperator); + pParams->m_pGraphics->SetStrokeColor(&clrHSep); + pParams->m_pGraphics->StrokePath(&path, pMatrix); + pParams->m_pGraphics->RestoreGraphState(); + return TRUE; +} +FX_BOOL CFWL_MonthCalendarTP::DrawWeekNumSep(CFWL_ThemeBackground* pParams, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + CFX_RectF rtWeekSep; + rtWeekSep = pParams->m_rtPart; + path.MoveTo(rtWeekSep.left, rtWeekSep.top); + path.LineTo(rtWeekSep.left, rtWeekSep.bottom()); + pParams->m_pGraphics->SaveGraphState(); + CFX_Color clrHSep(m_pThemeData->clrSeperator); + pParams->m_pGraphics->SetStrokeColor(&clrHSep); + pParams->m_pGraphics->StrokePath(&path, pMatrix); + pParams->m_pGraphics->RestoreGraphState(); + return TRUE; +} +FX_BOOL CFWL_MonthCalendarTP::DrawDatesInBK(CFWL_ThemeBackground* pParams, + CFX_Matrix* pMatrix) { + pParams->m_pGraphics->SaveGraphState(); + if (pParams->m_dwStates & FWL_PARTSTATE_MCD_Selected) { + CFX_Path path; + path.Create(); + CFX_RectF rtSelDay; + rtSelDay = pParams->m_rtPart; + path.AddRectangle(rtSelDay.left, rtSelDay.top, rtSelDay.width, + rtSelDay.height); + CFX_Color clrSelDayBK; + clrSelDayBK = m_pThemeData->clrDatesSelectedBK; + pParams->m_pGraphics->SetFillColor(&clrSelDayBK); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + } else if (pParams->m_dwStates & FWL_PARTSTATE_MCD_Hovered) { + CFX_Path path; + path.Create(); + CFX_RectF rtSelDay; + rtSelDay = pParams->m_rtPart; + path.AddRectangle(rtSelDay.left, rtSelDay.top, rtSelDay.width, + rtSelDay.height); + CFX_Color clrSelDayBK; + clrSelDayBK = m_pThemeData->clrDatesHoverBK; + pParams->m_pGraphics->SetFillColor(&clrSelDayBK); + pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + } + pParams->m_pGraphics->RestoreGraphState(); + return FALSE; +} +FX_BOOL CFWL_MonthCalendarTP::DrawDatesInCircle(CFWL_ThemeBackground* pParams, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + CFX_RectF rtSelDay; + rtSelDay = pParams->m_rtPart; + path.AddRectangle(rtSelDay.left, rtSelDay.top, rtSelDay.width, + rtSelDay.height); + pParams->m_pGraphics->SaveGraphState(); + CFX_Color clrSelDayBK; + clrSelDayBK = m_pThemeData->clrDatesCircle; + pParams->m_pGraphics->SetStrokeColor(&clrSelDayBK); + pParams->m_pGraphics->StrokePath(&path, pMatrix); + pParams->m_pGraphics->RestoreGraphState(); + return TRUE; +} +FX_BOOL CFWL_MonthCalendarTP::DrawTodayCircle(CFWL_ThemeBackground* pParams, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + CFX_RectF rtTodayCircle; + rtTodayCircle = pParams->m_rtPart; + path.AddRectangle(rtTodayCircle.left, rtTodayCircle.top, rtTodayCircle.width, + rtTodayCircle.height); + pParams->m_pGraphics->SaveGraphState(); + CFX_Color clrTodayCircle; + clrTodayCircle = m_pThemeData->clrDatesCircle; + pParams->m_pGraphics->SetStrokeColor(&clrTodayCircle); + pParams->m_pGraphics->StrokePath(&path, pMatrix); + pParams->m_pGraphics->RestoreGraphState(); + return TRUE; +} +FWLTHEME_STATE CFWL_MonthCalendarTP::GetState(FX_DWORD dwFWLStates) { + if (dwFWLStates & FWL_PARTSTATE_MCD_Hovered) { + return FWLTHEME_STATE_Hover; + } else if (dwFWLStates & FWL_PARTSTATE_MCD_Pressed) { + return FWLTHEME_STATE_Pressed; + } + return FWLTHEME_STATE_Normal; +} +void CFWL_MonthCalendarTP::SetThemeData(FX_DWORD dwThemeID) { + if (dwThemeID == 0) { + m_pThemeData->clrCaption = ArgbEncode(0xff, 0, 153, 255); + m_pThemeData->clrSeperator = ArgbEncode(0xff, 141, 161, 239); + m_pThemeData->clrDatesHoverBK = ArgbEncode(0xff, 193, 211, 251); + m_pThemeData->clrDatesSelectedBK = ArgbEncode(0xff, 173, 188, 239); + m_pThemeData->clrDatesCircle = ArgbEncode(0xff, 103, 144, 209); + m_pThemeData->clrToday = ArgbEncode(0xff, 0, 0, 0); + m_pThemeData->clrBK = ArgbEncode(0xff, 255, 255, 255); + } else { + m_pThemeData->clrCaption = ArgbEncode(0xff, 128, 128, 0); + m_pThemeData->clrSeperator = ArgbEncode(0xff, 128, 128, 64); + m_pThemeData->clrDatesHoverBK = ArgbEncode(0xff, 217, 220, 191); + m_pThemeData->clrDatesSelectedBK = ArgbEncode(0xff, 204, 208, 183); + m_pThemeData->clrDatesCircle = ArgbEncode(0xff, 128, 128, 0); + m_pThemeData->clrToday = ArgbEncode(0xff, 0, 0, 0); + m_pThemeData->clrBK = ArgbEncode(0xff, 255, 255, 255); + } +} diff --git a/xfa/fwl/theme/pictureboxtp.cpp b/xfa/fwl/theme/pictureboxtp.cpp new file mode 100644 index 0000000000..5d7c079e86 --- /dev/null +++ b/xfa/fwl/theme/pictureboxtp.cpp @@ -0,0 +1,36 @@ +// 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 "xfa/include/fwl/theme/pictureboxtp.h" + +#include "xfa/include/fwl/basewidget/fwl_picturebox.h" +#include "xfa/include/fwl/core/fwl_widget.h" + +CFWL_PictureBoxTP::CFWL_PictureBoxTP() {} +CFWL_PictureBoxTP::~CFWL_PictureBoxTP() {} + +FX_BOOL CFWL_PictureBoxTP::IsValidWidget(IFWL_Widget* pWidget) { + if (!pWidget) + return FALSE; + return pWidget->GetClassID() == FWL_CLASSHASH_PictureBox; +} +FX_BOOL CFWL_PictureBoxTP::DrawBackground(CFWL_ThemeBackground* pParams) { + if (!pParams) + return FALSE; + switch (pParams->m_iPart) { + case FWL_PART_PTB_Border: { + DrawBorder(pParams->m_pGraphics, &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_PTB_Edge: { + DrawEdge(pParams->m_pGraphics, pParams->m_pWidget->GetStyles(), + &pParams->m_rtPart, &pParams->m_matrix); + break; + } + default: {} + } + return TRUE; +} diff --git a/xfa/fwl/theme/pushbuttontp.cpp b/xfa/fwl/theme/pushbuttontp.cpp new file mode 100644 index 0000000000..76e0eab7dc --- /dev/null +++ b/xfa/fwl/theme/pushbuttontp.cpp @@ -0,0 +1,157 @@ +// 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 "xfa/include/fwl/theme/pushbuttontp.h" + +#include "xfa/include/fwl/basewidget/fwl_pushbutton.h" +#include "xfa/include/fwl/core/fwl_widget.h" + +#define PUSHBUTTON_SIZE_Corner 2 + +CFWL_PushButtonTP::CFWL_PushButtonTP() { + m_pThemeData = new PBThemeData; + SetThemeData(0); +} +CFWL_PushButtonTP::~CFWL_PushButtonTP() { + if (m_pThemeData) { + delete m_pThemeData; + } +} +FX_BOOL CFWL_PushButtonTP::IsValidWidget(IFWL_Widget* pWidget) { + return pWidget->GetClassID() == FWL_CLASSHASH_PushButton; +} +FX_DWORD CFWL_PushButtonTP::SetThemeID(IFWL_Widget* pWidget, + FX_DWORD dwThemeID, + FX_BOOL bChildren) { + SetThemeData(FWL_GetThemeColor(dwThemeID)); + return CFWL_WidgetTP::SetThemeID(pWidget, dwThemeID, bChildren); +} +FX_BOOL CFWL_PushButtonTP::DrawBackground(CFWL_ThemeBackground* pParams) { + switch (pParams->m_iPart) { + case FWL_PART_PSB_Border: { + DrawBorder(pParams->m_pGraphics, &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_PSB_Edge: { + DrawEdge(pParams->m_pGraphics, pParams->m_pWidget->GetStyles(), + &pParams->m_rtPart, &pParams->m_matrix); + break; + } + case FWL_PART_PSB_Background: { + CFX_RectF& rect = pParams->m_rtPart; + FX_FLOAT fRight = rect.right(); + FX_FLOAT fBottom = rect.bottom(); + CFX_Path strokePath; + strokePath.Create(); + strokePath.MoveTo(rect.left + PUSHBUTTON_SIZE_Corner, rect.top); + strokePath.LineTo(fRight - PUSHBUTTON_SIZE_Corner, rect.top); + strokePath.LineTo(fRight, rect.top + PUSHBUTTON_SIZE_Corner); + strokePath.LineTo(fRight, fBottom - PUSHBUTTON_SIZE_Corner); + strokePath.LineTo(fRight - PUSHBUTTON_SIZE_Corner, fBottom); + strokePath.LineTo(rect.left + PUSHBUTTON_SIZE_Corner, fBottom); + strokePath.LineTo(rect.left, fBottom - PUSHBUTTON_SIZE_Corner); + strokePath.LineTo(rect.left, rect.top + PUSHBUTTON_SIZE_Corner); + strokePath.LineTo(rect.left + PUSHBUTTON_SIZE_Corner, rect.top); + CFX_Path fillPath; + fillPath.Create(); + fillPath.AddSubpath(&strokePath); + CFX_Graphics* pGraphics = pParams->m_pGraphics; + pGraphics->SaveGraphState(); + CFX_RectF rtInner(rect); + rtInner.Deflate(PUSHBUTTON_SIZE_Corner + 1, PUSHBUTTON_SIZE_Corner + 1, + PUSHBUTTON_SIZE_Corner, PUSHBUTTON_SIZE_Corner); + fillPath.AddRectangle(rtInner.left, rtInner.top, rtInner.width, + rtInner.height); + int32_t iColor = GetColorID(pParams->m_dwStates); + DrawAxialShading(pGraphics, rect.left + PUSHBUTTON_SIZE_Corner, rect.top, + rect.left + PUSHBUTTON_SIZE_Corner, rect.bottom(), + m_pThemeData->clrStart[iColor], + m_pThemeData->clrEnd[iColor], &fillPath, + FXFILL_ALTERNATE, &pParams->m_matrix); + CFX_Color crStroke(m_pThemeData->clrBorder[iColor]); + pGraphics->SetStrokeColor(&crStroke); + pGraphics->StrokePath(&strokePath, &pParams->m_matrix); + fillPath.Clear(); + fillPath.AddRectangle(rtInner.left, rtInner.top, rtInner.width, + rtInner.height); + CFX_Color crFill(m_pThemeData->clrFill[iColor]); + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&fillPath, FXFILL_WINDING, &pParams->m_matrix); + if (pParams->m_dwStates & FWL_PARTSTATE_PSB_Focused) { + rtInner.Inflate(1, 1, 0, 0); + DrawFocus(pGraphics, &rtInner, &pParams->m_matrix); + } + pGraphics->RestoreGraphState(); + break; + } + default: {} + } + return TRUE; +} +void* CFWL_PushButtonTP::GetCapacity(CFWL_ThemePart* pThemePart, + FX_DWORD dwCapacity) { + if (dwCapacity == FWL_WGTCAPACITY_PSB_Margin) { + m_fValue = 0; + return &m_fValue; + } + return CFWL_WidgetTP::GetCapacity(pThemePart, dwCapacity); +} +FWL_ERR CFWL_PushButtonTP::Initialize() { + InitTTO(); + return CFWL_WidgetTP::Initialize(); +} +FWL_ERR CFWL_PushButtonTP::Finalize() { + FinalizeTTO(); + return CFWL_WidgetTP::Finalize(); +} +void CFWL_PushButtonTP::SetThemeData(FX_DWORD dwID) { + if (dwID) { + m_pThemeData->clrBorder[0] = ArgbEncode(255, 55, 98, 6); + m_pThemeData->clrBorder[1] = ArgbEncode(255, 55, 98, 6); + m_pThemeData->clrBorder[2] = ArgbEncode(255, 55, 98, 6); + m_pThemeData->clrBorder[3] = ArgbEncode(255, 55, 98, 6); + m_pThemeData->clrBorder[4] = ArgbEncode(255, 172, 168, 153); + m_pThemeData->clrStart[0] = ArgbEncode(255, 255, 255, 246); + m_pThemeData->clrStart[1] = ArgbEncode(255, 223, 205, 180); + m_pThemeData->clrStart[2] = ArgbEncode(255, 252, 197, 149); + m_pThemeData->clrStart[3] = ArgbEncode(255, 194, 209, 143); + m_pThemeData->clrStart[4] = ArgbEncode(255, 216, 216, 216); + m_pThemeData->clrEnd[0] = ArgbEncode(255, 227, 209, 184); + m_pThemeData->clrEnd[1] = ArgbEncode(255, 248, 244, 228); + m_pThemeData->clrEnd[2] = ArgbEncode(255, 207, 114, 37); + m_pThemeData->clrEnd[3] = ArgbEncode(255, 144, 193, 84); + m_pThemeData->clrEnd[4] = ArgbEncode(255, 172, 168, 153); + m_pThemeData->clrFill[0] = ArgbEncode(255, 255, 255, 255); + m_pThemeData->clrFill[1] = ArgbEncode(255, 226, 225, 218); + m_pThemeData->clrFill[2] = ArgbEncode(255, 255, 255, 255); + m_pThemeData->clrFill[3] = ArgbEncode(255, 255, 255, 255); + m_pThemeData->clrFill[4] = ArgbEncode(255, 245, 244, 234); + } else { + m_pThemeData->clrBorder[0] = ArgbEncode(255, 0, 60, 116); + m_pThemeData->clrBorder[1] = ArgbEncode(255, 0, 60, 116); + m_pThemeData->clrBorder[2] = ArgbEncode(255, 0, 60, 116); + m_pThemeData->clrBorder[3] = ArgbEncode(255, 0, 60, 116); + m_pThemeData->clrBorder[4] = ArgbEncode(255, 201, 199, 186); + m_pThemeData->clrStart[0] = ArgbEncode(255, 255, 255, 255); + m_pThemeData->clrStart[1] = ArgbEncode(255, 209, 204, 193); + m_pThemeData->clrStart[2] = ArgbEncode(255, 255, 240, 207); + m_pThemeData->clrStart[3] = ArgbEncode(255, 206, 231, 255); + m_pThemeData->clrStart[4] = ArgbEncode(255, 245, 244, 234); + m_pThemeData->clrEnd[0] = ArgbEncode(255, 214, 208, 197); + m_pThemeData->clrEnd[1] = ArgbEncode(255, 242, 241, 238); + m_pThemeData->clrEnd[2] = ArgbEncode(255, 229, 151, 0); + m_pThemeData->clrEnd[3] = ArgbEncode(255, 105, 130, 238); + m_pThemeData->clrEnd[4] = ArgbEncode(255, 245, 244, 234); + m_pThemeData->clrFill[0] = ArgbEncode(255, 255, 255, 255); + m_pThemeData->clrFill[1] = ArgbEncode(255, 226, 225, 218); + m_pThemeData->clrFill[2] = ArgbEncode(255, 255, 255, 255); + m_pThemeData->clrFill[3] = ArgbEncode(255, 255, 255, 255); + m_pThemeData->clrFill[4] = ArgbEncode(255, 245, 244, 234); + } +} +int32_t CFWL_PushButtonTP::GetColorID(FX_DWORD dwStates) { + return dwStates &= FWL_PARTSTATE_PSB_Mask; +} diff --git a/xfa/fwl/theme/scrollbartp.cpp b/xfa/fwl/theme/scrollbartp.cpp new file mode 100644 index 0000000000..424ff549e5 --- /dev/null +++ b/xfa/fwl/theme/scrollbartp.cpp @@ -0,0 +1,377 @@ +// 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 "xfa/include/fwl/theme/scrollbartp.h" + +#include "xfa/include/fwl/basewidget/fwl_scrollbar.h" +#include "xfa/include/fwl/core/fwl_widget.h" + +#define FWL_SCROLL_PawLen 12.5f + +CFWL_ScrollBarTP::CFWL_ScrollBarTP() { + m_pThemeData = new SBThemeData; + SetThemeData(0); +} +CFWL_ScrollBarTP::~CFWL_ScrollBarTP() { + if (m_pThemeData) { + delete m_pThemeData; + m_pThemeData = NULL; + } +} +FX_BOOL CFWL_ScrollBarTP::IsValidWidget(IFWL_Widget* pWidget) { + if (!pWidget) + return FALSE; + return pWidget->GetClassID() == FWL_CLASSHASH_ScrollBar; +} +void* CFWL_ScrollBarTP::GetCapacity(CFWL_ThemePart* pThemePart, + FX_DWORD dwCapacity) { + if (dwCapacity == FWL_CAPACITY_SCB_Size) { + m_fValue = 5; + return &m_fValue; + } + return CFWL_WidgetTP::GetCapacity(pThemePart, dwCapacity); +} +FX_DWORD CFWL_ScrollBarTP::SetThemeID(IFWL_Widget* pWidget, + FX_DWORD dwThemeID, + FX_BOOL bChildren) { + if (m_pThemeData) { + SetThemeData(FWL_GetThemeColor(dwThemeID)); + } + return CFWL_WidgetTP::SetThemeID(pWidget, dwThemeID, bChildren); +} +FX_BOOL CFWL_ScrollBarTP::DrawBackground(CFWL_ThemeBackground* pParams) { + if (!pParams) + return FALSE; + IFWL_Widget* pWidget = pParams->m_pWidget; + FWLTHEME_STATE eState = FWLTHEME_STATE_Normal; + switch (pParams->m_dwStates & 0x03) { + case FWL_PARTSTATE_SCB_Hovered: { + eState = FWLTHEME_STATE_Hover; + break; + } + case FWL_PARTSTATE_SCB_Pressed: { + eState = FWLTHEME_STATE_Pressed; + break; + } + case FWL_PARTSTATE_SCB_Disabled: { + eState = FWLTHEME_STATE_Disabale; + break; + } + } + CFX_Graphics* pGraphics = pParams->m_pGraphics; + CFX_RectF* pRect = &pParams->m_rtPart; + FX_BOOL bVert = pWidget->GetStylesEx(); + switch (pParams->m_iPart) { + case FWL_PART_SCB_ForeArrow: { + DrawMaxMinBtn(pGraphics, pRect, + bVert ? FWLTHEME_DIRECTION_Up : FWLTHEME_DIRECTION_Left, + eState, &pParams->m_matrix); + break; + } + case FWL_PART_SCB_BackArrow: { + DrawMaxMinBtn(pGraphics, pRect, + bVert ? FWLTHEME_DIRECTION_Down : FWLTHEME_DIRECTION_Right, + eState, &pParams->m_matrix); + break; + } + case FWL_PART_SCB_Thumb: { + DrawThumbBtn(pGraphics, pRect, bVert, eState, TRUE, &pParams->m_matrix); + break; + } + case FWL_PART_SCB_LowerTrack: { + DrawTrack(pGraphics, pRect, bVert, eState, TRUE, &pParams->m_matrix); + break; + } + case FWL_PART_SCB_UpperTrack: { + DrawTrack(pGraphics, pRect, bVert, eState, FALSE, &pParams->m_matrix); + break; + } + default: {} + } + return TRUE; +} +#ifdef THEME_XPSimilar +void CFWL_ScrollBarTP::DrawThumbBtn(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FX_BOOL bVert, + FWLTHEME_STATE eState, + FX_BOOL bPawButton, + CFX_Matrix* pMatrix) { + if (eState < FWLTHEME_STATE_Normal || eState > FWLTHEME_STATE_Disabale) { + return; + } + CFX_Path path; + path.Create(); + CFX_RectF rect(*pRect); + if (bVert) { + rect.Deflate(1, 0); + if (rect.IsEmpty(0.1f)) { + return; + } + path.AddRectangle(rect.left, rect.top, rect.width, rect.height); + DrawAxialShading(pGraphics, rect.left, rect.top, rect.right(), rect.top, + m_pThemeData->clrBtnBK[eState - 1][0], + m_pThemeData->clrBtnBK[eState - 1][1], &path, + FXFILL_WINDING, pMatrix); + CFX_Color rcStroke; + rcStroke.Set(m_pThemeData->clrBtnBorder[eState - 1]); + pGraphics->SaveGraphState(); + pGraphics->SetStrokeColor(&rcStroke); + pGraphics->StrokePath(&path, pMatrix); + pGraphics->RestoreGraphState(); + } else { + rect.Deflate(0, 1); + if (rect.IsEmpty(0.1f)) { + return; + } + path.AddRectangle(rect.left, rect.top, rect.width, rect.height); + DrawAxialShading(pGraphics, rect.left, rect.top, rect.left, rect.bottom(), + m_pThemeData->clrBtnBK[eState - 1][0], + m_pThemeData->clrBtnBK[eState - 1][1], &path, + FXFILL_WINDING, pMatrix); + CFX_Color rcStroke; + rcStroke.Set(m_pThemeData->clrBtnBorder[eState - 1]); + pGraphics->SaveGraphState(); + pGraphics->SetStrokeColor(&rcStroke); + pGraphics->StrokePath(&path, pMatrix); + pGraphics->RestoreGraphState(); + } +} +void CFWL_ScrollBarTP::DrawPaw(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FX_BOOL bVert, + FWLTHEME_STATE eState, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + if (bVert) { + FX_FLOAT fPawLen = FWL_SCROLL_PawLen; + if (pRect->width / 2 <= fPawLen) { + fPawLen = (pRect->width - 6) / 2; + } + FX_FLOAT fX = pRect->left + pRect->width / 4; + FX_FLOAT fY = pRect->top + pRect->height / 2; + path.MoveTo(fX, fY - 4); + path.LineTo(fX + fPawLen, fY - 4); + path.MoveTo(fX, fY - 2); + path.LineTo(fX + fPawLen, fY - 2); + path.MoveTo(fX, fY); + path.LineTo(fX + fPawLen, fY); + path.MoveTo(fX, fY + 2); + path.LineTo(fX + fPawLen, fY + 2); + CFX_Color clrLight(m_pThemeData->clrPawColorLight[eState - 1]); + pGraphics->SetLineWidth(1); + pGraphics->SetStrokeColor(&clrLight); + pGraphics->StrokePath(&path); + fX++; + path.Clear(); + path.MoveTo(fX, fY - 3); + path.LineTo(fX + fPawLen, fY - 3); + path.MoveTo(fX, fY - 1); + path.LineTo(fX + fPawLen, fY - 1); + path.MoveTo(fX, fY + 1); + path.LineTo(fX + fPawLen, fY + 1); + path.MoveTo(fX, fY + 3); + path.LineTo(fX + fPawLen, fY + 3); + CFX_Color clrDark(m_pThemeData->clrPawColorDark[eState - 1]); + pGraphics->SetLineWidth(1); + pGraphics->SetStrokeColor(&clrDark); + pGraphics->StrokePath(&path, pMatrix); + } else { + FX_FLOAT fPawLen = FWL_SCROLL_PawLen; + if (pRect->height / 2 <= fPawLen) { + fPawLen = (pRect->height - 6) / 2; + } + FX_FLOAT fX = pRect->left + pRect->width / 2; + FX_FLOAT fY = pRect->top + pRect->height / 4; + path.MoveTo(fX - 4, fY); + path.LineTo(fX - 4, fY + fPawLen); + path.MoveTo(fX - 2, fY); + path.LineTo(fX - 2, fY + fPawLen); + path.MoveTo(fX, fY); + path.LineTo(fX, fY + fPawLen); + path.MoveTo(fX + 2, fY); + path.LineTo(fX + 2, fY + fPawLen); + CFX_Color clrLight(m_pThemeData->clrPawColorLight[eState - 1]); + pGraphics->SetLineWidth(1); + pGraphics->SetStrokeColor(&clrLight); + pGraphics->StrokePath(&path, pMatrix); + fY++; + path.Clear(); + path.MoveTo(fX - 3, fY); + path.LineTo(fX - 3, fY + fPawLen); + path.MoveTo(fX - 1, fY); + path.LineTo(fX - 1, fY + fPawLen); + path.MoveTo(fX + 1, fY); + path.LineTo(fX + 1, fY + fPawLen); + path.MoveTo(fX + 3, fY); + path.LineTo(fX + 3, fY + fPawLen); + CFX_Color clrDark(m_pThemeData->clrPawColorDark[eState - 1]); + pGraphics->SetLineWidth(1); + pGraphics->SetStrokeColor(&clrDark); + pGraphics->StrokePath(&path, pMatrix); + } +} +void CFWL_ScrollBarTP::DrawTrack(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FX_BOOL bVert, + FWLTHEME_STATE eState, + FX_BOOL bLowerTrack, + CFX_Matrix* pMatrix) { + if (eState < FWLTHEME_STATE_Normal || eState > FWLTHEME_STATE_Disabale) { + return; + } + pGraphics->SaveGraphState(); + CFX_Color colorLine(ArgbEncode(255, 238, 237, 229)); + CFX_Path path; + path.Create(); + FX_FLOAT fRight = pRect->right(); + FX_FLOAT fBottom = pRect->bottom(); + if (bVert) { + path.AddRectangle(pRect->left, pRect->top, 1, pRect->height); + path.AddRectangle(fRight - 1, pRect->top, 1, pRect->height); + } else { + path.AddRectangle(pRect->left, pRect->top, pRect->width, 1); + path.AddRectangle(pRect->left, fBottom - 1, pRect->width, 1); + } + pGraphics->SetFillColor(&colorLine); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + path.Clear(); + path.AddRectangle(pRect->left + 1, pRect->top, pRect->width - 2, + pRect->height); + FX_FLOAT x1 = bVert ? pRect->left + 1 : pRect->left; + FX_FLOAT y1 = bVert ? pRect->top : pRect->top + 1; + FX_FLOAT x2 = bVert ? fRight - 1 : pRect->left; + FX_FLOAT y2 = bVert ? pRect->top : fBottom - 1; + pGraphics->RestoreGraphState(); + DrawAxialShading(pGraphics, x1, y1, x2, y2, m_pThemeData->clrTrackBKStart, + m_pThemeData->clrTrackBKEnd, &path, FXFILL_WINDING, pMatrix); +} +void CFWL_ScrollBarTP::DrawMaxMinBtn(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_DIRECTION eDict, + FWLTHEME_STATE eState, + CFX_Matrix* pMatrix) { + DrawTrack(pGraphics, pRect, + eDict == FWLTHEME_DIRECTION_Up || eDict == FWLTHEME_DIRECTION_Down, + eState, TRUE, pMatrix); + CFX_RectF rtArrowBtn(*pRect); + rtArrowBtn.Deflate(1, 1, 1, 1); + DrawArrowBtn(pGraphics, &rtArrowBtn, eDict, eState, pMatrix); +} +#else +void CFWL_ScrollBarTP::DrawThumbBtn(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FX_BOOL bVert, + FWLTHEME_STATE eState, + FX_BOOL bPawButton, + CFX_Matrix* pMatrix) { + if (pRect->IsEmpty()) { + return; + } + CFX_RectF rtThumb(*pRect); + FX_FLOAT fWidth = 2; + Draw3DRect(pGraphics, FWLTHEME_EDGE_Raised, fWidth, pRect, + FWLTHEME_COLOR_EDGELT1, FWLTHEME_COLOR_EDGELT2, + FWLTHEME_COLOR_EDGERB1, FWLTHEME_COLOR_EDGERB2, pMatrix); + CFX_Path path; + path.Create(); + path.AddRectangle(pRect->left + fWidth, pRect->top + fWidth, + pRect->width - 2 * fWidth, pRect->height - 2 * fWidth); + pGraphics->SaveGraphState(); + CFX_Color crFill(FWLTHEME_COLOR_Background); + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_ScrollBarTP::DrawTrack(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FX_BOOL bVert, + FWLTHEME_STATE eState, + FX_BOOL bLowerTrack, + CFX_Matrix* pMatrix) { + if (pRect->IsEmpty()) { + return; + } + CFX_Path path; + path.Create(); + path.AddRectangle(pRect->left, pRect->top, pRect->width, pRect->height); + pGraphics->SaveGraphState(); + CFX_Color clrFill(0xFFF0F0F0); + pGraphics->SetFillColor(&clrFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_ScrollBarTP::DrawMaxMinBtn(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_DIRECTION eDict, + FWLTHEME_STATE eState, + CFX_Matrix* pMatrix) { + CFX_RectF rtThumb(*pRect); + FX_FLOAT fWidth = eState == FWLTHEME_STATE_Pressed ? 1.0f : 2.0f; + FWLTHEME_EDGE eType = eState == FWLTHEME_STATE_Pressed ? FWLTHEME_EDGE_Flat + : FWLTHEME_EDGE_Raised; + Draw3DRect(pGraphics, eType, fWidth, pRect, FWLTHEME_COLOR_EDGELT1, + FWLTHEME_COLOR_EDGELT2, FWLTHEME_COLOR_EDGERB1, + FWLTHEME_COLOR_EDGERB2, pMatrix); + CFX_Path path; + path.Create(); + path.AddRectangle(pRect->left + fWidth, pRect->top + fWidth, + pRect->width - 2 * fWidth, pRect->height - 2 * fWidth); + pGraphics->SaveGraphState(); + CFX_Color crFill(FWLTHEME_COLOR_Background); + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pGraphics->RestoreGraphState(); + DrawArrow(pGraphics, pRect, eDict, + eState == FWLTHEME_STATE_Disabale ? 0xFFA0A0A0 : 0xFF000000, + eState == FWLTHEME_STATE_Pressed, pMatrix); +} +#endif +void CFWL_ScrollBarTP::SetThemeData(FX_DWORD dwID) { + m_pThemeData->clrPawColorLight[3] = ArgbEncode(0xff, 208, 223, 172); + m_pThemeData->clrPawColorDark[3] = ArgbEncode(0xff, 140, 157, 115); + m_pThemeData->clrBtnBK[3][0] = ArgbEncode(0xff, 164, 180, 139); + m_pThemeData->clrBtnBK[3][1] = ArgbEncode(0xff, 141, 157, 115); + m_pThemeData->clrBtnBorder[3] = ArgbEncode(0xff, 236, 233, 216); + if (dwID) { + m_pThemeData->clrPawColorLight[0] = ArgbEncode(0xff, 208, 223, 172); + m_pThemeData->clrPawColorDark[0] = ArgbEncode(0xff, 140, 157, 115); + m_pThemeData->clrBtnBK[0][0] = ArgbEncode(0xff, 162, 179, 141); + m_pThemeData->clrBtnBK[0][1] = ArgbEncode(0xff, 149, 167, 117); + m_pThemeData->clrBtnBorder[0] = ArgbEncode(0xff, 142, 153, 125); + m_pThemeData->clrPawColorLight[1] = ArgbEncode(0xff, 235, 245, 212); + m_pThemeData->clrPawColorDark[1] = ArgbEncode(0xff, 182, 198, 142); + m_pThemeData->clrBtnBK[1][0] = ArgbEncode(0xff, 200, 213, 170); + m_pThemeData->clrBtnBK[1][1] = ArgbEncode(0xff, 195, 208, 150); + m_pThemeData->clrBtnBorder[1] = ArgbEncode(0xff, 189, 203, 150); + m_pThemeData->clrPawColorLight[2] = ArgbEncode(0xff, 208, 223, 172); + m_pThemeData->clrPawColorDark[2] = ArgbEncode(0xff, 140, 157, 115); + m_pThemeData->clrBtnBK[2][0] = ArgbEncode(0xff, 164, 180, 139); + m_pThemeData->clrBtnBK[2][1] = ArgbEncode(0xff, 141, 157, 115); + m_pThemeData->clrBtnBorder[2] = ArgbEncode(0xff, 128, 146, 102); + m_pThemeData->clrTrackBKStart = ArgbEncode(0xff, 243, 241, 236); + m_pThemeData->clrTrackBKEnd = ArgbEncode(0xff, 254, 254, 251); + } else { + m_pThemeData->clrPawColorLight[0] = ArgbEncode(0xff, 238, 244, 254); + m_pThemeData->clrPawColorDark[0] = ArgbEncode(0xff, 140, 176, 248); + m_pThemeData->clrBtnBK[0][0] = ArgbEncode(0xff, 197, 213, 252); + m_pThemeData->clrBtnBK[0][1] = ArgbEncode(0xff, 182, 205, 251); + m_pThemeData->clrBtnBorder[0] = ArgbEncode(0xff, 148, 176, 221); + m_pThemeData->clrPawColorLight[1] = ArgbEncode(0xff, 252, 253, 255); + m_pThemeData->clrPawColorDark[1] = ArgbEncode(0xff, 156, 197, 255); + m_pThemeData->clrBtnBK[1][0] = ArgbEncode(0xff, 216, 232, 255); + m_pThemeData->clrBtnBK[1][1] = ArgbEncode(0xff, 204, 225, 255); + m_pThemeData->clrBtnBorder[1] = ArgbEncode(0xff, 218, 230, 254); + m_pThemeData->clrPawColorLight[2] = ArgbEncode(0xff, 207, 221, 253); + m_pThemeData->clrPawColorDark[2] = ArgbEncode(0xff, 131, 158, 216); + m_pThemeData->clrBtnBK[2][0] = ArgbEncode(0xff, 167, 190, 245); + m_pThemeData->clrBtnBK[2][1] = ArgbEncode(0xff, 146, 179, 249); + m_pThemeData->clrBtnBorder[2] = ArgbEncode(0xff, 124, 159, 211); + m_pThemeData->clrTrackBKStart = ArgbEncode(0xff, 243, 241, 236); + m_pThemeData->clrTrackBKEnd = ArgbEncode(0xff, 254, 254, 251); + } +} diff --git a/xfa/fwl/theme/widgettp.cpp b/xfa/fwl/theme/widgettp.cpp new file mode 100644 index 0000000000..04b67b3310 --- /dev/null +++ b/xfa/fwl/theme/widgettp.cpp @@ -0,0 +1,840 @@ +// 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 "xfa/include/fwl/theme/widgettp.h" + +#include + +#include "xfa/fde/tto/fde_textout.h" +#include "xfa/include/fwl/core/fwl_widgetmgr.h" + +static void FWL_SetChildThemeID(IFWL_Widget* pParent, FX_DWORD dwThemeID) { + IFWL_WidgetMgr* pWidgetMgr = FWL_GetWidgetMgr(); + IFWL_Widget* pChild = + pWidgetMgr->GetWidget(pParent, FWL_WGTRELATION_FirstChild); + while (pChild) { + IFWL_ThemeProvider* pTheme = pChild->GetThemeProvider(); + if (pTheme) { + pTheme->SetThemeID(pChild, dwThemeID, FALSE); + } + FWL_SetChildThemeID(pChild, dwThemeID); + pChild = pWidgetMgr->GetWidget(pChild, FWL_WGTRELATION_NextSibling); + } +} +FX_BOOL CFWL_WidgetTP::IsValidWidget(IFWL_Widget* pWidget) { + return FALSE; +} +FX_DWORD CFWL_WidgetTP::GetThemeID(IFWL_Widget* pWidget) { + return m_dwThemeID; +} +FX_DWORD CFWL_WidgetTP::SetThemeID(IFWL_Widget* pWidget, + FX_DWORD dwThemeID, + FX_BOOL bChildren) { + FX_DWORD dwOld = m_dwThemeID; + m_dwThemeID = dwThemeID; + if (CFWL_ArrowData::IsInstance()) { + CFWL_ArrowData::GetInstance()->SetColorData(FWL_GetThemeColor(dwThemeID)); + } + if (bChildren) { + FWL_SetChildThemeID(pWidget, dwThemeID); + } + return dwOld; +} +FWL_ERR CFWL_WidgetTP::GetThemeMatrix(IFWL_Widget* pWidget, + CFX_Matrix& matrix) { + matrix.Set(_ctm.a, _ctm.b, _ctm.c, _ctm.d, _ctm.e, _ctm.f); + return FWL_ERR_Succeeded; +} +FWL_ERR CFWL_WidgetTP::SetThemeMatrix(IFWL_Widget* pWidget, + const CFX_Matrix& matrix) { + _ctm.Set(matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f); + return FWL_ERR_Succeeded; +} +FX_BOOL CFWL_WidgetTP::DrawBackground(CFWL_ThemeBackground* pParams) { + return TRUE; +} +FX_BOOL CFWL_WidgetTP::DrawText(CFWL_ThemeText* pParams) { + if (!m_pTextOut) { + InitTTO(); + } + int32_t iLen = pParams->m_wsText.GetLength(); + if (iLen <= 0) + return FALSE; + CFX_Graphics* pGraphics = pParams->m_pGraphics; + m_pTextOut->SetRenderDevice(pGraphics->GetRenderDevice()); + m_pTextOut->SetStyles(pParams->m_dwTTOStyles); + m_pTextOut->SetAlignment(pParams->m_iTTOAlign); + CFX_Matrix* pMatrix = &pParams->m_matrix; + pMatrix->Concat(*pGraphics->GetMatrix()); + m_pTextOut->SetMatrix(*pMatrix); + m_pTextOut->DrawLogicText(pParams->m_wsText, iLen, pParams->m_rtPart); + return TRUE; +} +void* CFWL_WidgetTP::GetCapacity(CFWL_ThemePart* pThemePart, + FX_DWORD dwCapacity) { + switch (dwCapacity) { + case FWL_WGTCAPACITY_CXBorder: { + m_fValue = FWLTHEME_CAPACITY_CXBorder; + break; + } + case FWL_WGTCAPACITY_CYBorder: { + m_fValue = FWLTHEME_CAPACITY_CYBorder; + break; + } + case FWL_WGTCAPACITY_EdgeFlat: { + m_fValue = FWLTHEME_CAPACITY_EdgeFlat; + break; + } + case FWL_WGTCAPACITY_EdgeRaised: { + m_fValue = FWLTHEME_CAPACITY_EdgeRaised; + break; + } + case FWL_WGTCAPACITY_EdgeSunken: { + m_fValue = FWLTHEME_CAPACITY_EdgeSunken; + break; + } + case FWL_WGTCAPACITY_FontSize: { + m_fValue = FWLTHEME_CAPACITY_FontSize; + break; + } + case FWL_WGTCAPACITY_TextColor: { + m_dwValue = FWLTHEME_CAPACITY_TextColor; + return &m_dwValue; + } + case FWL_WGTCAPACITY_ScrollBarWidth: { + m_fValue = FWLTHEME_CAPACITY_ScrollBarWidth; + break; + } + case FWL_WGTCAPACITY_Font: { + return m_pFDEFont; + } + case FWL_WGTCAPACITY_TextSelColor: { + m_dwValue = (m_dwThemeID == 0) ? FWLTHEME_CAPACITY_TextSelColor + : FWLTHEME_COLOR_Green_BKSelected; + return &m_dwValue; + } + case FWL_WGTCAPACITY_LineHeight: { + m_fValue = FWLTHEME_CAPACITY_LineHeight; + break; + } + case FWL_WGTCAPACITY_UIMargin: { + m_rtMargin.Set(0, 0, 0, 0); + return &m_rtMargin; + } + default: { return NULL; } + } + return &m_fValue; +} +FX_BOOL CFWL_WidgetTP::IsCustomizedLayout(IFWL_Widget* pWidget) { + return FWL_GetThemeLayout(m_dwThemeID); +} +FWL_ERR CFWL_WidgetTP::GetPartRect(CFWL_ThemePart* pThemePart, + CFX_RectF& rect) { + return FWL_ERR_Succeeded; +} +FX_BOOL CFWL_WidgetTP::IsInPart(CFWL_ThemePart* pThemePart, + FX_FLOAT fx, + FX_FLOAT fy) { + return TRUE; +} +FX_BOOL CFWL_WidgetTP::CalcTextRect(CFWL_ThemeText* pParams, CFX_RectF& rect) { + if (!pParams) + return FALSE; + if (!m_pTextOut) + return FALSE; + m_pTextOut->SetAlignment(pParams->m_iTTOAlign); + m_pTextOut->SetStyles(pParams->m_dwTTOStyles | FDE_TTOSTYLE_ArabicContext); + m_pTextOut->CalcLogicSize(pParams->m_wsText, pParams->m_wsText.GetLength(), + rect); + return TRUE; +} +FWL_ERR CFWL_WidgetTP::Initialize() { + m_dwThemeID = 0; + _ctm.SetIdentity(); + return FWL_ERR_Succeeded; +} +FWL_ERR CFWL_WidgetTP::Finalize() { + if (!m_pTextOut) { + FinalizeTTO(); + } + return FWL_ERR_Succeeded; +} +CFWL_WidgetTP::~CFWL_WidgetTP() {} +FWL_ERR CFWL_WidgetTP::SetFont(IFWL_Widget* pWidget, + const FX_WCHAR* strFont, + FX_FLOAT fFontSize, + FX_ARGB rgbFont) { + if (!m_pTextOut) { + return FWL_ERR_Succeeded; + } + m_pFDEFont = CFWL_FontManager::GetInstance()->FindFont(strFont, 0, 0); + m_pTextOut->SetFont(m_pFDEFont); + m_pTextOut->SetFontSize(fFontSize); + m_pTextOut->SetTextColor(rgbFont); + return FWL_ERR_Succeeded; +} +FWL_ERR CFWL_WidgetTP::SetFont(IFWL_Widget* pWidget, + IFX_Font* pFont, + FX_FLOAT fFontSize, + FX_ARGB rgbFont) { + if (!m_pTextOut) { + return FWL_ERR_Succeeded; + } + m_pTextOut->SetFont(pFont); + m_pTextOut->SetFontSize(fFontSize); + m_pTextOut->SetTextColor(rgbFont); + return FWL_ERR_Succeeded; +} +IFX_Font* CFWL_WidgetTP::GetFont(IFWL_Widget* pWidget) { + return m_pFDEFont; +} +CFWL_WidgetTP::CFWL_WidgetTP() + : m_dwRefCount(1), m_pTextOut(NULL), m_pFDEFont(NULL), m_dwThemeID(0) {} +FX_ERR CFWL_WidgetTP::InitTTO() { + if (m_pTextOut) { + return FWL_ERR_Succeeded; + } + m_pFDEFont = + CFWL_FontManager::GetInstance()->FindFont(FX_WSTRC(L"Helvetica"), 0, 0); + m_pTextOut = IFDE_TextOut::Create(); + m_pTextOut->SetFont(m_pFDEFont); + m_pTextOut->SetFontSize(FWLTHEME_CAPACITY_FontSize); + m_pTextOut->SetTextColor(FWLTHEME_CAPACITY_TextColor); + m_pTextOut->SetEllipsisString(L"..."); + return FWL_ERR_Succeeded; +} +FX_ERR CFWL_WidgetTP::FinalizeTTO() { + if (m_pTextOut) { + m_pTextOut->Release(); + m_pTextOut = NULL; + } + return FWL_ERR_Succeeded; +} +#ifdef THEME_XPSimilar +void CFWL_WidgetTP::DrawEdge(CFX_Graphics* pGraphics, + FX_DWORD dwStyles, + const CFX_RectF* pRect, + CFX_Matrix* pMatrix) { + if (!pGraphics) + return; + if (!pRect) + return; + pGraphics->SaveGraphState(); + CFX_Color crStroke(FWL_GetThemeColor(m_dwThemeID) == 0 + ? ArgbEncode(255, 127, 157, 185) + : FWLTHEME_COLOR_Green_BKSelected); + pGraphics->SetStrokeColor(&crStroke); + CFX_Path path; + path.Create(); + path.AddRectangle(pRect->left, pRect->top, pRect->width - 1, + pRect->height - 1); + pGraphics->StrokePath(&path, pMatrix); + path.Clear(); + crStroke = ArgbEncode(255, 255, 255, 255); + pGraphics->SetStrokeColor(&crStroke); + path.AddRectangle(pRect->left + 1, pRect->top + 1, pRect->width - 3, + pRect->height - 3); + pGraphics->StrokePath(&path, pMatrix); + pGraphics->RestoreGraphState(); +} +#else +void CFWL_WidgetTP::DrawEdge(CFX_Graphics* pGraphics, + FX_DWORD dwStyles, + const CFX_RectF* pRect, + CFX_Matrix* pMatrix) { + if (!pGraphics) + return; + if (!pRect) + return; + FWLTHEME_EDGE eType; + FX_FLOAT fWidth; + switch (dwStyles & FWL_WGTSTYLE_EdgeMask) { + case FWL_WGTSTYLE_EdgeRaised: { + eType = FWLTHEME_EDGE_Raised, fWidth = FWLTHEME_CAPACITY_EdgeRaised; + break; + } + case FWL_WGTSTYLE_EdgeSunken: { + eType = FWLTHEME_EDGE_Sunken, fWidth = FWLTHEME_CAPACITY_EdgeSunken; + break; + } + case FWL_WGTSTYLE_EdgeFlat: + default: { return; } + } + Draw3DRect(pGraphics, eType, fWidth, pRect, FWLTHEME_COLOR_EDGELT1, + FWLTHEME_COLOR_EDGELT2, FWLTHEME_COLOR_EDGERB1, + FWLTHEME_COLOR_EDGERB2, pMatrix); +} +#endif +void CFWL_WidgetTP::Draw3DRect(CFX_Graphics* pGraphics, + FWLTHEME_EDGE eType, + FX_FLOAT fWidth, + const CFX_RectF* pRect, + FX_ARGB cr1, + FX_ARGB cr2, + FX_ARGB cr3, + FX_ARGB cr4, + CFX_Matrix* pMatrix) { + if (!pGraphics) + return; + if (!pRect) + return; + pGraphics->SaveGraphState(); + if (eType == FWLTHEME_EDGE_Flat) { + CFX_Path path; + path.Create(); + path.AddRectangle(pRect->left, pRect->top, pRect->width, pRect->height); + path.AddRectangle(pRect->left + 1, pRect->top + 1, pRect->width - 2, + pRect->height - 2); + CFX_Color cr(ArgbEncode(255, 100, 100, 100)); + pGraphics->SetFillColor(&cr); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + path.Clear(); + path.AddRectangle(pRect->left + 1, pRect->top + 1, pRect->width - 2, + pRect->height - 2); + path.AddRectangle(pRect->left + 2, pRect->top + 2, pRect->width - 4, + pRect->height - 4); + cr.Set(0xFFFFFFFF); + pGraphics->SetFillColor(&cr); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + } else { + FX_FLOAT fLeft = pRect->left; + FX_FLOAT fRight = pRect->right(); + FX_FLOAT fTop = pRect->top; + FX_FLOAT fBottom = pRect->bottom(); + FX_FLOAT fHalfWidth = fWidth / 2.0f; + CFX_Color crLT(eType == FWLTHEME_EDGE_Raised ? cr4 : cr1); + pGraphics->SetFillColor(&crLT); + CFX_Path pathLT; + pathLT.Create(); + pathLT.MoveTo(fLeft, fBottom - fHalfWidth); + pathLT.LineTo(fLeft, fTop); + pathLT.LineTo(fRight - fHalfWidth, fTop); + pathLT.LineTo(fRight - fHalfWidth, fTop + fHalfWidth); + pathLT.LineTo(fLeft + fHalfWidth, fTop + fHalfWidth); + pathLT.LineTo(fLeft + fHalfWidth, fBottom - fHalfWidth); + pathLT.LineTo(fLeft, fBottom - fHalfWidth); + pGraphics->FillPath(&pathLT, FXFILL_WINDING, pMatrix); + crLT = CFX_Color(eType == FWLTHEME_EDGE_Raised ? cr3 : cr2); + pGraphics->SetFillColor(&crLT); + pathLT.Clear(); + pathLT.MoveTo(fLeft + fHalfWidth, fBottom - fWidth); + pathLT.LineTo(fLeft + fHalfWidth, fTop + fHalfWidth); + pathLT.LineTo(fRight - fWidth, fTop + fHalfWidth); + pathLT.LineTo(fRight - fWidth, fTop + fWidth); + pathLT.LineTo(fLeft + fWidth, fTop + fWidth); + pathLT.LineTo(fLeft + fWidth, fBottom - fWidth); + pathLT.LineTo(fLeft + fHalfWidth, fBottom - fWidth); + pGraphics->FillPath(&pathLT, FXFILL_WINDING, pMatrix); + CFX_Color crRB(eType == FWLTHEME_EDGE_Raised ? cr1 : cr3); + pGraphics->SetFillColor(&crRB); + CFX_Path pathRB; + pathRB.Create(); + pathRB.MoveTo(fRight - fHalfWidth, fTop + fHalfWidth); + pathRB.LineTo(fRight - fHalfWidth, fBottom - fHalfWidth); + pathRB.LineTo(fLeft + fHalfWidth, fBottom - fHalfWidth); + pathRB.LineTo(fLeft + fHalfWidth, fBottom - fWidth); + pathRB.LineTo(fRight - fWidth, fBottom - fWidth); + pathRB.LineTo(fRight - fWidth, fTop + fHalfWidth); + pathRB.LineTo(fRight - fHalfWidth, fTop + fHalfWidth); + pGraphics->FillPath(&pathRB, FXFILL_WINDING, pMatrix); + crRB = CFX_Color(eType == FWLTHEME_EDGE_Raised ? cr2 : cr4); + pGraphics->SetFillColor(&crRB); + pathRB.Clear(); + pathRB.MoveTo(fRight, fTop); + pathRB.LineTo(fRight, fBottom); + pathRB.LineTo(fLeft, fBottom); + pathRB.LineTo(fLeft, fBottom - fHalfWidth); + pathRB.LineTo(fRight - fHalfWidth, fBottom - fHalfWidth); + pathRB.LineTo(fRight - fHalfWidth, fTop); + pathRB.LineTo(fRight, fTop); + pGraphics->FillPath(&pathRB, FXFILL_WINDING, pMatrix); + } + pGraphics->RestoreGraphState(); +} +void CFWL_WidgetTP::Draw3DCircle(CFX_Graphics* pGraphics, + FWLTHEME_EDGE eType, + FX_FLOAT fWidth, + const CFX_RectF* pRect, + FX_ARGB cr1, + FX_ARGB cr2, + FX_ARGB cr3, + FX_ARGB cr4, + CFX_Matrix* pMatrix) { + if (!pGraphics) + return; + if (!pRect) + return; + pGraphics->SaveGraphState(); + CFX_Path path; + path.Create(); + path.AddArc(pRect->left, pRect->top, pRect->width, pRect->height, + FWLTHEME_PI * 3 / 4, FWLTHEME_PI); + CFX_Color crFill1(eType == FWLTHEME_EDGE_Raised ? cr4 : cr1); + pGraphics->SetStrokeColor(&crFill1); + pGraphics->StrokePath(&path, pMatrix); + CFX_RectF rtInner(*pRect); + rtInner.Deflate(pRect->width / 4, pRect->height / 4); + path.Clear(); + path.AddArc(rtInner.left, rtInner.top, rtInner.width, rtInner.height, + FWLTHEME_PI * 3 / 4, FWLTHEME_PI); + CFX_Color crFill2(eType == FWLTHEME_EDGE_Raised ? cr3 : cr2); + pGraphics->SetStrokeColor(&crFill2); + pGraphics->StrokePath(&path, pMatrix); + path.Clear(); + path.AddArc(pRect->left, pRect->top, pRect->width, pRect->height, + FWLTHEME_PI * 7 / 4, FWLTHEME_PI); + CFX_Color crFill3(eType == FWLTHEME_EDGE_Raised ? cr1 : cr3); + pGraphics->SetStrokeColor(&crFill3); + pGraphics->StrokePath(&path, pMatrix); + path.AddArc(rtInner.left, rtInner.top, rtInner.width, rtInner.height, + FWLTHEME_PI * 7 / 4, FWLTHEME_PI); + CFX_Color crFill4(eType == FWLTHEME_EDGE_Raised ? cr2 : cr4); + pGraphics->SetStrokeColor(&crFill4); + pGraphics->StrokePath(&path, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_WidgetTP::DrawBorder(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + CFX_Matrix* pMatrix) { + if (!pGraphics) + return; + if (!pRect) + return; + CFX_Path path; + path.Create(); + path.AddRectangle(pRect->left, pRect->top, pRect->width, pRect->height); + path.AddRectangle(pRect->left + 1, pRect->top + 1, pRect->width - 2, + pRect->height - 2); + pGraphics->SaveGraphState(); + CFX_Color crFill(ArgbEncode(255, 0, 0, 0)); + pGraphics->SetFillColor(&crFill); + pGraphics->FillPath(&path, FXFILL_ALTERNATE, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_WidgetTP::FillBackground(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + CFX_Matrix* pMatrix) { + FillSoildRect(pGraphics, FWLTHEME_COLOR_Background, pRect, pMatrix); +} +void CFWL_WidgetTP::FillSoildRect(CFX_Graphics* pGraphics, + FX_ARGB fillColor, + const CFX_RectF* pRect, + CFX_Matrix* pMatrix) { + if (!pGraphics) + return; + if (!pRect) + return; + pGraphics->SaveGraphState(); + CFX_Color crFill(fillColor); + pGraphics->SetFillColor(&crFill); + CFX_Path path; + path.Create(); + path.AddRectangle(pRect->left, pRect->top, pRect->width, pRect->height); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_WidgetTP::DrawAxialShading(CFX_Graphics* pGraphics, + FX_FLOAT fx1, + FX_FLOAT fy1, + FX_FLOAT fx2, + FX_FLOAT fy2, + FX_ARGB beginColor, + FX_ARGB endColor, + CFX_Path* path, + int32_t fillMode, + CFX_Matrix* pMatrix) { + if (!pGraphics || !path) + return; + + CFX_PointF begPoint(fx1, fy1); + CFX_PointF endPoint(fx2, fy2); + CFX_Shading shading; + shading.CreateAxial(begPoint, endPoint, FALSE, FALSE, beginColor, endColor); + pGraphics->SaveGraphState(); + CFX_Color color1(&shading); + pGraphics->SetFillColor(&color1); + pGraphics->FillPath(path, fillMode, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_WidgetTP::DrawAnnulusRect(CFX_Graphics* pGraphics, + FX_ARGB fillColor, + const CFX_RectF* pRect, + FX_FLOAT fRingWidth, + CFX_Matrix* pMatrix) { + if (!pGraphics) + return; + if (!pRect) + return; + pGraphics->SaveGraphState(); + CFX_Color cr(fillColor); + pGraphics->SetFillColor(&cr); + CFX_Path path; + path.Create(); + CFX_RectF rtInner(*pRect); + rtInner.Deflate(fRingWidth, fRingWidth); + path.AddRectangle(rtInner.left, rtInner.top, rtInner.width, rtInner.height); + path.AddRectangle(pRect->left, pRect->top, pRect->width, pRect->height); + pGraphics->FillPath(&path, FXFILL_ALTERNATE, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_WidgetTP::DrawAnnulusCircle(CFX_Graphics* pGraphics, + FX_ARGB fillColor, + const CFX_RectF* pRect, + FX_FLOAT fWidth, + CFX_Matrix* pMatrix) { + if (!pGraphics) + return; + if (!pRect) + return; + if (fWidth > pRect->width / 2) { + return; + } + pGraphics->SaveGraphState(); + CFX_Color cr(fillColor); + pGraphics->SetFillColor(&cr); + CFX_Path path; + path.Create(); + path.AddEllipse(*pRect); + CFX_RectF rtIn(*pRect); + rtIn.Inflate(-fWidth, -fWidth); + path.AddEllipse(rtIn); + pGraphics->FillPath(&path, FXFILL_ALTERNATE, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_WidgetTP::DrawFocus(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + CFX_Matrix* pMatrix) { + if (!pGraphics) + return; + if (!pRect) + return; + pGraphics->SaveGraphState(); + CFX_Color cr(0xFF000000); + pGraphics->SetStrokeColor(&cr); + FX_FLOAT DashPattern[2] = {1, 1}; + pGraphics->SetLineDash(0.0f, DashPattern, 2); + CFX_Path path; + path.Create(); + path.AddRectangle(pRect->left, pRect->top, pRect->width, pRect->height); + pGraphics->StrokePath(&path, pMatrix); + pGraphics->RestoreGraphState(); +} +#define FWLTHEME_ARROW_Denominator 3 +void CFWL_WidgetTP::DrawArrow(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_DIRECTION eDict, + FX_ARGB argbFill, + FX_BOOL bPressed, + CFX_Matrix* pMatrix) { + CFX_RectF rtArrow(*pRect); + CFX_Path path; + path.Create(); + FX_FLOAT fBtn = + std::min(pRect->width, pRect->height) / FWLTHEME_ARROW_Denominator; + rtArrow.left = pRect->left + (pRect->width - fBtn) / 2; + rtArrow.top = pRect->top + (pRect->height - fBtn) / 2; + rtArrow.width = fBtn; + rtArrow.height = fBtn; + if (bPressed) { + rtArrow.Offset(1, 1); + } + switch (eDict) { + case FWLTHEME_DIRECTION_Up: { + path.MoveTo(rtArrow.left, rtArrow.bottom()); + path.LineTo(rtArrow.right(), rtArrow.bottom()); + path.LineTo(rtArrow.left + fBtn / 2, rtArrow.top); + path.LineTo(rtArrow.left, rtArrow.bottom()); + break; + } + case FWLTHEME_DIRECTION_Left: { + path.MoveTo(rtArrow.right(), rtArrow.top); + path.LineTo(rtArrow.right(), rtArrow.bottom()); + path.LineTo(rtArrow.left, rtArrow.top + fBtn / 2); + path.LineTo(rtArrow.right(), rtArrow.top); + break; + } + case FWLTHEME_DIRECTION_Right: { + path.MoveTo(rtArrow.left, rtArrow.top); + path.LineTo(rtArrow.left, rtArrow.bottom()); + path.LineTo(rtArrow.right(), rtArrow.top + fBtn / 2); + path.LineTo(rtArrow.left, rtArrow.top); + break; + } + case FWLTHEME_DIRECTION_Down: + default: { + path.MoveTo(rtArrow.left, rtArrow.top); + path.LineTo(rtArrow.right(), rtArrow.top); + path.LineTo(rtArrow.left + fBtn / 2, rtArrow.bottom()); + path.LineTo(rtArrow.left, rtArrow.top); + } + } + pGraphics->SaveGraphState(); + CFX_Color cr(argbFill); + pGraphics->SetFillColor(&cr); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); + pGraphics->RestoreGraphState(); +} +void CFWL_WidgetTP::DrawArrow(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_DIRECTION eDict, + FX_ARGB argSign, + CFX_Matrix* pMatrix) { + FX_BOOL bVert = + (eDict == FWLTHEME_DIRECTION_Up || eDict == FWLTHEME_DIRECTION_Down); + FX_FLOAT fLeft = + (FX_FLOAT)(((pRect->width - (bVert ? 9 : 6)) / 2 + pRect->left) + 0.5); + FX_FLOAT fTop = + (FX_FLOAT)(((pRect->height - (bVert ? 6 : 9)) / 2 + pRect->top) + 0.5); + CFX_Path path; + path.Create(); + switch (eDict) { + case FWLTHEME_DIRECTION_Down: { + path.MoveTo(fLeft, fTop + 1); + path.LineTo(fLeft + 4, fTop + 5); + path.LineTo(fLeft + 8, fTop + 1); + path.LineTo(fLeft + 7, fTop); + path.LineTo(fLeft + 4, fTop + 3); + path.LineTo(fLeft + 1, fTop); + break; + } + case FWLTHEME_DIRECTION_Up: { + path.MoveTo(fLeft, fTop + 4); + path.LineTo(fLeft + 4, fTop); + path.LineTo(fLeft + 8, fTop + 4); + path.LineTo(fLeft + 7, fTop + 5); + path.LineTo(fLeft + 4, fTop + 2); + path.LineTo(fLeft + 1, fTop + 5); + break; + } + case FWLTHEME_DIRECTION_Right: { + path.MoveTo(fLeft + 1, fTop); + path.LineTo(fLeft + 5, fTop + 4); + path.LineTo(fLeft + 1, fTop + 8); + path.LineTo(fLeft, fTop + 7); + path.LineTo(fLeft + 3, fTop + 4); + path.LineTo(fLeft, fTop + 1); + break; + } + case FWLTHEME_DIRECTION_Left: { + path.MoveTo(fLeft, fTop + 4); + path.LineTo(fLeft + 4, fTop); + path.LineTo(fLeft + 5, fTop + 1); + path.LineTo(fLeft + 2, fTop + 4); + path.LineTo(fLeft + 5, fTop + 7); + path.LineTo(fLeft + 4, fTop + 8); + break; + } + } + CFX_Color cr(argSign); + pGraphics->SetFillColor(&cr); + pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix); +} +void CFWL_WidgetTP::DrawBtn(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_STATE eState, + CFX_Matrix* pMatrix) { + CFX_Path path; + path.Create(); + if (!CFWL_ArrowData::IsInstance()) { + CFWL_ArrowData::GetInstance()->SetColorData(FWL_GetThemeColor(m_dwThemeID)); + } + CFWL_ArrowData::CColorData* pColorData = + CFWL_ArrowData::GetInstance()->m_pColorData; + FX_FLOAT fRight = pRect->right(); + FX_FLOAT fBottom = pRect->bottom(); + path.AddRectangle(pRect->left, pRect->top, pRect->width, pRect->height); + DrawAxialShading(pGraphics, pRect->left, pRect->top, fRight, fBottom, + pColorData->clrStart[eState - 1], + pColorData->clrEnd[eState - 1], &path, FXFILL_WINDING, + pMatrix); + CFX_Color rcStroke; + rcStroke.Set(pColorData->clrBorder[eState - 1]); + pGraphics->SetStrokeColor(&rcStroke); + pGraphics->StrokePath(&path, pMatrix); +} +void CFWL_WidgetTP::DrawArrowBtn(CFX_Graphics* pGraphics, + const CFX_RectF* pRect, + FWLTHEME_DIRECTION eDict, + FWLTHEME_STATE eState, + CFX_Matrix* pMatrix) { + DrawBtn(pGraphics, pRect, eState, pMatrix); + if (!CFWL_ArrowData::IsInstance()) { + CFWL_ArrowData::GetInstance()->SetColorData(FWL_GetThemeColor(m_dwThemeID)); + } + CFWL_ArrowData::CColorData* pColorData = + CFWL_ArrowData::GetInstance()->m_pColorData; + DrawArrow(pGraphics, pRect, eDict, pColorData->clrSign[eState - 1], pMatrix); +} +FWLCOLOR CFWL_WidgetTP::BlendColor(FWLCOLOR srcColor, + FWLCOLOR renderColor, + uint8_t scale) { + FWLCOLOR dstColor; + uint8_t n = 255 - scale; + dstColor.a = (uint8_t)( + ((FX_WORD)srcColor.a * n + (FX_WORD)renderColor.a * scale) >> 8); + dstColor.r = (uint8_t)( + ((FX_WORD)srcColor.r * n + (FX_WORD)renderColor.r * scale) >> 8); + dstColor.g = (uint8_t)( + ((FX_WORD)srcColor.g * n + (FX_WORD)renderColor.g * scale) >> 8); + dstColor.b = (uint8_t)( + ((FX_WORD)srcColor.b * n + (FX_WORD)renderColor.b * scale) >> 8); + return dstColor; +} +CFWL_ArrowData::CFWL_ArrowData() : m_pColorData(NULL) { + SetColorData(0); +} +CFWL_FontData::CFWL_FontData() + : m_dwStyles(0), + m_dwCodePage(0), + m_pFont(0), + m_pFontMgr(NULL) +#if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_ + , + m_pFontSource(NULL) +#endif +{ +} +CFWL_FontData::~CFWL_FontData() { + if (m_pFont) { + m_pFont->Release(); + } + if (m_pFontMgr) { + m_pFontMgr->Release(); + } +#if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_ + if (m_pFontSource != NULL) { + m_pFontSource->Release(); + } +#endif +} +FX_BOOL CFWL_FontData::Equal(const CFX_WideStringC& wsFontFamily, + FX_DWORD dwFontStyles, + FX_WORD wCodePage) { + return m_wsFamily == wsFontFamily && m_dwStyles == dwFontStyles && + m_dwCodePage == wCodePage; +} +FX_BOOL CFWL_FontData::LoadFont(const CFX_WideStringC& wsFontFamily, + FX_DWORD dwFontStyles, + FX_WORD dwCodePage) { + m_wsFamily = wsFontFamily; + m_dwStyles = dwFontStyles; + m_dwCodePage = dwCodePage; + if (!m_pFontMgr) { +#if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ + m_pFontMgr = IFX_FontMgr::Create(FX_GetDefFontEnumerator()); +#else + m_pFontSource = FX_CreateDefaultFontSourceEnum(); + m_pFontMgr = IFX_FontMgr::Create(m_pFontSource); +#endif + } + m_pFont = IFX_Font::LoadFont(wsFontFamily.GetPtr(), dwFontStyles, dwCodePage, + m_pFontMgr); + return m_pFont != NULL; +} + +CFWL_FontManager* CFWL_FontManager::s_FontManager = nullptr; +CFWL_FontManager* CFWL_FontManager::GetInstance() { + if (!s_FontManager) + s_FontManager = new CFWL_FontManager; + return s_FontManager; +} +void CFWL_FontManager::DestroyInstance() { + delete s_FontManager; + s_FontManager = nullptr; +} +CFWL_FontManager::CFWL_FontManager() {} +CFWL_FontManager::~CFWL_FontManager() {} +IFX_Font* CFWL_FontManager::FindFont(const CFX_WideStringC& wsFontFamily, + FX_DWORD dwFontStyles, + FX_WORD wCodePage) { + for (const auto& pData : m_FontsArray) { + if (pData->Equal(wsFontFamily, dwFontStyles, wCodePage)) + return pData->GetFont(); + } + std::unique_ptr pFontData(new CFWL_FontData); + if (!pFontData->LoadFont(wsFontFamily, dwFontStyles, wCodePage)) + return nullptr; + m_FontsArray.push_back(std::move(pFontData)); + return m_FontsArray.back()->GetFont(); +} +FX_BOOL FWLTHEME_Init() { + return TRUE; +} +void FWLTHEME_Release() { + CFWL_ArrowData::DestroyInstance(); + CFWL_FontManager::DestroyInstance(); +} +FX_DWORD FWL_GetThemeLayout(FX_DWORD dwThemeID) { + return 0xffff0000 & dwThemeID; +} +FX_DWORD FWL_GetThemeColor(FX_DWORD dwThemeID) { + return 0x0000ffff & dwThemeID; +} +FX_DWORD FWL_MakeThemeID(FX_DWORD dwLayout, FX_DWORD dwColor) { + return (dwLayout << 16) | (0x0000FFFF & dwColor); +} +CFWL_ArrowData* CFWL_ArrowData::m_pInstance = NULL; +CFWL_ArrowData* CFWL_ArrowData::GetInstance() { + if (!m_pInstance) { + m_pInstance = new CFWL_ArrowData; + } + return m_pInstance; +} +FX_BOOL CFWL_ArrowData::IsInstance() { + return (m_pInstance != NULL); +} +void CFWL_ArrowData::DestroyInstance() { + if (m_pInstance) { + delete m_pInstance; + m_pInstance = NULL; + } +} +CFWL_ArrowData::~CFWL_ArrowData() { + if (m_pColorData) { + delete m_pColorData; + m_pColorData = NULL; + } +} +void CFWL_ArrowData::SetColorData(FX_DWORD dwID) { + if (!m_pColorData) { + m_pColorData = new CColorData; + } + if (dwID) { + m_pColorData->clrBorder[0] = ArgbEncode(255, 142, 153, 125); + m_pColorData->clrBorder[1] = ArgbEncode(255, 157, 171, 119); + m_pColorData->clrBorder[2] = ArgbEncode(255, 118, 131, 97); + m_pColorData->clrBorder[3] = ArgbEncode(255, 172, 168, 153); + m_pColorData->clrStart[0] = ArgbEncode(255, 203, 215, 186); + m_pColorData->clrStart[1] = ArgbEncode(255, 218, 232, 185); + m_pColorData->clrStart[2] = ArgbEncode(255, 203, 215, 186); + m_pColorData->clrStart[3] = ArgbEncode(255, 254, 254, 251); + m_pColorData->clrEnd[0] = ArgbEncode(255, 149, 167, 117); + m_pColorData->clrEnd[1] = ArgbEncode(255, 198, 211, 155); + m_pColorData->clrEnd[2] = ArgbEncode(255, 149, 167, 117); + m_pColorData->clrEnd[3] = ArgbEncode(255, 243, 241, 236); + m_pColorData->clrSign[0] = ArgbEncode(255, 255, 255, 255); + m_pColorData->clrSign[1] = ArgbEncode(255, 255, 255, 255); + m_pColorData->clrSign[2] = ArgbEncode(255, 255, 255, 255); + m_pColorData->clrSign[3] = ArgbEncode(255, 128, 128, 128); + } else { + m_pColorData->clrBorder[0] = ArgbEncode(255, 202, 216, 249); + m_pColorData->clrBorder[1] = ArgbEncode(255, 171, 190, 233); + m_pColorData->clrBorder[2] = ArgbEncode(255, 135, 147, 219); + m_pColorData->clrBorder[3] = ArgbEncode(255, 172, 168, 153); + m_pColorData->clrStart[0] = ArgbEncode(255, 225, 234, 254); + m_pColorData->clrStart[1] = ArgbEncode(255, 253, 255, 255); + m_pColorData->clrStart[2] = ArgbEncode(255, 110, 142, 241); + m_pColorData->clrStart[3] = ArgbEncode(255, 254, 254, 251); + m_pColorData->clrEnd[0] = ArgbEncode(255, 175, 204, 251); + m_pColorData->clrEnd[1] = ArgbEncode(255, 185, 218, 251); + m_pColorData->clrEnd[2] = ArgbEncode(255, 210, 222, 235); + m_pColorData->clrEnd[3] = ArgbEncode(255, 243, 241, 236); + m_pColorData->clrSign[0] = ArgbEncode(255, 77, 97, 133); + m_pColorData->clrSign[1] = ArgbEncode(255, 77, 97, 133); + m_pColorData->clrSign[2] = ArgbEncode(255, 77, 97, 133); + m_pColorData->clrSign[3] = ArgbEncode(255, 128, 128, 128); + } +} -- cgit v1.2.3