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 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_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::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_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::DrawBorder(CFX_Graphics* pGraphics,
const CFX_RectF* pRect,
CFX_Matrix* pMatrix) {
if (!pGraphics)
return;
if (!pRect)
return;
CFX_Path path;
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_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_ComboBoxTP::DrawStrethHandler(CFWL_ThemeBackground* pParams,
uint32_t dwStates,
CFX_Matrix* pMatrix) {
CFX_Path path;
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_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::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_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);
}
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.AddRectangle(pRect->left, pRect->top, pRect->width, pRect->height);
pGraphics->FillPath(&path, FXFILL_WINDING, pMatrix);
pGraphics->RestoreGraphState();
}
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_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.AddRectangle(pRect->left, pRect->top, pRect->width, pRect->height);
pGraphics->StrokePath(&path, pMatrix);
pGraphics->RestoreGraphState();
}
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_ComboBoxTP::DrawBackground(CFWL_ThemeBackground* pParams) {
if (!pParams)
return;
switch (pParams->m_iPart) {
case CFWL_Part::Border: {
DrawBorder(pParams->m_pGraphics, &pParams->m_rtPart, &pParams->m_matrix);
break;
}
case CFWL_Part::Background: {
CFX_Path path;
CFX_RectF& rect = pParams->m_rtPart;
path.AddRectangle(rect.left, rect.top, rect.width, rect.height);
FX_ARGB argb_color;
switch (pParams->m_dwStates) {
case CFWL_PartState_Selected:
argb_color = FWLTHEME_COLOR_BKSelected;
break;
case CFWL_PartState_Disabled:
argb_color = FWLTHEME_COLOR_EDGERB1;
break;
default:
argb_color = 0xFFFFFFFF;
}
pParams->m_pGraphics->SaveGraphState();
CFX_Color cr(argb_color);
pParams->m_pGraphics->SetFillColor(&cr);
pParams->m_pGraphics->FillPath(&path, FXFILL_WINDING, &pParams->m_matrix);
pParams->m_pGraphics->RestoreGraphState();
break;
}
case CFWL_Part::DropDownButton: {
DrawDropDownButton(pParams, pParams->m_dwStates, &pParams->m_matrix);
break;
}
case CFWL_Part::StretchHandler: {
DrawStrethHandler(pParams, 0, &pParams->m_matrix);
break;
}
default:
break;
}
}
void CFWL_WidgetTP::DrawBtn(CFX_Graphics* pGraphics,
const CFX_RectF* pRect,
FWLTHEME_STATE eState,
CFX_Matrix* pMatrix) {
CFX_Path path;
InitializeArrowColorData();
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,
m_pColorData->clrStart[eState - 1],
m_pColorData->clrEnd[eState - 1], &path, FXFILL_WINDING,
pMatrix);
CFX_Color rcStroke;
rcStroke.Set(m_pColorData->clrBorder[eState - 1]);
pGraphics->SetStrokeColor(&rcStroke);
pGraphics->StrokePath(&path, pMatrix);
}
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);
}
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);
}
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;
}
FX_BOOL CFWL_PushButtonTP::DrawBackground(CFWL_ThemeBackground* pParams) {
switch (pParams->m_iPart) {
case CFWL_Part::Border: {
DrawBorder(pParams->m_pGraphics, &pParams->m_rtPart, &pParams->m_matrix);
break;
}
case CFWL_Part::Edge: {
DrawEdge(pParams->m_pGraphics, pParams->m_pWidget->GetStyles(),
&pParams->m_rtPart, &pParams->m_matrix);
break;
}
case CFWL_Part::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 & CFWL_PartState_Focused) {
rtInner.Inflate(1, 1, 0, 0);
DrawFocus(pGraphics, &rtInner, &pParams->m_matrix);
}
pGraphics->RestoreGraphState();
break;
}
default: {}
}
return TRUE;
}
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,
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_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();
}