blob: b68ace8dce0f15cd6d3e7537af9ab92a18213b9d [file] [log] [blame]
// 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/fde/css/fde_cssstyleselector.h"
#include <algorithm>
#include <memory>
#include "xfa/fde/css/fde_csscache.h"
#include "xfa/fde/css/fde_cssdeclaration.h"
#include "xfa/fde/css/fde_cssstylesheet.h"
#include "xfa/fde/css/fde_csssyntax.h"
#include "xfa/fxfa/app/xfa_textlayout.h"
#define FDE_CSSUNIVERSALHASH ('*')
int32_t CFDE_CSSCounterStyle::FindIndex(const FX_WCHAR* pszIdentifier) {
int32_t iCount = m_arrCounterData.GetSize();
for (int32_t i = 0; i < iCount; i++) {
if (FXSYS_wcscmp(pszIdentifier, m_arrCounterData.ElementAt(i).m_pszIdent) ==
0) {
return i;
}
}
return -1;
}
void CFDE_CSSCounterStyle::DoUpdateIndex(IFDE_CSSValueList* pList) {
if (!pList)
return;
int32_t iCount = pList->CountValues();
FX_FLOAT fDefValue = 1.0;
FX_BOOL bDefIncrement = TRUE;
if (pList == m_pCounterReset) {
fDefValue = 0.0;
bDefIncrement = FALSE;
}
for (int32_t i = 0; i < iCount; i++) {
IFDE_CSSValueList* pCounter =
static_cast<IFDE_CSSValueList*>(pList->GetValue(i));
int32_t iLen;
const FX_WCHAR* pszIdentifier =
static_cast<IFDE_CSSPrimitiveValue*>(pCounter->GetValue(0))
->GetString(iLen);
FX_FLOAT fValue = fDefValue;
if (pCounter->CountValues() > 1) {
fValue = static_cast<IFDE_CSSPrimitiveValue*>(pCounter->GetValue(1))
->GetFloat();
}
int32_t iIndex = FindIndex(pszIdentifier);
if (iIndex == -1) {
FDE_CSSCOUNTERDATA data;
data.m_pszIdent = pszIdentifier;
if (bDefIncrement) {
data.m_bIncrement = TRUE;
data.m_iIncVal = (int32_t)fValue;
} else {
data.m_iResetVal = (int32_t)fValue;
data.m_bReset = TRUE;
}
m_arrCounterData.Add(data);
} else {
FDE_CSSCOUNTERDATA& data = m_arrCounterData.ElementAt(iIndex);
if (bDefIncrement) {
data.m_bIncrement = TRUE;
data.m_iIncVal += (int32_t)fValue;
} else {
data.m_bReset = TRUE;
data.m_iResetVal = (int32_t)fValue;
}
}
}
}
CFDE_CSSCounterStyle::CFDE_CSSCounterStyle()
: m_pCounterInc(nullptr), m_pCounterReset(nullptr), m_bIndexDirty(FALSE) {}
CFDE_CSSCounterStyle::~CFDE_CSSCounterStyle() {}
void CFDE_CSSCounterStyle::UpdateIndex() {
if (!m_bIndexDirty) {
return;
}
m_arrCounterData.RemoveAll();
DoUpdateIndex(m_pCounterInc);
DoUpdateIndex(m_pCounterReset);
m_bIndexDirty = FALSE;
}
FDE_CSSRuleData::FDE_CSSRuleData(CFDE_CSSSelector* pSel,
CFDE_CSSDeclaration* pDecl,
uint32_t dwPos)
: pSelector(pSel), pDeclaration(pDecl), dwPriority(dwPos), pNext(nullptr) {
static const uint32_t s_Specific[5] = {0x00010000, 0x00010000, 0x00100000,
0x00100000, 0x01000000};
for (; pSel; pSel = pSel->GetNextSelector()) {
FDE_CSSSELECTORTYPE eType = pSel->GetType();
if (eType > FDE_CSSSELECTORTYPE_Descendant ||
pSel->GetNameHash() != FDE_CSSUNIVERSALHASH) {
dwPriority += s_Specific[eType];
}
}
}
CFDE_CSSStyleSelector::CFDE_CSSStyleSelector(IFGAS_FontMgr* pFontMgr)
: m_pFontMgr(pFontMgr), m_fDefFontSize(12.0f) {
m_ePriorities[FDE_CSSSTYLESHEETPRIORITY_High] = FDE_CSSSTYLESHEETGROUP_Author;
m_ePriorities[FDE_CSSSTYLESHEETPRIORITY_Mid] = FDE_CSSSTYLESHEETGROUP_User;
m_ePriorities[FDE_CSSSTYLESHEETPRIORITY_Low] =
FDE_CSSSTYLESHEETGROUP_UserAgent;
}
CFDE_CSSStyleSelector::~CFDE_CSSStyleSelector() {
Reset();
}
void CFDE_CSSStyleSelector::SetDefFontSize(FX_FLOAT fFontSize) {
ASSERT(fFontSize > 0);
m_fDefFontSize = fFontSize;
}
CFDE_CSSAccelerator* CFDE_CSSStyleSelector::InitAccelerator() {
if (!m_pAccelerator)
m_pAccelerator.reset(new CFDE_CSSAccelerator);
m_pAccelerator->Clear();
return m_pAccelerator.get();
}
IFDE_CSSComputedStyle* CFDE_CSSStyleSelector::CreateComputedStyle(
IFDE_CSSComputedStyle* pParentStyle) {
if (!m_pFixedStyleStore) {
m_pFixedStyleStore = IFX_MemoryAllocator::Create(
FX_ALLOCTYPE_Fixed, 16, sizeof(CFDE_CSSComputedStyle));
}
CFDE_CSSComputedStyle* pStyle = FXTARGET_NewWith(m_pFixedStyleStore.get())
CFDE_CSSComputedStyle(m_pFixedStyleStore.get());
if (pParentStyle) {
pStyle->m_InheritedData =
static_cast<CFDE_CSSComputedStyle*>(pParentStyle)->m_InheritedData;
} else {
pStyle->m_InheritedData.Reset();
}
pStyle->m_NonInheritedData.Reset();
return pStyle;
}
FX_BOOL CFDE_CSSStyleSelector::SetStyleSheet(FDE_CSSSTYLESHEETGROUP eType,
IFDE_CSSStyleSheet* pSheet) {
ASSERT(eType < FDE_CSSSTYLESHEETGROUP_MAX);
CFDE_CSSStyleSheetArray& dest = m_SheetGroups[eType];
dest.RemoveAt(0, dest.GetSize());
if (pSheet)
dest.Add(pSheet);
return TRUE;
}
FX_BOOL CFDE_CSSStyleSelector::SetStyleSheets(
FDE_CSSSTYLESHEETGROUP eType,
const CFDE_CSSStyleSheetArray* pArray) {
ASSERT(eType < FDE_CSSSTYLESHEETGROUP_MAX);
CFDE_CSSStyleSheetArray& dest = m_SheetGroups[eType];
if (pArray)
dest.Copy(*pArray);
else
dest.RemoveAt(0, dest.GetSize());
return TRUE;
}
void CFDE_CSSStyleSelector::SetStylePriority(
FDE_CSSSTYLESHEETGROUP eType,
FDE_CSSSTYLESHEETPRIORITY ePriority) {
m_ePriorities[ePriority] = eType;
}
void CFDE_CSSStyleSelector::UpdateStyleIndex(uint32_t dwMediaList) {
Reset();
m_pRuleDataStore = IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Static, 1024, 0);
for (int32_t iGroup = 0; iGroup < FDE_CSSSTYLESHEETGROUP_MAX; ++iGroup) {
CFDE_CSSRuleCollection& rules = m_RuleCollection[iGroup];
rules.m_pStaticStore = m_pRuleDataStore.get();
rules.AddRulesFrom(m_SheetGroups[iGroup], dwMediaList, m_pFontMgr);
}
}
void CFDE_CSSStyleSelector::Reset() {
for (int32_t iGroup = 0; iGroup < FDE_CSSSTYLESHEETGROUP_MAX; ++iGroup) {
m_RuleCollection[iGroup].Clear();
}
m_pRuleDataStore.reset();
}
int32_t CFDE_CSSStyleSelector::MatchDeclarations(
CXFA_CSSTagProvider* pTag,
CFDE_CSSDeclarationArray& matchedDecls,
FDE_CSSPERSUDO ePersudoType) {
ASSERT(m_pAccelerator && pTag);
FDE_CSSTagCache* pCache = m_pAccelerator->GetTopElement();
ASSERT(pCache && pCache->GetTag() == pTag);
matchedDecls.RemoveAt(0, matchedDecls.GetSize());
for (int32_t ePriority = FDE_CSSSTYLESHEETPRIORITY_MAX - 1; ePriority >= 0;
--ePriority) {
FDE_CSSSTYLESHEETGROUP eGroup = m_ePriorities[ePriority];
CFDE_CSSRuleCollection& rules = m_RuleCollection[eGroup];
if (rules.CountSelectors() == 0)
continue;
if (ePersudoType == FDE_CSSPERSUDO_NONE) {
MatchRules(pCache, rules.GetUniversalRuleData(), ePersudoType);
if (pCache->HashTag()) {
MatchRules(pCache, rules.GetTagRuleData(pCache->HashTag()),
ePersudoType);
}
int32_t iCount = pCache->CountHashClass();
for (int32_t i = 0; i < iCount; i++) {
pCache->SetClassIndex(i);
MatchRules(pCache, rules.GetClassRuleData(pCache->HashClass()),
ePersudoType);
}
} else {
MatchRules(pCache, rules.GetPersudoRuleData(), ePersudoType);
}
std::sort(m_MatchedRules.begin(), m_MatchedRules.end(),
[](const FDE_CSSRuleData* p1, const FDE_CSSRuleData* p2) {
return p1->dwPriority < p2->dwPriority;
});
for (const auto& rule : m_MatchedRules)
matchedDecls.Add(rule->pDeclaration);
m_MatchedRules.clear();
}
return matchedDecls.GetSize();
}
void CFDE_CSSStyleSelector::MatchRules(FDE_CSSTagCache* pCache,
FDE_CSSRuleData* pList,
FDE_CSSPERSUDO ePersudoType) {
while (pList) {
if (MatchSelector(pCache, pList->pSelector, ePersudoType))
m_MatchedRules.push_back(pList);
pList = pList->pNext;
}
}
FX_BOOL CFDE_CSSStyleSelector::MatchSelector(FDE_CSSTagCache* pCache,
CFDE_CSSSelector* pSel,
FDE_CSSPERSUDO ePersudoType) {
uint32_t dwHash;
while (pSel && pCache) {
switch (pSel->GetType()) {
case FDE_CSSSELECTORTYPE_Descendant:
dwHash = pSel->GetNameHash();
while ((pCache = pCache->GetParent()) != nullptr) {
if (dwHash != FDE_CSSUNIVERSALHASH && dwHash != pCache->HashTag()) {
continue;
}
if (MatchSelector(pCache, pSel->GetNextSelector(), ePersudoType)) {
return TRUE;
}
}
return FALSE;
case FDE_CSSSELECTORTYPE_ID:
dwHash = pCache->HashID();
if (dwHash != pSel->GetNameHash()) {
return FALSE;
}
break;
case FDE_CSSSELECTORTYPE_Class:
dwHash = pCache->HashClass();
if (dwHash != pSel->GetNameHash()) {
return FALSE;
}
break;
case FDE_CSSSELECTORTYPE_Element:
dwHash = pSel->GetNameHash();
if (dwHash != FDE_CSSUNIVERSALHASH && dwHash != pCache->HashTag()) {
return FALSE;
}
break;
case FDE_CSSSELECTORTYPE_Persudo:
dwHash = FDE_GetCSSPersudoByEnum(ePersudoType)->dwHash;
if (dwHash != pSel->GetNameHash()) {
return FALSE;
}
break;
default:
ASSERT(FALSE);
break;
}
pSel = pSel->GetNextSelector();
}
return !pSel && pCache;
}
void CFDE_CSSStyleSelector::ComputeStyle(
CXFA_CSSTagProvider* pTag,
const CFDE_CSSDeclaration** ppDeclArray,
int32_t iDeclCount,
IFDE_CSSComputedStyle* pDestStyle) {
ASSERT(iDeclCount >= 0);
ASSERT(pDestStyle);
static const uint32_t s_dwStyleHash = FX_HashCode_GetW(L"style", true);
static const uint32_t s_dwAlignHash = FX_HashCode_GetW(L"align", true);
if (!pTag->empty()) {
if (!m_pInlineStyleStore) {
m_pInlineStyleStore =
IFX_MemoryAllocator::Create(FX_ALLOCTYPE_Static, 2048, 0);
}
CFDE_CSSDeclaration* pDecl = nullptr;
for (auto it : *pTag) {
CFX_WideString wsAttri = it.first;
CFX_WideString wsValue = it.second;
uint32_t dwAttriHash = FX_HashCode_GetW(wsAttri.AsStringC(), true);
if (dwAttriHash == s_dwStyleHash) {
if (!pDecl)
pDecl =
FXTARGET_NewWith(m_pInlineStyleStore.get()) CFDE_CSSDeclaration;
AppendInlineStyle(pDecl, wsValue.c_str(), wsValue.GetLength());
} else if (dwAttriHash == s_dwAlignHash) {
if (!pDecl)
pDecl =
FXTARGET_NewWith(m_pInlineStyleStore.get()) CFDE_CSSDeclaration;
FDE_CSSPROPERTYARGS args;
args.pStringCache = nullptr;
args.pStaticStore = m_pInlineStyleStore.get();
args.pProperty = FDE_GetCSSPropertyByEnum(FDE_CSSPROPERTY_TextAlign);
pDecl->AddProperty(&args, wsValue.c_str(), wsValue.GetLength());
}
}
if (pDecl) {
CFDE_CSSDeclarationArray decls;
decls.SetSize(iDeclCount + 1);
CFDE_CSSDeclaration** ppInline = decls.GetData();
FXSYS_memcpy(ppInline, ppDeclArray,
iDeclCount * sizeof(CFDE_CSSDeclaration*));
ppInline[iDeclCount++] = pDecl;
ApplyDeclarations(TRUE, const_cast<const CFDE_CSSDeclaration**>(ppInline),
iDeclCount, pDestStyle);
ApplyDeclarations(FALSE,
const_cast<const CFDE_CSSDeclaration**>(ppInline),
iDeclCount, pDestStyle);
return;
}
}
if (iDeclCount > 0) {
ASSERT(ppDeclArray);
ApplyDeclarations(TRUE, ppDeclArray, iDeclCount, pDestStyle);
ApplyDeclarations(FALSE, ppDeclArray, iDeclCount, pDestStyle);
}
}
void CFDE_CSSStyleSelector::ApplyDeclarations(
FX_BOOL bPriority,
const CFDE_CSSDeclaration** ppDeclArray,
int32_t iDeclCount,
IFDE_CSSComputedStyle* pDestStyle) {
CFDE_CSSComputedStyle* pComputedStyle =
static_cast<CFDE_CSSComputedStyle*>(pDestStyle);
IFDE_CSSValue* pVal;
FX_BOOL bImportant;
int32_t i;
if (bPriority) {
IFDE_CSSValue* pLastest = nullptr;
IFDE_CSSValue* pImportant = nullptr;
for (i = 0; i < iDeclCount; ++i) {
pVal = ppDeclArray[i]->GetProperty(FDE_CSSPROPERTY_FontSize, bImportant);
if (!pVal)
continue;
if (bImportant)
pImportant = pVal;
else
pLastest = pVal;
}
if (pImportant) {
ApplyProperty(FDE_CSSPROPERTY_FontSize, pImportant, pComputedStyle);
} else if (pLastest) {
ApplyProperty(FDE_CSSPROPERTY_FontSize, pLastest, pComputedStyle);
}
} else {
CFDE_CSSDeclarationArray importants;
const CFDE_CSSDeclaration* pDecl = nullptr;
FDE_CSSPROPERTY eProp;
FX_POSITION pos;
for (i = 0; i < iDeclCount; ++i) {
pDecl = ppDeclArray[i];
pos = pDecl->GetStartPosition();
while (pos) {
pDecl->GetNextProperty(pos, eProp, pVal, bImportant);
if (eProp == FDE_CSSPROPERTY_FontSize) {
continue;
} else if (!bImportant) {
ApplyProperty(eProp, pVal, pComputedStyle);
} else if (importants.GetSize() == 0 ||
importants[importants.GetUpperBound()] != pDecl) {
importants.Add(const_cast<CFDE_CSSDeclaration*>(pDecl));
}
}
}
iDeclCount = importants.GetSize();
for (i = 0; i < iDeclCount; ++i) {
pDecl = importants[i];
pos = pDecl->GetStartPosition();
while (pos) {
pDecl->GetNextProperty(pos, eProp, pVal, bImportant);
if (bImportant && eProp != FDE_CSSPROPERTY_FontSize) {
ApplyProperty(eProp, pVal, pComputedStyle);
}
}
}
CFX_WideString wsName, wsValue;
pos = pDecl->GetStartCustom();
while (pos) {
pDecl->GetNextCustom(pos, wsName, wsValue);
pComputedStyle->AddCustomStyle(wsName, wsValue);
}
}
}
void CFDE_CSSStyleSelector::AppendInlineStyle(CFDE_CSSDeclaration* pDecl,
const FX_WCHAR* psz,
int32_t iLen) {
ASSERT(pDecl && psz && iLen > 0);
std::unique_ptr<CFDE_CSSSyntaxParser> pSyntax(new CFDE_CSSSyntaxParser);
if (!pSyntax->Init(psz, iLen, 32, TRUE))
return;
int32_t iLen2 = 0;
const FX_WCHAR* psz2;
FDE_CSSPROPERTYARGS args;
args.pStringCache = nullptr;
args.pStaticStore = m_pInlineStyleStore.get();
args.pProperty = nullptr;
CFX_WideString wsName;
while (1) {
FDE_CSSSYNTAXSTATUS eStatus = pSyntax->DoSyntaxParse();
if (eStatus == FDE_CSSSYNTAXSTATUS_PropertyName) {
psz2 = pSyntax->GetCurrentString(iLen2);
args.pProperty = FDE_GetCSSPropertyByName(CFX_WideStringC(psz2, iLen2));
if (!args.pProperty)
wsName = CFX_WideStringC(psz2, iLen2);
} else if (eStatus == FDE_CSSSYNTAXSTATUS_PropertyValue) {
if (args.pProperty) {
psz2 = pSyntax->GetCurrentString(iLen2);
if (iLen2 > 0)
pDecl->AddProperty(&args, psz2, iLen2);
} else if (iLen2 > 0) {
psz2 = pSyntax->GetCurrentString(iLen2);
if (iLen2 > 0) {
pDecl->AddProperty(&args, wsName.c_str(), wsName.GetLength(), psz2,
iLen2);
}
}
} else {
break;
}
}
}
#define FDE_CSSNONINHERITS (pComputedStyle->m_NonInheritedData)
#define FDE_CSSINHERITS (pComputedStyle->m_InheritedData)
#define FDE_CSSFONTSIZE (FDE_CSSINHERITS.m_fFontSize)
void CFDE_CSSStyleSelector::ApplyProperty(
FDE_CSSPROPERTY eProperty,
IFDE_CSSValue* pValue,
CFDE_CSSComputedStyle* pComputedStyle) {
if (pValue->GetType() == FDE_CSSVALUETYPE_Primitive) {
IFDE_CSSPrimitiveValue* pPrimitive =
static_cast<IFDE_CSSPrimitiveValue*>(pValue);
FDE_CSSPRIMITIVETYPE eType = pPrimitive->GetPrimitiveType();
switch (eProperty) {
case FDE_CSSPROPERTY_Display:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eDisplay = ToDisplay(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_FontSize: {
FX_FLOAT& fFontSize = FDE_CSSFONTSIZE;
if (eType >= FDE_CSSPRIMITIVETYPE_Number &&
eType <= FDE_CSSPRIMITIVETYPE_PC) {
fFontSize = ApplyNumber(eType, pPrimitive->GetFloat(), fFontSize);
} else if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
fFontSize = ToFontSize(pPrimitive->GetEnum(), fFontSize);
}
} break;
case FDE_CSSPROPERTY_LineHeight:
if (eType == FDE_CSSPRIMITIVETYPE_Number) {
FDE_CSSINHERITS.m_fLineHeight =
pPrimitive->GetFloat() * FDE_CSSFONTSIZE;
} else if (eType > FDE_CSSPRIMITIVETYPE_Number &&
eType <= FDE_CSSPRIMITIVETYPE_PC) {
FDE_CSSINHERITS.m_fLineHeight =
ApplyNumber(eType, pPrimitive->GetFloat(), FDE_CSSFONTSIZE);
}
break;
case FDE_CSSPROPERTY_TextAlign:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eTextAligh = ToTextAlign(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_TextIndent:
SetLengthWithPercent(FDE_CSSINHERITS.m_TextIndent, eType, pPrimitive,
FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_FontWeight:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_wFontWeight = ToFontWeight(pPrimitive->GetEnum());
} else if (eType == FDE_CSSPRIMITIVETYPE_Number) {
int32_t iValue = (int32_t)pPrimitive->GetFloat() / 100;
if (iValue >= 1 && iValue <= 9) {
FDE_CSSINHERITS.m_wFontWeight = iValue * 100;
}
}
break;
case FDE_CSSPROPERTY_FontStyle:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eFontStyle = ToFontStyle(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_Color:
if (eType == FDE_CSSPRIMITIVETYPE_RGB) {
FDE_CSSINHERITS.m_dwFontColor = pPrimitive->GetRGBColor();
}
break;
case FDE_CSSPROPERTY_MarginLeft:
FDE_CSSNONINHERITS.m_bHasMargin |=
SetLengthWithPercent(FDE_CSSNONINHERITS.m_MarginWidth.left, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_MarginTop:
FDE_CSSNONINHERITS.m_bHasMargin |=
SetLengthWithPercent(FDE_CSSNONINHERITS.m_MarginWidth.top, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_MarginRight:
FDE_CSSNONINHERITS.m_bHasMargin |=
SetLengthWithPercent(FDE_CSSNONINHERITS.m_MarginWidth.right, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_MarginBottom:
FDE_CSSNONINHERITS.m_bHasMargin |=
SetLengthWithPercent(FDE_CSSNONINHERITS.m_MarginWidth.bottom, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_PaddingLeft:
FDE_CSSNONINHERITS.m_bHasPadding |=
SetLengthWithPercent(FDE_CSSNONINHERITS.m_PaddingWidth.left, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_PaddingTop:
FDE_CSSNONINHERITS.m_bHasPadding |=
SetLengthWithPercent(FDE_CSSNONINHERITS.m_PaddingWidth.top, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_PaddingRight:
FDE_CSSNONINHERITS.m_bHasPadding |=
SetLengthWithPercent(FDE_CSSNONINHERITS.m_PaddingWidth.right, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_PaddingBottom:
FDE_CSSNONINHERITS.m_bHasPadding |=
SetLengthWithPercent(FDE_CSSNONINHERITS.m_PaddingWidth.bottom,
eType, pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_BorderLeftWidth:
FDE_CSSNONINHERITS.m_bHasBorder |=
SetLengthWithPercent(FDE_CSSNONINHERITS.m_BorderWidth.left, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_BorderTopWidth:
FDE_CSSNONINHERITS.m_bHasBorder |=
SetLengthWithPercent(FDE_CSSNONINHERITS.m_BorderWidth.top, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_BorderRightWidth:
FDE_CSSNONINHERITS.m_bHasBorder |=
SetLengthWithPercent(FDE_CSSNONINHERITS.m_BorderWidth.right, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_BorderBottomWidth:
FDE_CSSNONINHERITS.m_bHasBorder |=
SetLengthWithPercent(FDE_CSSNONINHERITS.m_BorderWidth.bottom, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_BorderLeftStyle:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eBDRLeftStyle =
ToBorderStyle(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_BorderTopStyle:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eBDRTopStyle =
ToBorderStyle(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_BorderRightStyle:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eBDRRightStyle =
ToBorderStyle(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_BorderBottomStyle:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eBDRBottomStyle =
ToBorderStyle(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_BorderLeftColor:
if (eType == FDE_CSSPRIMITIVETYPE_RGB) {
FDE_CSSNONINHERITS.m_dwBDRLeftColor = pPrimitive->GetRGBColor();
}
break;
case FDE_CSSPROPERTY_BorderTopColor:
if (eType == FDE_CSSPRIMITIVETYPE_RGB) {
FDE_CSSNONINHERITS.m_dwBDRTopColor = pPrimitive->GetRGBColor();
}
break;
case FDE_CSSPROPERTY_BorderRightColor:
if (eType == FDE_CSSPRIMITIVETYPE_RGB) {
FDE_CSSNONINHERITS.m_dwBDRRightColor = pPrimitive->GetRGBColor();
}
break;
case FDE_CSSPROPERTY_BorderBottomColor:
if (eType == FDE_CSSPRIMITIVETYPE_RGB) {
FDE_CSSNONINHERITS.m_dwBDRBottomColor = pPrimitive->GetRGBColor();
}
break;
case FDE_CSSPROPERTY_ListStyleType:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eListStyleType =
ToListStyleType(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_ListStylePosition:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eListStylePosition =
ToListStylePosition(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_BackgroundColor:
if (eType == FDE_CSSPRIMITIVETYPE_RGB) {
FDE_CSSNONINHERITS.m_dwBKGColor = pPrimitive->GetRGBColor();
} else if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_dwBKGColor = 0;
}
break;
case FDE_CSSPROPERTY_Visibility:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eVisibility = ToVisibility(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_Width:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_BoxSize.cx, eType, pPrimitive,
FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_Height:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_BoxSize.cy, eType, pPrimitive,
FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_MinWidth:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_MinBoxSize.cx, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_MinHeight:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_MinBoxSize.cy, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_MaxWidth:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_MaxBoxSize.cx, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_MaxHeight:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_MaxBoxSize.cy, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_VerticalAlign:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eVerticalAlign =
ToVerticalAlign(pPrimitive->GetEnum());
} else if (eType >= FDE_CSSPRIMITIVETYPE_Number &&
eType <= FDE_CSSPRIMITIVETYPE_PC) {
FDE_CSSNONINHERITS.m_eVerticalAlign = FDE_CSSVERTICALALIGN_Number;
FDE_CSSNONINHERITS.m_fVerticalAlign =
ApplyNumber(eType, pPrimitive->GetFloat(), FDE_CSSFONTSIZE);
}
break;
case FDE_CSSPROPERTY_WhiteSpace:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eWhiteSpace = ToWhiteSpace(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_TextTransform:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eTextTransform =
ToTextTransform(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_FontVariant:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eFontVariant = ToFontVariant(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_LetterSpacing:
if (eType == FDE_CSSPRIMITIVETYPE_Percent) {
break;
} else if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_LetterSpacing.Set(FDE_CSSLENGTHUNIT_Normal);
} else if (eType >= FDE_CSSPRIMITIVETYPE_Number &&
eType <= FDE_CSSPRIMITIVETYPE_PC) {
SetLengthWithPercent(FDE_CSSINHERITS.m_LetterSpacing, eType,
pPrimitive, FDE_CSSFONTSIZE);
}
break;
case FDE_CSSPROPERTY_WordSpacing:
if (eType == FDE_CSSPRIMITIVETYPE_Percent) {
break;
} else if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_WordSpacing.Set(FDE_CSSLENGTHUNIT_Normal);
} else if (eType >= FDE_CSSPRIMITIVETYPE_Number &&
eType <= FDE_CSSPRIMITIVETYPE_PC) {
SetLengthWithPercent(FDE_CSSINHERITS.m_WordSpacing, eType, pPrimitive,
FDE_CSSFONTSIZE);
}
break;
case FDE_CSSPROPERTY_Float:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eFloat = ToFloat(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_Clear:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eClear = ToClear(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_WritingMode:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eWritingMode = ToWritingMode(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_WordBreak:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eWordBreak = ToWordBreak(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_Widows:
if (eType == FDE_CSSPRIMITIVETYPE_Number) {
FDE_CSSINHERITS.m_iWidows = (int32_t)pPrimitive->GetFloat();
}
break;
case FDE_CSSPROPERTY_Orphans:
if (eType == FDE_CSSPRIMITIVETYPE_Number) {
FDE_CSSINHERITS.m_iOrphans = (int32_t)pPrimitive->GetFloat();
}
break;
case FDE_CSSPROPERTY_TextEmphasisColor:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
switch (pPrimitive->GetEnum()) {
case FDE_CSSPROPERTYVALUE_Transparent:
FDE_CSSINHERITS.m_dwTextEmphasisColor = 0;
FDE_CSSINHERITS.m_bTextEmphasisColorCurrent = FALSE;
break;
case FDE_CSSPROPERTYVALUE_Currentcolor:
FDE_CSSINHERITS.m_bTextEmphasisColorCurrent = TRUE;
break;
default:
break;
}
} else if (eType == FDE_CSSPRIMITIVETYPE_RGB) {
FDE_CSSINHERITS.m_dwTextEmphasisColor = pPrimitive->GetRGBColor();
FDE_CSSINHERITS.m_bTextEmphasisColorCurrent = FALSE;
}
break;
case FDE_CSSPROPERTY_PageBreakBefore:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_ePageBreakBefore =
ToPageBreak(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_PageBreakAfter:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_ePageBreakAfter =
ToPageBreak(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_PageBreakInside:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_ePageBreakInside =
ToPageBreak(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_OverflowX:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eOverflowX = ToOverflow(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_OverflowY:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eOverflowY = ToOverflow(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_LineBreak:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eLineBreak = ToLineBreak(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_ColumnCount:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_ColumnCount.Set(FDE_CSSLENGTHUNIT_Auto);
} else if (eType == FDE_CSSPRIMITIVETYPE_Number) {
FDE_CSSNONINHERITS.m_ColumnCount.Set(FDE_CSSLENGTHUNIT_Point,
pPrimitive->GetFloat());
}
break;
case FDE_CSSPROPERTY_ColumnGap:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_ColumnGap, eType, pPrimitive,
FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_ColumnRuleColor:
if (eType == FDE_CSSPRIMITIVETYPE_RGB) {
FDE_CSSNONINHERITS.m_dwColumnRuleColor = pPrimitive->GetRGBColor();
FDE_CSSNONINHERITS.m_bColumnRuleColorSame = FALSE;
}
break;
case FDE_CSSPROPERTY_ColumnRuleStyle:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eColumnRuleStyle =
ToBorderStyle(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_ColumnRuleWidth:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_ColumnRuleWidth, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_ColumnWidth:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_ColumnWidth, eType,
pPrimitive, FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_BackgroundImage:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_pszBKGImage = nullptr;
} else if (eType == FDE_CSSPRIMITIVETYPE_URI) {
int32_t iLength;
FDE_CSSNONINHERITS.m_pszBKGImage = pPrimitive->GetString(iLength);
}
break;
case FDE_CSSPROPERTY_Position:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_ePosition = ToPosition(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_Top:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_Top, eType, pPrimitive,
FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_Bottom:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_Bottom, eType, pPrimitive,
FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_Left:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_Left, eType, pPrimitive,
FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_Right:
SetLengthWithPercent(FDE_CSSNONINHERITS.m_Right, eType, pPrimitive,
FDE_CSSFONTSIZE);
break;
case FDE_CSSPROPERTY_ListStyleImage:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_pszListStyleImage = nullptr;
} else if (eType == FDE_CSSPRIMITIVETYPE_URI) {
int32_t iLength;
FDE_CSSINHERITS.m_pszListStyleImage = pPrimitive->GetString(iLength);
}
break;
case FDE_CSSPROPERTY_CaptionSide:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eCaptionSide = ToCaptionSide(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_BackgroundRepeat:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eBKGRepeat = ToBKGRepeat(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_BackgroundAttachment:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSNONINHERITS.m_eBKGAttachment =
ToBKGAttachment(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_RubyAlign:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eRubyAlign = ToRubyAlign(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_RubyOverhang:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eRubyOverhang =
ToRubyOverhang(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_RubyPosition:
if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
FDE_CSSINHERITS.m_eRubyPosition =
ToRubyPosition(pPrimitive->GetEnum());
}
break;
case FDE_CSSPROPERTY_RubySpan:
FDE_CSSNONINHERITS.m_pRubySpan = pPrimitive;
break;
default:
break;
}
} else if (pValue->GetType() == FDE_CSSVALUETYPE_List) {
IFDE_CSSValueList* pList = static_cast<IFDE_CSSValueList*>(pValue);
int32_t iCount = pList->CountValues();
if (iCount > 0) {
switch (eProperty) {
case FDE_CSSPROPERTY_FontFamily:
FDE_CSSINHERITS.m_pFontFamily = pList;
break;
case FDE_CSSPROPERTY_TextDecoration:
FDE_CSSNONINHERITS.m_dwTextDecoration = ToTextDecoration(pList);
break;
case FDE_CSSPROPERTY_CounterIncrement: {
if (!FDE_CSSNONINHERITS.m_pCounterStyle)
FDE_CSSNONINHERITS.m_pCounterStyle = new CFDE_CSSCounterStyle;
FDE_CSSNONINHERITS.m_pCounterStyle->SetCounterIncrementList(pList);
} break;
case FDE_CSSPROPERTY_CounterReset: {
if (!FDE_CSSNONINHERITS.m_pCounterStyle)
FDE_CSSNONINHERITS.m_pCounterStyle = new CFDE_CSSCounterStyle;
FDE_CSSNONINHERITS.m_pCounterStyle->SetCounterResetList(pList);
} break;
case FDE_CSSPROPERTY_Content:
FDE_CSSNONINHERITS.m_pContentList = pList;
break;
case FDE_CSSPROPERTY_Quotes:
FDE_CSSINHERITS.m_pQuotes = pList;
break;
case FDE_CSSPROPERTY_TextCombine: {
for (int32_t i = 0; i < pList->CountValues(); i++) {
IFDE_CSSPrimitiveValue* pVal =
static_cast<IFDE_CSSPrimitiveValue*>(pList->GetValue(i));
switch (pVal->GetPrimitiveType()) {
case FDE_CSSPRIMITIVETYPE_Enum: {
switch (pVal->GetEnum()) {
case FDE_CSSPROPERTYVALUE_None: {
FDE_CSSNONINHERITS.m_eTextCombine = FDE_CSSTEXTCOMBINE_None;
FDE_CSSNONINHERITS.m_bHasTextCombineNumber = FALSE;
} break;
case FDE_CSSPROPERTYVALUE_Horizontal: {
FDE_CSSNONINHERITS.m_eTextCombine =
FDE_CSSTEXTCOMBINE_Horizontal;
FDE_CSSNONINHERITS.m_bHasTextCombineNumber = FALSE;
} break;
default:
break;
}
} break;
case FDE_CSSPRIMITIVETYPE_Number:
FDE_CSSNONINHERITS.m_fTextCombineNumber = pVal->GetFloat();
break;
default:
break;
}
}
} break;
case FDE_CSSPROPERTY_TextEmphasisStyle: {
FDE_CSSTEXTEMPHASISFILL eFill;
FDE_CSSTEXTEMPHASISMARK eMark;
for (int32_t i = 0; i < pList->CountValues(); i++) {
IFDE_CSSPrimitiveValue* pVal =
static_cast<IFDE_CSSPrimitiveValue*>(pList->GetValue(i));
switch (pVal->GetPrimitiveType()) {
case FDE_CSSPRIMITIVETYPE_Enum: {
if (ToTextEmphasisFill(pVal->GetEnum(), eFill)) {
FDE_CSSINHERITS.m_eTextEmphasisFill = eFill;
continue;
} else if (ToTextEmphasisMark(pVal->GetEnum(), eMark)) {
FDE_CSSINHERITS.m_eTextEmphasisMark = eMark;
}
} break;
case FDE_CSSPRIMITIVETYPE_String: {
FDE_CSSINHERITS.m_eTextEmphasisMark =
FDE_CSSTEXTEMPHASISMARK_Custom;
int32_t iLen;
FDE_CSSINHERITS.m_pszTextEmphasisCustomMark =
pVal->GetString(iLen);
} break;
default:
break;
}
}
} break;
default:
break;
}
}
} else {
ASSERT(FALSE);
}
}
FX_FLOAT CFDE_CSSStyleSelector::ApplyNumber(FDE_CSSPRIMITIVETYPE eUnit,
FX_FLOAT fValue,
FX_FLOAT fPercentBase) {
switch (eUnit) {
case FDE_CSSPRIMITIVETYPE_PX:
case FDE_CSSPRIMITIVETYPE_Number:
return fValue * 72 / 96;
case FDE_CSSPRIMITIVETYPE_PT:
return fValue;
case FDE_CSSPRIMITIVETYPE_EMS:
case FDE_CSSPRIMITIVETYPE_EXS:
return fValue * fPercentBase;
case FDE_CSSPRIMITIVETYPE_Percent:
return fValue * fPercentBase / 100.0f;
case FDE_CSSPRIMITIVETYPE_CM:
return fValue * 28.3464f;
case FDE_CSSPRIMITIVETYPE_MM:
return fValue * 2.8346f;
case FDE_CSSPRIMITIVETYPE_IN:
return fValue * 72.0f;
case FDE_CSSPRIMITIVETYPE_PC:
return fValue / 12.0f;
default:
return fValue;
}
}
FDE_CSSRUBYSPAN CFDE_CSSStyleSelector::ToRubySpan(FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_None:
default:
return FDE_CSSRUBYSPAN_None;
}
}
FDE_CSSRUBYPOSITION CFDE_CSSStyleSelector::ToRubyPosition(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Before:
return FDE_CSSRUBYPOSITION_Before;
case FDE_CSSPROPERTYVALUE_After:
return FDE_CSSRUBYPOSITION_After;
case FDE_CSSPROPERTYVALUE_Right:
return FDE_CSSRUBYPOSITION_Right;
case FDE_CSSPROPERTYVALUE_Inline:
return FDE_CSSRUBYPOSITION_Inline;
default:
return FDE_CSSRUBYPOSITION_Before;
}
}
FDE_CSSRUBYOVERHANG CFDE_CSSStyleSelector::ToRubyOverhang(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Auto:
return FDE_CSSRUBYOVERHANG_Auto;
case FDE_CSSPROPERTYVALUE_Start:
return FDE_CSSRUBYOVERHANG_Start;
case FDE_CSSPROPERTYVALUE_End:
return FDE_CSSRUBYOVERHANG_End;
case FDE_CSSPROPERTYVALUE_None:
default:
return FDE_CSSRUBYOVERHANG_None;
}
}
FDE_CSSRUBYALIGN CFDE_CSSStyleSelector::ToRubyAlign(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Auto:
return FDE_CSSRUBYALIGN_Auto;
case FDE_CSSPROPERTYVALUE_Start:
return FDE_CSSRUBYALIGN_Start;
case FDE_CSSPROPERTYVALUE_Left:
return FDE_CSSRUBYALIGN_End;
case FDE_CSSPROPERTYVALUE_Center:
return FDE_CSSRUBYALIGN_Center;
case FDE_CSSPROPERTYVALUE_End:
return FDE_CSSRUBYALIGN_End;
case FDE_CSSPROPERTYVALUE_Right:
return FDE_CSSRUBYALIGN_Right;
case FDE_CSSPROPERTYVALUE_DistributeLetter:
return FDE_CSSRUBYALIGN_DistributeLetter;
case FDE_CSSPROPERTYVALUE_DistributeSpace:
return FDE_CSSRUBYALIGN_DistributeSpace;
case FDE_CSSPROPERTYVALUE_LineEdge:
return FDE_CSSRUBYALIGN_LineEdge;
default:
return FDE_CSSRUBYALIGN_Auto;
}
}
FX_BOOL CFDE_CSSStyleSelector::ToTextEmphasisMark(
FDE_CSSPROPERTYVALUE eValue,
FDE_CSSTEXTEMPHASISMARK& eMark) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_None:
eMark = FDE_CSSTEXTEMPHASISMARK_None;
return TRUE;
case FDE_CSSPROPERTYVALUE_Dot:
eMark = FDE_CSSTEXTEMPHASISMARK_Dot;
return TRUE;
case FDE_CSSPROPERTYVALUE_Circle:
eMark = FDE_CSSTEXTEMPHASISMARK_Circle;
return TRUE;
case FDE_CSSPROPERTYVALUE_DoubleCircle:
eMark = FDE_CSSTEXTEMPHASISMARK_DoubleCircle;
return TRUE;
case FDE_CSSPROPERTYVALUE_Triangle:
eMark = FDE_CSSTEXTEMPHASISMARK_Triangle;
return TRUE;
case FDE_CSSPROPERTYVALUE_Sesame:
eMark = FDE_CSSTEXTEMPHASISMARK_Sesame;
return TRUE;
default:
return FALSE;
}
}
FX_BOOL CFDE_CSSStyleSelector::ToTextEmphasisFill(
FDE_CSSPROPERTYVALUE eValue,
FDE_CSSTEXTEMPHASISFILL& eFill) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Filled:
eFill = FDE_CSSTEXTEMPHASISFILL_Filled;
return TRUE;
case FDE_CSSPROPERTYVALUE_Open:
eFill = FDE_CSSTEXTEMPHASISFILL_Open;
return TRUE;
default:
return FALSE;
}
}
FDE_CSSBKGATTACHMENT CFDE_CSSStyleSelector::ToBKGAttachment(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Fixed:
return FDE_CSSBKGATTACHMENT_Fixed;
case FDE_CSSPROPERTYVALUE_Scroll:
return FDE_CSSBKGATTACHMENT_Scroll;
default:
return FDE_CSSBKGATTACHMENT_Fixed;
}
}
FDE_CSSCAPTIONSIDE CFDE_CSSStyleSelector::ToCaptionSide(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Top:
return FDE_CSSCAPTIONSIDE_Top;
case FDE_CSSPROPERTYVALUE_Bottom:
return FDE_CSSCAPTIONSIDE_Bottom;
case FDE_CSSPROPERTYVALUE_Left:
return FDE_CSSCAPTIONSIDE_Left;
case FDE_CSSPROPERTYVALUE_Right:
return FDE_CSSCAPTIONSIDE_Right;
case FDE_CSSPROPERTYVALUE_Before:
return FDE_CSSCAPTIONSIDE_Before;
case FDE_CSSPROPERTYVALUE_After:
return FDE_CSSCAPTIONSIDE_After;
default:
return FDE_CSSCAPTIONSIDE_Top;
}
}
FDE_CSSPOSITION CFDE_CSSStyleSelector::ToPosition(FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Static:
return FDE_CSSPOSITION_Static;
case FDE_CSSPROPERTYVALUE_Relative:
return FDE_CSSPOSITION_Relative;
case FDE_CSSPROPERTYVALUE_Fixed:
return FDE_CSSPOSITION_Fixed;
case FDE_CSSPROPERTYVALUE_Absolute:
return FDE_CSSPOSITION_Absolute;
default:
return FDE_CSSPOSITION_Static;
}
}
FDE_CSSCURSOR CFDE_CSSStyleSelector::ToCursor(FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Auto:
return FDE_CSSCURSOR_Auto;
case FDE_CSSPROPERTYVALUE_Crosshair:
return FDE_CSSCURSOR_Crosshair;
case FDE_CSSPROPERTYVALUE_Default:
return FDE_CSSCURSOR_Default;
case FDE_CSSPROPERTYVALUE_Pointer:
return FDE_CSSCURSOR_Pointer;
case FDE_CSSPROPERTYVALUE_Move:
return FDE_CSSCURSOR_Move;
case FDE_CSSPROPERTYVALUE_EResize:
return FDE_CSSCURSOR_EResize;
case FDE_CSSPROPERTYVALUE_NeResize:
return FDE_CSSCURSOR_NeResize;
case FDE_CSSPROPERTYVALUE_NwResize:
return FDE_CSSCURSOR_NwResize;
case FDE_CSSPROPERTYVALUE_NResize:
return FDE_CSSCURSOR_NResize;
case FDE_CSSPROPERTYVALUE_SeResize:
return FDE_CSSCURSOR_SeResize;
case FDE_CSSPROPERTYVALUE_SwResize:
return FDE_CSSCURSOR_SwResize;
default:
return FDE_CSSCURSOR_Auto;
}
}
FDE_CSSBKGREPEAT CFDE_CSSStyleSelector::ToBKGRepeat(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Repeat:
return FDE_CSSBKGREPEAT_Repeat;
case FDE_CSSPROPERTYVALUE_RepeatX:
return FDE_CSSBKGREPEAT_RepeatX;
case FDE_CSSPROPERTYVALUE_RepeatY:
return FDE_CSSBKGREPEAT_RepeatY;
case FDE_CSSPROPERTYVALUE_NoRepeat:
return FDE_CSSBKGREPEAT_NoRepeat;
default:
return FDE_CSSBKGREPEAT_Repeat;
}
}
FDE_CSSTEXTCOMBINE CFDE_CSSStyleSelector::ToTextCombine(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Horizontal:
return FDE_CSSTEXTCOMBINE_Horizontal;
case FDE_CSSPROPERTYVALUE_None:
default:
return FDE_CSSTEXTCOMBINE_None;
}
}
FDE_CSSLINEBREAK CFDE_CSSStyleSelector::ToLineBreak(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Auto:
return FDE_CSSLINEBREAK_Auto;
case FDE_CSSPROPERTYVALUE_Loose:
return FDE_CSSLINEBREAK_Loose;
case FDE_CSSPROPERTYVALUE_Normal:
return FDE_CSSLINEBREAK_Normal;
case FDE_CSSPROPERTYVALUE_Strict:
return FDE_CSSLINEBREAK_Strict;
default:
return FDE_CSSLINEBREAK_Auto;
}
}
FDE_CSSOVERFLOW CFDE_CSSStyleSelector::ToOverflow(FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Visible:
return FDE_CSSOVERFLOW_Visible;
case FDE_CSSPROPERTYVALUE_Hidden:
return FDE_CSSOVERFLOW_Hidden;
case FDE_CSSPROPERTYVALUE_Scroll:
return FDE_CSSOVERFLOW_Scroll;
case FDE_CSSPROPERTYVALUE_Auto:
return FDE_CSSOVERFLOW_Auto;
case FDE_CSSPROPERTYVALUE_NoDisplay:
return FDE_CSSOVERFLOW_NoDisplay;
case FDE_CSSPROPERTYVALUE_NoContent:
return FDE_CSSOVERFLOW_NoContent;
default:
return FDE_CSSOVERFLOW_Visible;
}
}
FDE_CSSWRITINGMODE CFDE_CSSStyleSelector::ToWritingMode(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_HorizontalTb:
return FDE_CSSWRITINGMODE_HorizontalTb;
case FDE_CSSPROPERTYVALUE_VerticalRl:
return FDE_CSSWRITINGMODE_VerticalRl;
case FDE_CSSPROPERTYVALUE_VerticalLr:
return FDE_CSSWRITINGMODE_VerticalLr;
default:
return FDE_CSSWRITINGMODE_HorizontalTb;
}
}
FDE_CSSWORDBREAK CFDE_CSSStyleSelector::ToWordBreak(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Normal:
return FDE_CSSWORDBREAK_Normal;
case FDE_CSSPROPERTYVALUE_KeepAll:
return FDE_CSSWORDBREAK_KeepAll;
case FDE_CSSPROPERTYVALUE_BreakAll:
return FDE_CSSWORDBREAK_BreakAll;
case FDE_CSSPROPERTYVALUE_KeepWords:
return FDE_CSSWORDBREAK_KeepWords;
default:
return FDE_CSSWORDBREAK_Normal;
}
}
FDE_CSSFLOAT CFDE_CSSStyleSelector::ToFloat(FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Left:
return FDE_CSSFLOAT_Left;
case FDE_CSSPROPERTYVALUE_Right:
return FDE_CSSFLOAT_Right;
case FDE_CSSPROPERTYVALUE_None:
return FDE_CSSFLOAT_None;
default:
return FDE_CSSFLOAT_None;
}
}
FDE_CSSCLEAR CFDE_CSSStyleSelector::ToClear(FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_None:
return FDE_CSSCLEAR_None;
case FDE_CSSPROPERTYVALUE_Left:
return FDE_CSSCLEAR_Left;
case FDE_CSSPROPERTYVALUE_Right:
return FDE_CSSCLEAR_Right;
case FDE_CSSPROPERTYVALUE_Both:
return FDE_CSSCLEAR_Both;
default:
return FDE_CSSCLEAR_None;
}
}
FDE_CSSPAGEBREAK CFDE_CSSStyleSelector::ToPageBreak(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Avoid:
return FDE_CSSPAGEBREAK_Avoid;
case FDE_CSSPROPERTYVALUE_Auto:
return FDE_CSSPAGEBREAK_Auto;
case FDE_CSSPROPERTYVALUE_Always:
return FDE_CSSPAGEBREAK_Always;
case FDE_CSSPROPERTYVALUE_Left:
return FDE_CSSPAGEBREAK_Left;
case FDE_CSSPROPERTYVALUE_Right:
return FDE_CSSPAGEBREAK_Right;
default:
return FDE_CSSPAGEBREAK_Auto;
}
}
FDE_CSSDISPLAY CFDE_CSSStyleSelector::ToDisplay(FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Inline:
return FDE_CSSDISPLAY_Inline;
case FDE_CSSPROPERTYVALUE_Block:
return FDE_CSSDISPLAY_Block;
case FDE_CSSPROPERTYVALUE_None:
return FDE_CSSDISPLAY_None;
case FDE_CSSPROPERTYVALUE_ListItem:
return FDE_CSSDISPLAY_ListItem;
case FDE_CSSPROPERTYVALUE_TableCell:
return FDE_CSSDISPLAY_TableCell;
case FDE_CSSPROPERTYVALUE_TableRow:
return FDE_CSSDISPLAY_TableRow;
case FDE_CSSPROPERTYVALUE_Table:
return FDE_CSSDISPLAY_Table;
case FDE_CSSPROPERTYVALUE_TableCaption:
return FDE_CSSDISPLAY_TableCaption;
case FDE_CSSPROPERTYVALUE_TableRowGroup:
return FDE_CSSDISPLAY_TableRowGroup;
case FDE_CSSPROPERTYVALUE_TableHeaderGroup:
return FDE_CSSDISPLAY_TableHeaderGroup;
case FDE_CSSPROPERTYVALUE_TableFooterGroup:
return FDE_CSSDISPLAY_TableFooterGroup;
case FDE_CSSPROPERTYVALUE_TableColumnGroup:
return FDE_CSSDISPLAY_TableColumnGroup;
case FDE_CSSPROPERTYVALUE_TableColumn:
return FDE_CSSDISPLAY_TableColumn;
case FDE_CSSPROPERTYVALUE_InlineTable:
return FDE_CSSDISPLAY_InlineTable;
case FDE_CSSPROPERTYVALUE_InlineBlock:
return FDE_CSSDISPLAY_InlineBlock;
case FDE_CSSPROPERTYVALUE_RunIn:
return FDE_CSSDISPLAY_RunIn;
case FDE_CSSPROPERTYVALUE_Ruby:
return FDE_CSSDISPLAY_Ruby;
case FDE_CSSPROPERTYVALUE_RubyBase:
return FDE_CSSDISPLAY_RubyBase;
case FDE_CSSPROPERTYVALUE_RubyText:
return FDE_CSSDISPLAY_RubyText;
case FDE_CSSPROPERTYVALUE_RubyBaseGroup:
return FDE_CSSDISPLSY_RubyBaseGroup;
case FDE_CSSPROPERTYVALUE_RubyTextGroup:
return FDE_CSSDISPLAY_RubyTextGroup;
default:
return FDE_CSSDISPLAY_Inline;
}
}
FDE_CSSTEXTALIGN CFDE_CSSStyleSelector::ToTextAlign(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Left:
return FDE_CSSTEXTALIGN_Left;
case FDE_CSSPROPERTYVALUE_Center:
return FDE_CSSTEXTALIGN_Center;
case FDE_CSSPROPERTYVALUE_Right:
return FDE_CSSTEXTALIGN_Right;
case FDE_CSSPROPERTYVALUE_Justify:
return FDE_CSSTEXTALIGN_Justify;
default:
return FDE_CSSTEXTALIGN_Left;
}
}
uint16_t CFDE_CSSStyleSelector::ToFontWeight(FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Normal:
return 400;
case FDE_CSSPROPERTYVALUE_Bold:
return 700;
case FDE_CSSPROPERTYVALUE_Bolder:
return 900;
case FDE_CSSPROPERTYVALUE_Lighter:
return 200;
default:
return 400;
}
}
FDE_CSSFONTSTYLE CFDE_CSSStyleSelector::ToFontStyle(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Italic:
case FDE_CSSPROPERTYVALUE_Oblique:
return FDE_CSSFONTSTYLE_Italic;
default:
return FDE_CSSFONTSTYLE_Normal;
}
}
FDE_CSSBORDERSTYLE CFDE_CSSStyleSelector::ToBorderStyle(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_None:
return FDE_CSSBORDERSTYLE_None;
case FDE_CSSPROPERTYVALUE_Solid:
return FDE_CSSBORDERSTYLE_Solid;
case FDE_CSSPROPERTYVALUE_Hidden:
return FDE_CSSBORDERSTYLE_Hidden;
case FDE_CSSPROPERTYVALUE_Dotted:
return FDE_CSSBORDERSTYLE_Dotted;
case FDE_CSSPROPERTYVALUE_Dashed:
return FDE_CSSBORDERSTYLE_Dashed;
case FDE_CSSPROPERTYVALUE_Double:
return FDE_CSSBORDERSTYLE_Double;
case FDE_CSSPROPERTYVALUE_Groove:
return FDE_CSSBORDERSTYLE_Groove;
case FDE_CSSPROPERTYVALUE_Ridge:
return FDE_CSSBORDERSTYLE_Ridge;
case FDE_CSSPROPERTYVALUE_Inset:
return FDE_CSSBORDERSTYLE_Inset;
case FDE_CSSPROPERTYVALUE_Outset:
return FDE_CSSBORDERSTYLE_outset;
default:
return FDE_CSSBORDERSTYLE_None;
}
}
FX_BOOL CFDE_CSSStyleSelector::SetLengthWithPercent(
FDE_CSSLENGTH& width,
FDE_CSSPRIMITIVETYPE eType,
IFDE_CSSPrimitiveValue* pPrimitive,
FX_FLOAT fFontSize) {
if (eType == FDE_CSSPRIMITIVETYPE_Percent) {
width.Set(FDE_CSSLENGTHUNIT_Percent, pPrimitive->GetFloat() / 100.0f);
return width.NonZero();
} else if (eType >= FDE_CSSPRIMITIVETYPE_Number &&
eType <= FDE_CSSPRIMITIVETYPE_PC) {
FX_FLOAT fValue = ApplyNumber(eType, pPrimitive->GetFloat(), fFontSize);
width.Set(FDE_CSSLENGTHUNIT_Point, fValue);
return width.NonZero();
} else if (eType == FDE_CSSPRIMITIVETYPE_Enum) {
switch (pPrimitive->GetEnum()) {
case FDE_CSSPROPERTYVALUE_Auto:
width.Set(FDE_CSSLENGTHUNIT_Auto);
return TRUE;
case FDE_CSSPROPERTYVALUE_None:
width.Set(FDE_CSSLENGTHUNIT_None);
return TRUE;
case FDE_CSSPROPERTYVALUE_Thin:
width.Set(FDE_CSSLENGTHUNIT_Point, 2);
return TRUE;
case FDE_CSSPROPERTYVALUE_Medium:
width.Set(FDE_CSSLENGTHUNIT_Point, 3);
return TRUE;
case FDE_CSSPROPERTYVALUE_Thick:
width.Set(FDE_CSSLENGTHUNIT_Point, 4);
return TRUE;
default:
return FALSE;
}
}
return FALSE;
}
FX_FLOAT CFDE_CSSStyleSelector::ToFontSize(FDE_CSSPROPERTYVALUE eValue,
FX_FLOAT fCurFontSize) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_XxSmall:
return m_fDefFontSize / 1.2f / 1.2f / 1.2f;
case FDE_CSSPROPERTYVALUE_XSmall:
return m_fDefFontSize / 1.2f / 1.2f;
case FDE_CSSPROPERTYVALUE_Small:
return m_fDefFontSize / 1.2f;
case FDE_CSSPROPERTYVALUE_Medium:
return m_fDefFontSize;
case FDE_CSSPROPERTYVALUE_Large:
return m_fDefFontSize * 1.2f;
case FDE_CSSPROPERTYVALUE_XLarge:
return m_fDefFontSize * 1.2f * 1.2f;
case FDE_CSSPROPERTYVALUE_XxLarge:
return m_fDefFontSize * 1.2f * 1.2f * 1.2f;
case FDE_CSSPROPERTYVALUE_Larger:
return fCurFontSize * 1.2f;
case FDE_CSSPROPERTYVALUE_Smaller:
return fCurFontSize / 1.2f;
default:
return fCurFontSize;
}
}
FDE_CSSVERTICALALIGN CFDE_CSSStyleSelector::ToVerticalAlign(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Baseline:
return FDE_CSSVERTICALALIGN_Baseline;
case FDE_CSSPROPERTYVALUE_Middle:
return FDE_CSSVERTICALALIGN_Middle;
case FDE_CSSPROPERTYVALUE_Bottom:
return FDE_CSSVERTICALALIGN_Bottom;
case FDE_CSSPROPERTYVALUE_Super:
return FDE_CSSVERTICALALIGN_Super;
case FDE_CSSPROPERTYVALUE_Sub:
return FDE_CSSVERTICALALIGN_Sub;
case FDE_CSSPROPERTYVALUE_Top:
return FDE_CSSVERTICALALIGN_Top;
case FDE_CSSPROPERTYVALUE_TextTop:
return FDE_CSSVERTICALALIGN_TextTop;
case FDE_CSSPROPERTYVALUE_TextBottom:
return FDE_CSSVERTICALALIGN_TextBottom;
default:
return FDE_CSSVERTICALALIGN_Baseline;
}
}
FDE_CSSLISTSTYLETYPE CFDE_CSSStyleSelector::ToListStyleType(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_None:
return FDE_CSSLISTSTYLETYPE_None;
case FDE_CSSPROPERTYVALUE_Disc:
return FDE_CSSLISTSTYLETYPE_Disc;
case FDE_CSSPROPERTYVALUE_Circle:
return FDE_CSSLISTSTYLETYPE_Circle;
case FDE_CSSPROPERTYVALUE_Square:
return FDE_CSSLISTSTYLETYPE_Square;
case FDE_CSSPROPERTYVALUE_Decimal:
return FDE_CSSLISTSTYLETYPE_Decimal;
case FDE_CSSPROPERTYVALUE_DecimalLeadingZero:
return FDE_CSSLISTSTYLETYPE_DecimalLeadingZero;
case FDE_CSSPROPERTYVALUE_LowerRoman:
return FDE_CSSLISTSTYLETYPE_LowerRoman;
case FDE_CSSPROPERTYVALUE_UpperRoman:
return FDE_CSSLISTSTYLETYPE_UpperRoman;
case FDE_CSSPROPERTYVALUE_LowerGreek:
return FDE_CSSLISTSTYLETYPE_LowerGreek;
case FDE_CSSPROPERTYVALUE_LowerLatin:
return FDE_CSSLISTSTYLETYPE_LowerLatin;
case FDE_CSSPROPERTYVALUE_UpperLatin:
return FDE_CSSLISTSTYLETYPE_UpperLatin;
case FDE_CSSPROPERTYVALUE_Armenian:
return FDE_CSSLISTSTYLETYPE_Armenian;
case FDE_CSSPROPERTYVALUE_Georgian:
return FDE_CSSLISTSTYLETYPE_Georgian;
case FDE_CSSPROPERTYVALUE_LowerAlpha:
return FDE_CSSLISTSTYLETYPE_LowerAlpha;
case FDE_CSSPROPERTYVALUE_UpperAlpha:
return FDE_CSSLISTSTYLETYPE_UpperAlpha;
case FDE_CSSPROPERTYVALUE_CjkIdeographic:
return FDE_CSSLISTSTYLETYPE_CjkIdeographic;
case FDE_CSSPROPERTYVALUE_Hebrew:
return FDE_CSSLISTSTYLETYPE_Hebrew;
case FDE_CSSLISTSTYLETYPE_Hiragana:
return FDE_CSSLISTSTYLETYPE_Hiragana;
case FDE_CSSLISTSTYLETYPE_HiraganaIroha:
return FDE_CSSLISTSTYLETYPE_HiraganaIroha;
case FDE_CSSLISTSTYLETYPE_Katakana:
return FDE_CSSLISTSTYLETYPE_Katakana;
case FDE_CSSLISTSTYLETYPE_KatakanaIroha:
return FDE_CSSLISTSTYLETYPE_KatakanaIroha;
default:
return FDE_CSSLISTSTYLETYPE_Disc;
}
}
FDE_CSSLISTSTYLEPOSITION CFDE_CSSStyleSelector::ToListStylePosition(
FDE_CSSPROPERTYVALUE eValue) {
return eValue == FDE_CSSPROPERTYVALUE_Inside
? FDE_CSSLISTSTYLEPOSITION_Inside
: FDE_CSSLISTSTYLEPOSITION_Outside;
}
FDE_CSSVISIBILITY CFDE_CSSStyleSelector::ToVisibility(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Visible:
return FDE_CSSVISIBILITY_Visible;
case FDE_CSSPROPERTYVALUE_Hidden:
return FDE_CSSVISIBILITY_Hidden;
case FDE_CSSPROPERTYVALUE_Collapse:
return FDE_CSSVISIBILITY_Collapse;
default:
return FDE_CSSVISIBILITY_Visible;
}
}
FDE_CSSWHITESPACE CFDE_CSSStyleSelector::ToWhiteSpace(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_Normal:
return FDE_CSSWHITESPACE_Normal;
case FDE_CSSPROPERTYVALUE_Pre:
return FDE_CSSWHITESPACE_Pre;
case FDE_CSSPROPERTYVALUE_Nowrap:
return FDE_CSSWHITESPACE_Nowrap;
case FDE_CSSPROPERTYVALUE_PreWrap:
return FDE_CSSWHITESPACE_PreWrap;
case FDE_CSSPROPERTYVALUE_PreLine:
return FDE_CSSWHITESPACE_PreLine;
default:
return FDE_CSSWHITESPACE_Normal;
}
}
uint32_t CFDE_CSSStyleSelector::ToTextDecoration(IFDE_CSSValueList* pValue) {
uint32_t dwDecoration = 0;
for (int32_t i = pValue->CountValues() - 1; i >= 0; --i) {
IFDE_CSSPrimitiveValue* pPrimitive =
static_cast<IFDE_CSSPrimitiveValue*>(pValue->GetValue(i));
if (pPrimitive->GetPrimitiveType() == FDE_CSSPRIMITIVETYPE_Enum) {
switch (pPrimitive->GetEnum()) {
case FDE_CSSPROPERTYVALUE_Underline:
dwDecoration |= FDE_CSSTEXTDECORATION_Underline;
break;
case FDE_CSSPROPERTYVALUE_LineThrough:
dwDecoration |= FDE_CSSTEXTDECORATION_LineThrough;
break;
case FDE_CSSPROPERTYVALUE_Overline:
dwDecoration |= FDE_CSSTEXTDECORATION_Overline;
break;
case FDE_CSSPROPERTYVALUE_Blink:
dwDecoration |= FDE_CSSTEXTDECORATION_Blink;
break;
case FDE_CSSPROPERTYVALUE_Double:
dwDecoration |= FDE_CSSTEXTDECORATION_Double;
break;
default:
break;
}
}
}
return dwDecoration;
}
FDE_CSSTEXTTRANSFORM CFDE_CSSStyleSelector::ToTextTransform(
FDE_CSSPROPERTYVALUE eValue) {
switch (eValue) {
case FDE_CSSPROPERTYVALUE_None:
return FDE_CSSTEXTTRANSFORM_None;
case FDE_CSSPROPERTYVALUE_Capitalize:
return FDE_CSSTEXTTRANSFORM_Capitalize;
case FDE_CSSPROPERTYVALUE_Uppercase:
return FDE_CSSTEXTTRANSFORM_UpperCase;
case FDE_CSSPROPERTYVALUE_Lowercase:
return FDE_CSSTEXTTRANSFORM_LowerCase;
default:
return FDE_CSSTEXTTRANSFORM_None;
}
}
FDE_CSSFONTVARIANT CFDE_CSSStyleSelector::ToFontVariant(
FDE_CSSPROPERTYVALUE eValue) {
return eValue == FDE_CSSPROPERTYVALUE_SmallCaps ? FDE_CSSFONTVARIANT_SmallCaps
: FDE_CSSFONTVARIANT_Normal;
}
CFDE_CSSComputedStyle::CFDE_CSSComputedStyle(IFX_MemoryAllocator* pAlloc)
: m_dwRefCount(1), m_pAllocator(pAlloc) {}
CFDE_CSSComputedStyle::~CFDE_CSSComputedStyle() {}
uint32_t CFDE_CSSComputedStyle::Retain() {
return ++m_dwRefCount;
}
uint32_t CFDE_CSSComputedStyle::Release() {
uint32_t dwRefCount = --m_dwRefCount;
if (dwRefCount == 0) {
delete m_NonInheritedData.m_pCounterStyle;
FXTARGET_DeleteWith(CFDE_CSSComputedStyle, m_pAllocator, this);
}
return dwRefCount;
}
void CFDE_CSSComputedStyle::Reset() {
m_InheritedData.Reset();
m_NonInheritedData.Reset();
}
IFDE_CSSFontStyle* CFDE_CSSComputedStyle::GetFontStyles() {
return static_cast<IFDE_CSSFontStyle*>(this);
}
IFDE_CSSBoundaryStyle* CFDE_CSSComputedStyle::GetBoundaryStyles() {
return static_cast<IFDE_CSSBoundaryStyle*>(this);
}
IFDE_CSSPositionStyle* CFDE_CSSComputedStyle::GetPositionStyles() {
return static_cast<IFDE_CSSPositionStyle*>(this);
}
IFDE_CSSParagraphStyle* CFDE_CSSComputedStyle::GetParagraphStyles() {
return static_cast<IFDE_CSSParagraphStyle*>(this);
}
FX_BOOL CFDE_CSSComputedStyle::GetCustomStyle(const CFX_WideStringC& wsName,
CFX_WideString& wsValue) const {
for (int32_t i = m_CustomProperties.GetSize() - 2; i > -1; i -= 2) {
if (wsName == m_CustomProperties[i]) {
wsValue = m_CustomProperties[i + 1];
return TRUE;
}
}
return FALSE;
}
int32_t CFDE_CSSComputedStyle::CountFontFamilies() const {
return m_InheritedData.m_pFontFamily
? m_InheritedData.m_pFontFamily->CountValues()
: 0;
}
const FX_WCHAR* CFDE_CSSComputedStyle::GetFontFamily(int32_t index) const {
return (static_cast<IFDE_CSSPrimitiveValue*>(
m_InheritedData.m_pFontFamily->GetValue(index)))
->GetString(index);
}
uint16_t CFDE_CSSComputedStyle::GetFontWeight() const {
return m_InheritedData.m_wFontWeight;
}
FDE_CSSFONTVARIANT CFDE_CSSComputedStyle::GetFontVariant() const {
return static_cast<FDE_CSSFONTVARIANT>(m_InheritedData.m_eFontVariant);
}
FDE_CSSFONTSTYLE CFDE_CSSComputedStyle::GetFontStyle() const {
return static_cast<FDE_CSSFONTSTYLE>(m_InheritedData.m_eFontStyle);
}
FX_FLOAT CFDE_CSSComputedStyle::GetFontSize() const {
return m_InheritedData.m_fFontSize;
}
FX_ARGB CFDE_CSSComputedStyle::GetColor() const {
return m_InheritedData.m_dwFontColor;
}
void CFDE_CSSComputedStyle::SetFontWeight(uint16_t wFontWeight) {
m_InheritedData.m_wFontWeight = wFontWeight;
}
void CFDE_CSSComputedStyle::SetFontVariant(FDE_CSSFONTVARIANT eFontVariant) {
m_InheritedData.m_eFontVariant = eFontVariant;
}
void CFDE_CSSComputedStyle::SetFontStyle(FDE_CSSFONTSTYLE eFontStyle) {
m_InheritedData.m_eFontStyle = eFontStyle;
}
void CFDE_CSSComputedStyle::SetFontSize(FX_FLOAT fFontSize) {
m_InheritedData.m_fFontSize = fFontSize;
}
void CFDE_CSSComputedStyle::SetColor(FX_ARGB dwFontColor) {
m_InheritedData.m_dwFontColor = dwFontColor;
}
const FDE_CSSRECT* CFDE_CSSComputedStyle::GetBorderWidth() const {
return m_NonInheritedData.m_bHasBorder ? &(m_NonInheritedData.m_BorderWidth)
: nullptr;
}
const FDE_CSSRECT* CFDE_CSSComputedStyle::GetMarginWidth() const {
return m_NonInheritedData.m_bHasMargin ? &(m_NonInheritedData.m_MarginWidth)
: nullptr;
}
const FDE_CSSRECT* CFDE_CSSComputedStyle::GetPaddingWidth() const {
return m_NonInheritedData.m_bHasPadding ? &(m_NonInheritedData.m_PaddingWidth)
: nullptr;
}
void CFDE_CSSComputedStyle::SetMarginWidth(const FDE_CSSRECT& rect) {
m_NonInheritedData.m_MarginWidth = rect;
m_NonInheritedData.m_bHasMargin = TRUE;
}
void CFDE_CSSComputedStyle::SetPaddingWidth(const FDE_CSSRECT& rect) {
m_NonInheritedData.m_PaddingWidth = rect;
m_NonInheritedData.m_bHasPadding = TRUE;
}
FDE_CSSDISPLAY CFDE_CSSComputedStyle::GetDisplay() const {
return static_cast<FDE_CSSDISPLAY>(m_NonInheritedData.m_eDisplay);
}
FX_FLOAT CFDE_CSSComputedStyle::GetLineHeight() const {
return m_InheritedData.m_fLineHeight;
}
const FDE_CSSLENGTH& CFDE_CSSComputedStyle::GetTextIndent() const {
return m_InheritedData.m_TextIndent;
}
FDE_CSSTEXTALIGN CFDE_CSSComputedStyle::GetTextAlign() const {
return static_cast<FDE_CSSTEXTALIGN>(m_InheritedData.m_eTextAligh);
}
FDE_CSSVERTICALALIGN CFDE_CSSComputedStyle::GetVerticalAlign() const {
return static_cast<FDE_CSSVERTICALALIGN>(m_NonInheritedData.m_eVerticalAlign);
}
FX_FLOAT CFDE_CSSComputedStyle::GetNumberVerticalAlign() const {
return m_NonInheritedData.m_fVerticalAlign;
}
uint32_t CFDE_CSSComputedStyle::GetTextDecoration() const {
return m_NonInheritedData.m_dwTextDecoration;
}
const FDE_CSSLENGTH& CFDE_CSSComputedStyle::GetLetterSpacing() const {
return m_InheritedData.m_LetterSpacing;
}
void CFDE_CSSComputedStyle::SetLineHeight(FX_FLOAT fLineHeight) {
m_InheritedData.m_fLineHeight = fLineHeight;
}
void CFDE_CSSComputedStyle::SetTextIndent(const FDE_CSSLENGTH& textIndent) {
m_InheritedData.m_TextIndent = textIndent;
}
void CFDE_CSSComputedStyle::SetTextAlign(FDE_CSSTEXTALIGN eTextAlign) {
m_InheritedData.m_eTextAligh = eTextAlign;
}
void CFDE_CSSComputedStyle::SetNumberVerticalAlign(FX_FLOAT fAlign) {
m_NonInheritedData.m_eVerticalAlign = FDE_CSSVERTICALALIGN_Number,
m_NonInheritedData.m_fVerticalAlign = fAlign;
}
void CFDE_CSSComputedStyle::SetTextDecoration(uint32_t dwTextDecoration) {
m_NonInheritedData.m_dwTextDecoration = dwTextDecoration;
}
void CFDE_CSSComputedStyle::SetLetterSpacing(
const FDE_CSSLENGTH& letterSpacing) {
m_InheritedData.m_LetterSpacing = letterSpacing;
}
void CFDE_CSSComputedStyle::AddCustomStyle(const CFX_WideString& wsName,
const CFX_WideString& wsValue) {
m_CustomProperties.Add(wsName);
m_CustomProperties.Add(wsValue);
}
CFDE_CSSInheritedData::CFDE_CSSInheritedData() {
Reset();
}
void CFDE_CSSInheritedData::Reset() {
FXSYS_memset(this, 0, sizeof(CFDE_CSSInheritedData));
m_LetterSpacing.Set(FDE_CSSLENGTHUNIT_Normal);
m_WordSpacing.Set(FDE_CSSLENGTHUNIT_Normal);
m_TextIndent.Set(FDE_CSSLENGTHUNIT_Point, 0);
m_fFontSize = 12.0f;
m_fLineHeight = 14.0f;
m_wFontWeight = 400;
m_dwFontColor = 0xFF000000;
m_iWidows = 2;
m_bTextEmphasisColorCurrent = TRUE;
m_iOrphans = 2;
}
CFDE_CSSNonInheritedData::CFDE_CSSNonInheritedData() {
Reset();
}
void CFDE_CSSNonInheritedData::Reset() {
FXSYS_memset(this, 0, sizeof(CFDE_CSSNonInheritedData));
m_PaddingWidth.Set(FDE_CSSLENGTHUNIT_Point, 0);
m_MarginWidth = m_PaddingWidth;
m_BorderWidth = m_PaddingWidth;
m_MinBoxSize.Set(FDE_CSSLENGTHUNIT_Point, 0);
m_MaxBoxSize.Set(FDE_CSSLENGTHUNIT_None);
m_eDisplay = FDE_CSSDISPLAY_Inline;
m_fVerticalAlign = 0.0f;
m_ColumnCount.Set(FDE_CSSLENGTHUNIT_Auto);
m_ColumnGap.Set(FDE_CSSLENGTHUNIT_Normal);
m_bColumnRuleColorSame = TRUE;
m_ColumnWidth.Set(FDE_CSSLENGTHUNIT_Auto);
m_ColumnRuleWidth.Set(FDE_CSSLENGTHUNIT_Auto);
m_eTextCombine = FDE_CSSTEXTCOMBINE_None;
}