void CXFA_FFPushButton::OnDrawWidget(CFX_Graphics* pGraphics,
const CFX_Matrix* pMatrix) {
if (m_pNormalWidget->GetStylesEx() & XFA_FWL_PSBSTYLEEXT_HiliteInverted) {
if ((m_pNormalWidget->GetStates() & FWL_STATE_PSB_Pressed) &&
(m_pNormalWidget->GetStates() & FWL_STATE_PSB_Hovered)) {
CFX_RectF rtFill;
m_pNormalWidget->GetWidgetRect(rtFill);
rtFill.left = rtFill.top = 0;
FX_FLOAT fLineWith = GetLineWidth();
rtFill.Deflate(fLineWith, fLineWith);
CFX_Color cr(FXARGB_MAKE(128, 128, 255, 255));
pGraphics->SetFillColor(&cr);
CFX_Path path;
path.Create();
path.AddRectangle(rtFill.left, rtFill.top, rtFill.width, rtFill.height);
pGraphics->FillPath(&path, FXFILL_WINDING, (CFX_Matrix*)pMatrix);
}
} else if (m_pNormalWidget->GetStylesEx() &
XFA_FWL_PSBSTYLEEXT_HiliteOutLine) {
if ((m_pNormalWidget->GetStates() & FWL_STATE_PSB_Pressed) &&
(m_pNormalWidget->GetStates() & FWL_STATE_PSB_Hovered)) {
FX_FLOAT fLineWidth = GetLineWidth();
CFX_Color cr(FXARGB_MAKE(255, 128, 255, 255));
pGraphics->SetStrokeColor(&cr);
pGraphics->SetLineWidth(fLineWidth);
CFX_Path path;
path.Create();
CFX_RectF rect;
m_pNormalWidget->GetWidgetRect(rect);
path.AddRectangle(0, 0, rect.width, rect.height);
pGraphics->StrokePath(&path, (CFX_Matrix*)pMatrix);
}
}
}
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);
}
}
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_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();
}
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);
}
}
}
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_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_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::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_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 CXFA_FFLine::RenderWidget(CFX_Graphics* pGS,
CFX_Matrix* pMatrix,
uint32_t dwStatus) {
if (!IsMatchVisibleStatus(dwStatus)) {
return;
}
CXFA_Value value = m_pDataAcc->GetFormValue();
if (!value) {
return;
}
CXFA_Line lineObj = value.GetLine();
FX_ARGB lineColor = 0xFF000000;
int32_t iStrokeType = 0;
FX_FLOAT fLineWidth = 1.0f;
FX_BOOL bSlope = lineObj.GetSlop();
int32_t iCap = 0;
CXFA_Edge edge = lineObj.GetEdge();
if (edge) {
if (edge.GetPresence() != XFA_ATTRIBUTEENUM_Visible) {
return;
}
lineColor = edge.GetColor();
iStrokeType = edge.GetStrokeType();
fLineWidth = edge.GetThickness();
iCap = edge.GetCapType();
}
CFX_Matrix mtRotate;
GetRotateMatrix(mtRotate);
if (pMatrix) {
mtRotate.Concat(*pMatrix);
}
CFX_RectF rtLine;
GetRectWithoutRotate(rtLine);
if (CXFA_Margin mgWidget = m_pDataAcc->GetMargin()) {
XFA_RectWidthoutMargin(rtLine, mgWidget);
}
GetRectFromHand(rtLine, lineObj.GetHand(), fLineWidth);
CFX_Path linePath;
linePath.Create();
if (bSlope && rtLine.right() > 0.0f && rtLine.bottom() > 0.0f) {
linePath.AddLine(rtLine.right(), rtLine.top, rtLine.left, rtLine.bottom());
} else {
linePath.AddLine(rtLine.left, rtLine.top, rtLine.right(), rtLine.bottom());
}
CFX_Color color(lineColor);
pGS->SaveGraphState();
pGS->SetLineWidth(fLineWidth, TRUE);
XFA_StrokeTypeSetLineDash(pGS, iStrokeType, iCap);
pGS->SetStrokeColor(&color);
pGS->SetLineCap(XFA_LineCapToFXGE(iCap));
pGS->StrokePath(&linePath, &mtRotate);
pGS->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 CXFA_FFField::DrawFocus(CFX_Graphics* pGS, CFX_Matrix* pMatrix) {
if (m_dwStatus & XFA_WidgetStatus_Focused) {
CFX_Color cr(0xFF000000);
pGS->SetStrokeColor(&cr);
FX_FLOAT DashPattern[2] = {1, 1};
pGS->SetLineDash(0.0f, DashPattern, 2);
pGS->SetLineWidth(0, FALSE);
CFX_Path path;
path.Create();
path.AddRectangle(m_rtUI.left, m_rtUI.top, m_rtUI.width, m_rtUI.height);
pGS->StrokePath(&path, pMatrix);
}
}
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::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_CheckBoxTP::DrawBoxBk(IFWL_Widget* pWidget,
CFX_Graphics* pGraphics,
const CFX_RectF* pRect,
uint32_t dwStates,
CFX_Matrix* pMatrix) {
dwStates &= 0x03;
int32_t fillMode = FXFILL_WINDING;
uint32_t dwStyleEx = pWidget->GetStylesEx();
dwStyleEx &= FWL_STYLEEXT_CKB_ShapeMask;
CFX_Path path;
path.Create();
FX_FLOAT fRight = pRect->right();
FX_FLOAT fBottom = pRect->bottom();
bool bClipSign = !!(dwStates & CFWL_PartState_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 + kSignMargin, pRect->top + kSignMargin,
pRect->width - kSignMargin * 2,
pRect->height - kSignMargin * 2);
}
} else {
CFX_RectF rect(*pRect);
rect.Deflate(0, 0, 1, 1);
path.AddEllipse(rect);
if (bClipSign) {
fillMode = FXFILL_ALTERNATE;
CFX_RectF rtClip(rect);
rtClip.Deflate(kSignMargin - 1, kSignMargin - 1);
path.AddEllipse(rtClip);
}
}
int32_t iTheme = 1;
if (dwStates & CFWL_PartState_Hovered) {
iTheme = 2;
} else if (dwStates & CFWL_PartState_Pressed) {
iTheme = 3;
} else if (dwStates & CFWL_PartState_Disabled) {
iTheme = 4;
}
if (dwStates & CFWL_PartState_Checked) {
iTheme += 4;
} else if (dwStates & CFWL_PartState_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::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_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);
}
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_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_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_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::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::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();
}
FWL_ERR CFWL_GridImp::DrawWidget(CFX_Graphics* pGraphics,
const CFX_Matrix* pMatrix) {
if (!pGraphics)
return FWL_ERR_Indefinite;
if ((m_pProperties->m_dwStyleExes & FWL_GRIDSTYLEEXT_ShowGridLines) == 0) {
return FWL_ERR_Succeeded;
}
pGraphics->SaveGraphState();
if (pMatrix) {
pGraphics->ConcatMatrix(pMatrix);
}
{
FX_BOOL bDrawLine = FALSE;
CFX_Path path;
path.Create();
int32_t iColumns = m_Columns.GetSize();
for (int32_t i = 1; i < iColumns; i++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Columns[i]);
if (!pColRow) {
continue;
}
bDrawLine = TRUE;
path.AddLine(pColRow->m_fActualPos, 0, pColRow->m_fActualPos,
m_pProperties->m_rtWidget.height);
}
int32_t iRows = m_Rows.GetSize();
for (int32_t j = 1; j < iRows; j++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Rows[j]);
if (!pColRow) {
continue;
}
bDrawLine = TRUE;
path.AddLine(0, pColRow->m_fActualPos, m_pProperties->m_rtWidget.width,
pColRow->m_fActualPos);
}
if (bDrawLine) {
CFX_Color cr(0xFFFF0000);
pGraphics->SetStrokeColor(&cr);
pGraphics->StrokePath(&path);
}
}
pGraphics->RestoreGraphState();
return FWL_ERR_Succeeded;
}
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_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_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 CXFA_FFField::DrawHighlight(CFX_Graphics* pGS,
CFX_Matrix* pMatrix,
uint32_t dwStatus,
FX_BOOL bEllipse) {
if (m_rtUI.IsEmpty() || !m_pDataAcc->GetDoc()->GetXFADoc()->IsInteractive()) {
return;
}
if ((dwStatus & XFA_WidgetStatus_Highlight) &&
m_pDataAcc->GetAccess() == XFA_ATTRIBUTEENUM_Open) {
CXFA_FFDoc* pDoc = GetDoc();
CFX_Color crHighlight(pDoc->GetDocProvider()->GetHighlightColor(pDoc));
pGS->SetFillColor(&crHighlight);
CFX_Path path;
path.Create();
if (bEllipse) {
path.AddEllipse(m_rtUI);
} else {
path.AddRectangle(m_rtUI.left, m_rtUI.top, m_rtUI.width, m_rtUI.height);
}
pGS->FillPath(&path, FXFILL_WINDING, pMatrix);
}
}
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);
}