~mmach/netext73/webkit2gtk

reflection->setOffset(reflectValue.offset().convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion>(builderState.cssToLengthConversionData()));

745

746

NinePieceImage mask(NinePieceImage::Type::Mask);

747

builderState.styleMap().mapNinePieceImage(CSSPropertyWebkitBoxReflect, reflectValue.mask(), mask);

748

reflection->setMask(mask);

749

750

return reflection;

751

}

752

753

inline IntSize BuilderConverter::convertInitialLetter(BuilderState&, const CSSValue& value)

754

{

755

auto& primitiveValue = downcast<CSSPrimitiveValue>(value);

756

757

if (primitiveValue.valueID() == CSSValueNormal)

758

return IntSize();

759

760

Pair* pair = primitiveValue.pairValue();

761

ASSERT(pair);

762

ASSERT(pair->first());

763

ASSERT(pair->second());

764

765

return IntSize(pair->first()->intValue(), pair->second()->intValue());

766

}

767

768

inline float BuilderConverter::convertTextStrokeWidth(BuilderState& builderState, const CSSValue& value)

769

{

770

auto& primitiveValue = downcast<CSSPrimitiveValue>(value);

771

772

float width = 0;

773

switch (primitiveValue.valueID()) {

774

case CSSValueThin:

775

case CSSValueMedium:

776

case CSSValueThick: {

777

double result = 1.0 / 48;

778

if (primitiveValue.valueID() == CSSValueMedium)

779

result *= 3;

780

else if (primitiveValue.valueID() == CSSValueThick)

781

result *= 5;

782

Ref<CSSPrimitiveValue> emsValue(CSSPrimitiveValue::create(result, CSSUnitType::CSS_EMS));

783

width = convertComputedLength<float>(builderState, emsValue);

784

break;

785

}

786

case CSSValueInvalid: {

787

width = convertComputedLength<float>(builderState, primitiveValue);

788

break;

789

}

790

default:

791

ASSERT_NOT_REACHED();

792

return 0;

793

}

794

795

return width;

796

}

797

798

inline OptionSet<LineBoxContain> BuilderConverter::convertLineBoxContain(BuilderState&, const CSSValue& value)

799

{

800

if (is<CSSPrimitiveValue>(value)) {

801

ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);

802

return { };

803

}

804

805

return downcast<CSSLineBoxContainValue>(value).value();

806

}

807

808

inline OptionSet<TextDecorationSkip> BuilderConverter::valueToDecorationSkip(const CSSPrimitiveValue& primitiveValue)

809

{

810

ASSERT(primitiveValue.isValueID());

811

812

switch (primitiveValue.valueID()) {

813

case CSSValueAuto:

814

return TextDecorationSkip::Auto;

815

case CSSValueNone:

816

return OptionSet<TextDecorationSkip> { };

817

case CSSValueInk:

818

return TextDecorationSkip::Ink;

819

case CSSValueObjects:

820

return TextDecorationSkip::Objects;

821

default:

822

break;

823

}

824

825

ASSERT_NOT_REACHED();

826

return OptionSet<TextDecorationSkip> { };

827

}

828

829

inline OptionSet<TextDecorationSkip> BuilderConverter::convertTextDecorationSkip(BuilderState&, const CSSValue& value)

830

{

831

if (is<CSSPrimitiveValue>(value))

832

return valueToDecorationSkip(downcast<CSSPrimitiveValue>(value));

833

834

OptionSet<TextDecorationSkip> skip;

835

for (auto& currentValue : downcast<CSSValueList>(value))

836

skip.add(valueToDecorationSkip(downcast<CSSPrimitiveValue>(currentValue.get())));

837

return skip;

838

}

839

840

static inline bool isImageShape(const CSSValue& value)

841

{

842

return is<CSSImageValue>(value) || is<CSSImageSetValue>(value) || is<CSSImageGeneratorValue>(value);

843

}

844

845

inline RefPtr<ShapeValue> BuilderConverter::convertShapeValue(BuilderState& builderState, CSSValue& value)

846

{

847

if (is<CSSPrimitiveValue>(value)) {

848

ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);

849

return nullptr;

850

}

851

852

if (isImageShape(value))

853

return ShapeValue::create(builderState.createStyleImage(value).releaseNonNull());

854

855

RefPtr<BasicShape> shape;

856

CSSBoxType referenceBox = CSSBoxType::BoxMissing;

857

for (auto& currentValue : downcast<CSSValueList>(value)) {

858

auto& primitiveValue = downcast<CSSPrimitiveValue>(currentValue.get());

859

if (primitiveValue.isShape())

860

shape = basicShapeForValue(builderState.cssToLengthConversionData(), *primitiveValue.shapeValue());

861

else if (primitiveValue.valueID() == CSSValueContentBox

862

|| primitiveValue.valueID() == CSSValueBorderBox

863

|| primitiveValue.valueID() == CSSValuePaddingBox

864

|| primitiveValue.valueID() == CSSValueMarginBox)

865

referenceBox = primitiveValue;

866

else {

867

ASSERT_NOT_REACHED();

868

return nullptr;

869

}

870

}

871

872

if (shape)

873

return ShapeValue::create(shape.releaseNonNull(), referenceBox);

874

875

if (referenceBox != CSSBoxType::BoxMissing)

876

return ShapeValue::create(referenceBox);

877

878

ASSERT_NOT_REACHED();

879

return nullptr;

880

}

881

882

#if ENABLE(CSS_SCROLL_SNAP)

883

884

inline ScrollSnapType BuilderConverter::convertScrollSnapType(BuilderState&, const CSSValue& value)

885

{

886

ScrollSnapType type;

887

auto& values = downcast<CSSValueList>(value);

888

auto& firstValue = downcast<CSSPrimitiveValue>(*values.item(0));

889

if (values.length() == 2) {

890

type.axis = firstValue;

891

type.strictness = downcast<CSSPrimitiveValue>(*values.item(1));

892

return type;

893

}

894

895

switch (firstValue.valueID()) {

896

case CSSValueNone:

897

case CSSValueMandatory:

898

case CSSValueProximity:

899

type.strictness = firstValue;

900

break;

901

default:

902

type.axis = firstValue;

903

type.strictness = ScrollSnapStrictness::Proximity;

904

break;

905

}

906

return type;

907

}

908

909

inline ScrollSnapAlign BuilderConverter::convertScrollSnapAlign(BuilderState&, const CSSValue& value)

910

{

911

auto& values = downcast<CSSValueList>(value);

912

ScrollSnapAlign alignment;

913

alignment.x = downcast<CSSPrimitiveValue>(*values.item(0));

914

if (values.length() == 1)

915

alignment.y = alignment.x;

916

else

917

alignment.y = downcast<CSSPrimitiveValue>(*values.item(1));

918

return alignment;

919

}

920

921

#endif

922

923

inline GridLength BuilderConverter::createGridTrackBreadth(const CSSPrimitiveValue& primitiveValue, BuilderState& builderState)

924

{

925

if (primitiveValue.valueID() == CSSValueMinContent || primitiveValue.valueID() == CSSValueWebkitMinContent)

926

return Length(MinContent);

927

928

if (primitiveValue.valueID() == CSSValueMaxContent || primitiveValue.valueID() == CSSValueWebkitMaxContent)

929

return Length(MaxContent);

930

931

// Fractional unit.

932

if (primitiveValue.isFlex())

933

return GridLength(primitiveValue.doubleValue());

934

935

return primitiveValue.convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion | AutoConversion>(builderState.cssToLengthConversionData());

936

}

937

938

inline GridTrackSize BuilderConverter::createGridTrackSize(const CSSValue& value, BuilderState& builderState)

939

{

940

if (is<CSSPrimitiveValue>(value))

941

return GridTrackSize(createGridTrackBreadth(downcast<CSSPrimitiveValue>(value), builderState));

942

943

ASSERT(is<CSSFunctionValue>(value));

944

const auto& function = downcast<CSSFunctionValue>(value);

945

946

if (function.length() == 1)

947

return GridTrackSize(createGridTrackBreadth(downcast<CSSPrimitiveValue>(*function.itemWithoutBoundsCheck(0)), builderState), FitContentTrackSizing);

948

949

RELEASE_ASSERT_WITH_SECURITY_IMPLICATION(function.length() == 2);

950

GridLength minTrackBreadth(createGridTrackBreadth(downcast<CSSPrimitiveValue>(*function.itemWithoutBoundsCheck(0)), builderState));

951

GridLength maxTrackBreadth(createGridTrackBreadth(downcast<CSSPrimitiveValue>(*function.itemWithoutBoundsCheck(1)), builderState));

952

return GridTrackSize(minTrackBreadth, maxTrackBreadth);

953

}

954

955

static void createGridLineNamesList(const CSSValue& value, unsigned currentNamedGridLine, NamedGridLinesMap& namedGridLines, OrderedNamedGridLinesMap& orderedNamedGridLines)

956

{

957

ASSERT(value.isGridLineNamesValue());

958

959

for (auto& namedGridLineValue : downcast<CSSGridLineNamesValue>(value)) {

960

String namedGridLine = downcast<CSSPrimitiveValue>(namedGridLineValue.get()).stringValue();

961

auto result = namedGridLines.add(namedGridLine, Vector<unsigned>());

962

result.iterator->value.append(currentNamedGridLine);

963

auto orderedResult = orderedNamedGridLines.add(currentNamedGridLine, Vector<String>());

964

orderedResult.iterator->value.append(namedGridLine);

965

}

966

}

967

968

struct BuilderConverter::TracksData {

969

WTF_MAKE_NONCOPYABLE(TracksData); WTF_MAKE_FAST_ALLOCATED;

970

public:

971

TracksData() = default;

972

973

Vector<GridTrackSize> m_trackSizes;

974

NamedGridLinesMap m_namedGridLines;

975

OrderedNamedGridLinesMap m_orderedNamedGridLines;

976

Vector<GridTrackSize> m_autoRepeatTrackSizes;

977

NamedGridLinesMap m_autoRepeatNamedGridLines;

978

OrderedNamedGridLinesMap m_autoRepeatOrderedNamedGridLines;

979

unsigned m_autoRepeatInsertionPoint { RenderStyle::initialGridAutoRepeatInsertionPoint() };

980

AutoRepeatType m_autoRepeatType { RenderStyle::initialGridAutoRepeatType() };

981

};

982

983

inline bool BuilderConverter::createGridTrackList(const CSSValue& value, TracksData& tracksData, BuilderState& builderState)

984

{

985

// Handle 'none'.

986

if (is<CSSPrimitiveValue>(value))

987

return downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone;

988

989

if (!is<CSSValueList>(value))

990

return false;

991

992

unsigned currentNamedGridLine = 0;

993

auto handleLineNameOrTrackSize = [&](const CSSValue& currentValue) {

994

if (is<CSSGridLineNamesValue>(currentValue))

995

createGridLineNamesList(currentValue, currentNamedGridLine, tracksData.m_namedGridLines, tracksData.m_orderedNamedGridLines);

996

else {

997

++currentNamedGridLine;

998

tracksData.m_trackSizes.append(createGridTrackSize(currentValue, builderState));

999

}

1000

};

1001

1002

for (auto& currentValue : downcast<CSSValueList>(value)) {

1003

if (is<CSSGridAutoRepeatValue>(currentValue)) {

1004

ASSERT(tracksData.m_autoRepeatTrackSizes.isEmpty());

1005

unsigned autoRepeatIndex = 0;

1006

CSSValueID autoRepeatID = downcast<CSSGridAutoRepeatValue>(currentValue.get()).autoRepeatID();

1007

ASSERT(autoRepeatID == CSSValueAutoFill || autoRepeatID == CSSValueAutoFit);

1008

tracksData.m_autoRepeatType = autoRepeatID == CSSValueAutoFill ? AutoRepeatType::Fill : AutoRepeatType::Fit;

1009

for (auto& autoRepeatValue : downcast<CSSValueList>(currentValue.get())) {

1010

if (is<CSSGridLineNamesValue>(autoRepeatValue)) {

1011

createGridLineNamesList(autoRepeatValue.get(), autoRepeatIndex, tracksData.m_autoRepeatNamedGridLines, tracksData.m_autoRepeatOrderedNamedGridLines);

1012

continue;

1013

}

1014

++autoRepeatIndex;

1015

tracksData.m_autoRepeatTrackSizes.append(createGridTrackSize(autoRepeatValue.get(), builderState));

1016

}

1017

tracksData.m_autoRepeatInsertionPoint = currentNamedGridLine++;

1018

continue;

1019

}

1020

1021

if (is<CSSGridIntegerRepeatValue>(currentValue)) {

1022

size_t repetitions = downcast<CSSGridIntegerRepeatValue>(currentValue.get()).repetitions();

1023

for (size_t i = 0; i < repetitions; ++i) {

1024

for (auto& integerRepeatValue : downcast<CSSValueList>(currentValue.get()))

1025

handleLineNameOrTrackSize(integerRepeatValue);

1026

}

1027

continue;

1028

}

1029

1030

handleLineNameOrTrackSize(currentValue);

1031

}

1032

1033

// The parser should have rejected any <track-list> without any <track-size> as

1034

// this is not conformant to the syntax.

1035

ASSERT(!tracksData.m_trackSizes.isEmpty() || !tracksData.m_autoRepeatTrackSizes.isEmpty());

1036

return true;

1037

}

1038

1039

inline bool BuilderConverter::createGridPosition(const CSSValue& value, GridPosition& position)

1040

{

1041

// We accept the specification's grammar:

1042

// auto | <custom-ident> | [ <integer> && <custom-ident>? ] | [ span && [ <integer> || <custom-ident> ] ]

1043

if (is<CSSPrimitiveValue>(value)) {

1044

auto& primitiveValue = downcast<CSSPrimitiveValue>(value);

1045

// We translate <ident> to <string> during parsing as it makes handling it simpler.

1046

if (primitiveValue.isString()) {

1047

position.setNamedGridArea(primitiveValue.stringValue());

1048

return true;

1049

}

1050

1051

ASSERT(primitiveValue.valueID() == CSSValueAuto);

1052

return true;

1053

}

1054

1055

auto& values = downcast<CSSValueList>(value);

1056

ASSERT(values.length());

1057

1058

auto it = values.begin();

1059

const CSSPrimitiveValue* currentValue = &downcast<CSSPrimitiveValue>(it->get());

1060

bool isSpanPosition = false;

1061

if (currentValue->valueID() == CSSValueSpan) {

1062

isSpanPosition = true;

1063

++it;

1064

currentValue = it != values.end() ? &downcast<CSSPrimitiveValue>(it->get()) : nullptr;

1065

}

1066

1067

int gridLineNumber = 0;

1068

if (currentValue && currentValue->isNumber()) {

1069

gridLineNumber = currentValue->intValue();

1070

++it;

1071

currentValue = it != values.end() ? &downcast<CSSPrimitiveValue>(it->get()) : nullptr;

1072

}

1073

1074

String gridLineName;

1075

if (currentValue && currentValue->isString()) {

1076

gridLineName = currentValue->stringValue();

1077

++it;

1078

}

1079

1080

ASSERT(it == values.end());

1081

if (isSpanPosition)

1082

position.setSpanPosition(gridLineNumber ? gridLineNumber : 1, gridLineName);

1083

else

1084

position.setExplicitPosition(gridLineNumber, gridLineName);

1085

1086

return true;

1087

}

1088

1089

inline void BuilderConverter::createImplicitNamedGridLinesFromGridArea(const NamedGridAreaMap& namedGridAreas, NamedGridLinesMap& namedGridLines, GridTrackSizingDirection direction)

1090

{

1091

for (auto& area : namedGridAreas) {

1092

GridSpan areaSpan = direction == ForRows ? area.value.rows : area.value.columns;

1093

{

1094

auto& startVector = namedGridLines.add(area.key + "-start", Vector<unsigned>()).iterator->value;

1095

startVector.append(areaSpan.startLine());

1096

std::sort(startVector.begin(), startVector.end());

1097

}

1098

{

1099

auto& endVector = namedGridLines.add(area.key + "-end", Vector<unsigned>()).iterator->value;

1100

endVector.append(areaSpan.endLine());

1101

std::sort(endVector.begin(), endVector.end());

1102

}

1103

}

1104

}

1105

1106

inline Vector<GridTrackSize> BuilderConverter::convertGridTrackSizeList(BuilderState& builderState, const CSSValue& value)

1107

{

1108

ASSERT(value.isValueList());

1109

auto& valueList = downcast<CSSValueList>(value);

1110

Vector<GridTrackSize> trackSizes;

1111

trackSizes.reserveInitialCapacity(valueList.length());

1112

for (auto& currValue : valueList) {

1113

ASSERT(!currValue->isGridLineNamesValue());

1114

ASSERT(!currValue->isGridAutoRepeatValue());

1115

ASSERT(!currValue->isGridIntegerRepeatValue());

1116

trackSizes.uncheckedAppend(convertGridTrackSize(builderState, currValue));

1117

}

1118

return trackSizes;

1119

}

1120

1121

inline GridTrackSize BuilderConverter::convertGridTrackSize(BuilderState& builderState, const CSSValue& value)

1122

{

1123

return createGridTrackSize(value, builderState);

1124

}

1125

1126

inline Optional<GridPosition> BuilderConverter::convertGridPosition(BuilderState&, const CSSValue& value)

1127

{

1128

GridPosition gridPosition;

1129

if (createGridPosition(value, gridPosition))

1130

return gridPosition;

1131

return WTF::nullopt;

1132

}

1133

1134

inline GridAutoFlow BuilderConverter::convertGridAutoFlow(BuilderState&, const CSSValue& value)

1135

{

1136

auto& list = downcast<CSSValueList>(value);

1137

if (!list.length())

1138

return RenderStyle::initialGridAutoFlow();

1139

1140

auto& first = downcast<CSSPrimitiveValue>(*list.item(0));

1141

auto* second = downcast<CSSPrimitiveValue>(list.item(1));

1142

1143

GridAutoFlow autoFlow;

1144

switch (first.valueID()) {

1145

case CSSValueRow:

1146

if (second && second->valueID() == CSSValueDense)

1147

autoFlow = AutoFlowRowDense;

1148

else

1149

autoFlow = AutoFlowRow;

1150

break;

1151

case CSSValueColumn:

1152

if (second && second->valueID() == CSSValueDense)

1153

autoFlow = AutoFlowColumnDense;

1154

else

1155

autoFlow = AutoFlowColumn;

1156

break;

1157

case CSSValueDense:

1158

if (second && second->valueID() == CSSValueColumn)

1159

autoFlow = AutoFlowColumnDense;

1160

else

1161

autoFlow = AutoFlowRowDense;

1162

break;

1163

default:

1164

ASSERT_NOT_REACHED();

1165

autoFlow = RenderStyle::initialGridAutoFlow();

1166

break;

1167

}

1168

1169

return autoFlow;

1170

}

1171

1172

inline CSSToLengthConversionData BuilderConverter::csstoLengthConversionDataWithTextZoomFactor(BuilderState& builderState)

1173

{

1174

if (auto* frame = builderState.document().frame()) {

1175

float textZoomFactor = builderState.style().textZoom() != TextZoom::Reset ? frame->textZoomFactor() : 1.0f;

1176

return builderState.cssToLengthConversionData().copyWithAdjustedZoom(builderState.style().effectiveZoom() * textZoomFactor);

1177

}

1178

return builderState.cssToLengthConversionData();

1179

}

1180

1181

inline Optional<Length> BuilderConverter::convertWordSpacing(BuilderState& builderState, const CSSValue& value)

1182

{

1183

Optional<Length> wordSpacing;

1184

auto& primitiveValue = downcast<CSSPrimitiveValue>(value);

1185

if (primitiveValue.valueID() == CSSValueNormal)

1186

wordSpacing = RenderStyle::initialWordSpacing();

1187

else if (primitiveValue.isLength())

1188

wordSpacing = primitiveValue.computeLength<Length>(csstoLengthConversionDataWithTextZoomFactor(builderState));

1189

else if (primitiveValue.isPercentage())

1190

wordSpacing = Length(clampTo<float>(primitiveValue.doubleValue(), minValueForCssLength, maxValueForCssLength), Percent);

1191

else if (primitiveValue.isNumber())

1192

wordSpacing = Length(primitiveValue.doubleValue(), Fixed);

1193

1194

return wordSpacing;

1195

}

1196

1197

inline Optional<float> BuilderConverter::convertPerspective(BuilderState& builderState, const CSSValue& value)

1198

{

1199

auto& primitiveValue = downcast<CSSPrimitiveValue>(value);

1200

if (primitiveValue.valueID() == CSSValueNone)

1201

return 0.f;

1202

1203

float perspective = -1;

1204

if (primitiveValue.isLength())

1205

perspective = primitiveValue.computeLength<float>(builderState.cssToLengthConversionData());

1206

else if (primitiveValue.isNumber())

1207

perspective = primitiveValue.doubleValue() * builderState.cssToLengthConversionData().zoom();

1208

else

1209

ASSERT_NOT_REACHED();

1210

1211

return perspective < 0 ? Optional<float>(WTF::nullopt) : Optional<float>(perspective);

1212

}

1213

1214

inline Optional<Length> BuilderConverter::convertMarqueeIncrement(BuilderState& builderState, const CSSValue& value)

1215

{

1216

Length length = downcast<CSSPrimitiveValue>(value).convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion>(builderState.cssToLengthConversionData().copyWithAdjustedZoom(1.0f));

1217

if (length.isUndefined())

1218

return WTF::nullopt;

1219

return length;

1220

}

1221

1222

inline Optional<FilterOperations> BuilderConverter::convertFilterOperations(BuilderState& builderState, const CSSValue& value)

1223

{

1224

FilterOperations operations;

1225

if (builderState.createFilterOperations(value, operations))

1226

return operations;

1227

return WTF::nullopt;

1228

}

1229

1230

inline FontFeatureSettings BuilderConverter::convertFontFeatureSettings(BuilderState&, const CSSValue& value)

1231

{

1232

if (is<CSSPrimitiveValue>(value)) {

1233

ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNormal);

1234

return { };

1235

}

1236

1237

FontFeatureSettings settings;

1238

for (auto& item : downcast<CSSValueList>(value)) {

1239

auto& feature = downcast<CSSFontFeatureValue>(item.get());

1240

settings.insert(FontFeature(feature.tag(), feature.value()));

1241

}

1242

return settings;

1243

}

1244

1245

inline FontSelectionValue BuilderConverter::convertFontWeightFromValue(const CSSValue& value)

1246

{

1247

ASSERT(is<CSSPrimitiveValue>(value));

1248

auto& primitiveValue = downcast<CSSPrimitiveValue>(value);

1249

1250

if (primitiveValue.isNumber())

1251

return FontSelectionValue::clampFloat(primitiveValue.floatValue());

1252

1253

ASSERT(primitiveValue.isValueID());

1254

switch (primitiveValue.valueID()) {

1255

case CSSValueNormal:

1256

return normalWeightValue();

1257

case CSSValueBold:

1258

case CSSValueBolder:

1259

return boldWeightValue();

1260

case CSSValueLighter:

1261

return lightWeightValue();

1262

default:

1263

ASSERT_NOT_REACHED();

1264

return normalWeightValue();

1265

}

1266

}

1267

1268

inline FontSelectionValue BuilderConverter::convertFontStretchFromValue(const CSSValue& value)

1269

{

1270

ASSERT(is<CSSPrimitiveValue>(value));

1271

const auto& primitiveValue = downcast<CSSPrimitiveValue>(value);

1272

1273

if (primitiveValue.isPercentage())

1274

return FontSelectionValue::clampFloat(primitiveValue.floatValue());

1275

1276

ASSERT(primitiveValue.isValueID());

1277

if (auto value = fontStretchValue(primitiveValue.valueID()))

1278

return value.value();

1279

ASSERT_NOT_REACHED();

1280

return normalStretchValue();

1281

}

1282

1283

// The input value needs to parsed and valid, this function returns WTF::nullopt if the input was "normal".

1284

inline Optional<FontSelectionValue> BuilderConverter::convertFontStyleFromValue(const CSSValue& value)

1285

{

1286

ASSERT(is<CSSFontStyleValue>(value));

1287

const auto& fontStyleValue = downcast<CSSFontStyleValue>(value);

1288

1289

auto valueID = fontStyleValue.fontStyleValue->valueID();

1290

if (valueID == CSSValueNormal)

1291

return WTF::nullopt;

1292

if (valueID == CSSValueItalic)

1293

return italicValue();

1294

ASSERT(valueID == CSSValueOblique);

1295

if (auto* obliqueValue = fontStyleValue.obliqueValue.get())

1296

return FontSelectionValue(obliqueValue->value<float>(CSSUnitType::CSS_DEG));

1297

return italicValue();

1298

}

1299

1300

inline FontSelectionValue BuilderConverter::convertFontWeight(BuilderState& builderState, const CSSValue& value)

1301

{

1302

ASSERT(is<CSSPrimitiveValue>(value));

1303

auto& primitiveValue = downcast<CSSPrimitiveValue>(value);

1304

if (primitiveValue.isValueID()) {

1305

auto valueID = primitiveValue.valueID();

1306

if (valueID == CSSValueBolder)

1307

return FontCascadeDescription::bolderWeight(builderState.parentStyle().fontDescription().weight());

1308

if (valueID == CSSValueLighter)

1309

return FontCascadeDescription::lighterWeight(builderState.parentStyle().fontDescription().weight());

1310

}

1311

return convertFontWeightFromValue(value);

1312

}

1313

1314

inline FontSelectionValue BuilderConverter::convertFontStretch(BuilderState&, const CSSValue& value)

1315

{

1316

return convertFontStretchFromValue(value);

1317

}

1318

1319

#if ENABLE(VARIATION_FONTS)

1320

inline FontVariationSettings BuilderConverter::convertFontVariationSettings(BuilderState&, const CSSValue& value)

1321

{

1322

if (is<CSSPrimitiveValue>(value)) {

1323

ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNormal);

1324

return { };

1325

}

1326

1327

FontVariationSettings settings;

1328

for (auto& item : downcast<CSSValueList>(value)) {

1329

auto& feature = downcast<CSSFontVariationValue>(item.get());

1330

settings.insert({ feature.tag(), feature.value() });

1331

}

1332

return settings;

1333

}

1334

#endif

1335

1336

#if PLATFORM(IOS_FAMILY)

1337

inline bool BuilderConverter::convertTouchCallout(BuilderState&, const CSSValue& value)

1338

{

1339

return !equalLettersIgnoringASCIICase(downcast<CSSPrimitiveValue>(value).stringValue(), "none");

1340

}

1341

#endif

1342

1343

#if ENABLE(TOUCH_EVENTS)

1344

inline Color BuilderConverter::convertTapHighlightColor(BuilderState& builderState, const CSSValue& value)

1345

{

1346

return builderState.colorFromPrimitiveValue(downcast<CSSPrimitiveValue>(value));

1347

}

1348

#endif

1349

1350

#if ENABLE(POINTER_EVENTS)

1351

inline OptionSet<TouchAction> BuilderConverter::convertTouchAction(BuilderState&, const CSSValue& value)

1352

{

1353

if (is<CSSPrimitiveValue>(value))

1354

return downcast<CSSPrimitiveValue>(value);

1355

1356

if (is<CSSValueList>(value)) {

1357

OptionSet<TouchAction> touchActions;

1358

for (auto& currentValue : downcast<CSSValueList>(value)) {

1359

auto& primitiveValue = downcast<CSSPrimitiveValue>(currentValue.get());

1360

auto primitiveValueID = primitiveValue.valueID();

1361

if (primitiveValueID != CSSValuePanX && primitiveValueID != CSSValuePanY && primitiveValueID != CSSValuePinchZoom)

1362

return RenderStyle::initialTouchActions();

1363

touchActions.add(primitiveValue);

1364

}

1365

return touchActions;

1366

}

1367

1368

return RenderStyle::initialTouchActions();

1369

}

1370

#endif

1371

1372

#if ENABLE(OVERFLOW_SCROLLING_TOUCH)

1373

inline bool BuilderConverter::convertOverflowScrolling(BuilderState&, const CSSValue& value)

1374

{

1375

return downcast<CSSPrimitiveValue>(value).valueID() == CSSValueTouch;

1376

}

1377

#endif

1378

1379

inline bool BuilderConverter::convertSmoothScrolling(BuilderState&, const CSSValue& value)

1380

{

1381

return downcast<CSSPrimitiveValue>(value).valueID() == CSSValueSmooth;

1382

}

1383

1384

inline SVGLengthValue BuilderConverter::convertSVGLengthValue(BuilderState&, const CSSValue& value)

1385

{

1386

return SVGLengthValue::fromCSSPrimitiveValue(downcast<CSSPrimitiveValue>(value));

1387

}

1388

1389

inline Vector<SVGLengthValue> BuilderConverter::convertSVGLengthVector(BuilderState& builderState, const CSSValue& value)

1390

{

1391

auto& valueList = downcast<CSSValueList>(value);

1392

1393

Vector<SVGLengthValue> svgLengths;

1394

svgLengths.reserveInitialCapacity(valueList.length());

1395

for (auto& item : valueList)

1396

svgLengths.uncheckedAppend(convertSVGLengthValue(builderState, item));

1397

1398

return svgLengths;

1399

}

1400

1401

inline Vector<SVGLengthValue> BuilderConverter::convertStrokeDashArray(BuilderState& builderState, const CSSValue& value)

1402

{

1403

if (is<CSSPrimitiveValue>(value)) {

1404

ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);

1405

return SVGRenderStyle::initialStrokeDashArray();

1406

}

1407

1408

return convertSVGLengthVector(builderState, value);

1409

}

1410

1411

inline PaintOrder BuilderConverter::convertPaintOrder(BuilderState&, const CSSValue& value)

1412

{

1413

if (is<CSSPrimitiveValue>(value)) {

1414

ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNormal);

1415

return PaintOrder::Normal;

1416

}

1417

1418

auto& orderTypeList = downcast<CSSValueList>(value);

1419

switch (downcast<CSSPrimitiveValue>(*orderTypeList.itemWithoutBoundsCheck(0)).valueID()) {

1420

case CSSValueFill:

1421

return orderTypeList.length() > 1 ? PaintOrder::FillMarkers : PaintOrder::Fill;

1422

case CSSValueStroke:

1423

return orderTypeList.length() > 1 ? PaintOrder::StrokeMarkers : PaintOrder::Stroke;

1424

case CSSValueMarkers:

1425

return orderTypeList.length() > 1 ? PaintOrder::MarkersStroke : PaintOrder::Markers;

1426

default:

1427

ASSERT_NOT_REACHED();

1428

return PaintOrder::Normal;

1429

}

1430

}

1431

1432

inline float BuilderConverter::convertOpacity(BuilderState&, const CSSValue& value)

1433

{

1434

auto& primitiveValue = downcast<CSSPrimitiveValue>(value);

1435

float opacity = primitiveValue.floatValue();

1436

if (primitiveValue.isPercentage())

1437

opacity /= 100.0f;

1438

return std::max(0.0f, std::min(1.0f, opacity));

1439

}

1440

1441

inline String BuilderConverter::convertSVGURIReference(BuilderState& builderState, const CSSValue& value)

1442

{

1443

String s;

1444

auto& primitiveValue = downcast<CSSPrimitiveValue>(value);

1445

if (primitiveValue.isURI())

1446

s = primitiveValue.stringValue();

1447

1448

return SVGURIReference::fragmentIdentifierFromIRIString(s, builderState.document());

1449

}

1450

1451

inline Color BuilderConverter::convertSVGColor(BuilderState& builderState, const CSSValue& value)

1452

{

1453

return builderState.colorFromPrimitiveValue(downcast<CSSPrimitiveValue>(value));

1454

}

1455

1456

inline StyleSelfAlignmentData BuilderConverter::convertSelfOrDefaultAlignmentData(BuilderState&, const CSSValue& value)

1457

{

1458

StyleSelfAlignmentData alignmentData = RenderStyle::initialSelfAlignment();

1459

auto& primitiveValue = downcast<CSSPrimitiveValue>(value);

1460

if (Pair* pairValue = primitiveValue.pairValue()) {

1461

if (pairValue->first()->valueID() == CSSValueLegacy) {

1462

alignmentData.setPositionType(ItemPositionType::Legacy);

1463

alignmentData.setPosition(*pairValue->second());

1464

} else if (pairValue->first()->valueID() == CSSValueFirst)

1465

alignmentData.setPosition(ItemPosition::Baseline);

1466

else if (pairValue->first()->valueID() == CSSValueLast)

1467

alignmentData.setPosition(ItemPosition::LastBaseline);

1468

else {

1469

alignmentData.setOverflow(*pairValue->first());

1470

alignmentData.setPosition(*pairValue->second());

1471

}

1472

} else

1473

alignmentData.setPosition(primitiveValue);

1474

return alignmentData;

1475

}

1476

1477

inline StyleContentAlignmentData BuilderConverter::convertContentAlignmentData(BuilderState&, const CSSValue& value)

1478

{

1479

StyleContentAlignmentData alignmentData = RenderStyle::initialContentAlignment();

1480

if (!is<CSSContentDistributionValue>(value))

1481

return alignmentData;

1482

auto& contentValue = downcast<CSSContentDistributionValue>(value);

1483

if (contentValue.distribution()->valueID() != CSSValueInvalid)

1484

alignmentData.setDistribution(contentValue.distribution().get());

1485

if (contentValue.position()->valueID() != CSSValueInvalid)

1486

alignmentData.setPosition(contentValue.position().get());

1487

if (contentValue.overflow()->valueID() != CSSValueInvalid)

1488

alignmentData.setOverflow(contentValue.overflow().get());

1489

return alignmentData;

1490

}

1491

1492

inline GlyphOrientation BuilderConverter::convertGlyphOrientation(BuilderState&, const CSSValue& value)

1493

{

1494

float angle = fabsf(fmodf(downcast<CSSPrimitiveValue>(value).floatValue(), 360.0f));

1495

if (angle <= 45.0f || angle > 315.0f)

1496

return GlyphOrientation::Degrees0;

1497

if (angle > 45.0f && angle <= 135.0f)

1498

return GlyphOrientation::Degrees90;

1499

if (angle > 135.0f && angle <= 225.0f)

1500

return GlyphOrientation::Degrees180;

1501

return GlyphOrientation::Degrees270;

1502

}

1503

1504

inline GlyphOrientation BuilderConverter::convertGlyphOrientationOrAuto(BuilderState& builderState, const CSSValue& value)

1505

{

1506

if (downcast<CSSPrimitiveValue>(value).valueID() == CSSValueAuto)

1507

return GlyphOrientation::Auto;

1508

return convertGlyphOrientation(builderState, value);

1509

}

1510

1511

inline Optional<Length> BuilderConverter::convertLineHeight(BuilderState& builderState, const CSSValue& value, float multiplier)

1512

{

1513

auto& primitiveValue = downcast<CSSPrimitiveValue>(value);

1514

if (primitiveValue.valueID() == CSSValueNormal)

1515

return RenderStyle::initialLineHeight();

1516

1517

if (primitiveValue.isLength()) {

1518

Length length = primitiveValue.computeLength<Length>(BuilderConverter::csstoLengthConversionDataWithTextZoomFactor(builderState));

1519

if (multiplier != 1.f)

1520

length = Length(length.value() * multiplier, Fixed);

1521

return length;

1522

}

1523

1524

// Line-height percentages need to inherit as if they were Fixed pixel values. In the example:

1525

// <div style="font-size: 10px; line-height: 150%;"><div style="font-size: 100px;"></div></div>

1526

// the inner element should have line-height of 15px. However, in this example:

1527

// <div style="font-size: 10px; line-height: 1.5;"><div style="font-size: 100px;"></div></div>

1528

// the inner element should have a line-height of 150px. Therefore, we map percentages to Fixed

1529

// values and raw numbers to percentages.

1530

if (primitiveValue.isPercentage()) {

1531

// FIXME: percentage should not be restricted to an integer here.

1532

return Length((builderState.style().computedFontSize() * primitiveValue.intValue()) / 100, Fixed);

1533

}

1534

if (primitiveValue.isNumber())

1535

return Length(primitiveValue.doubleValue() * 100.0, Percent);

1536

1537

// FIXME: The parser should only emit the above types, so this should never be reached. We should change the

1538

// type of this function to return just a Length (and not an Optional).

1539

return WTF::nullopt;

1540

}

1541

1542

inline FontSynthesis BuilderConverter::convertFontSynthesis(BuilderState&, const CSSValue& value)

1543

{

1544

if (is<CSSPrimitiveValue>(value)) {

1545

ASSERT(downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNone);

1546

return FontSynthesisNone;

1547

}

1548

1549

FontSynthesis result = FontSynthesisNone;

1550

ASSERT(is<CSSValueList>(value));

1551

for (const CSSValue& v : downcast<CSSValueList>(value)) {

1552

switch (downcast<CSSPrimitiveValue>(v).valueID()) {

1553

case CSSValueWeight:

1554

result |= FontSynthesisWeight;

1555

break;

1556

case CSSValueStyle:

1557

result |= FontSynthesisStyle;

1558

break;

1559

case CSSValueSmallCaps:

1560

result |= FontSynthesisSmallCaps;

1561

break;

1562

default:

1563

ASSERT_NOT_REACHED();

1564

break;

1565

}

1566

}

1567

1568

return result;

1569

}

1570

1571

inline OptionSet<SpeakAs> BuilderConverter::convertSpeakAs(BuilderState&, const CSSValue& value)

1572

{

1573

auto result = RenderStyle::initialSpeakAs();

1574

if (is<CSSValueList>(value)) {

1575

for (auto& currentValue : downcast<CSSValueList>(value))

1576

result.add(downcast<CSSPrimitiveValue>(currentValue.get()));

1577

}

1578

return result;

1579

}

1580

1581

inline OptionSet<HangingPunctuation> BuilderConverter::convertHangingPunctuation(BuilderState&, const CSSValue& value)

1582

{

1583

auto result = RenderStyle::initialHangingPunctuation();

1584

if (is<CSSValueList>(value)) {

1585

for (auto& currentValue : downcast<CSSValueList>(value))

1586

result.add(downcast<CSSPrimitiveValue>(currentValue.get()));

1587

}

1588

return result;

1589

}

1590

1591

inline GapLength BuilderConverter::convertGapLength(BuilderState& builderState, const CSSValue& value)

1592

{

1593

return (downcast<CSSPrimitiveValue>(value).valueID() == CSSValueNormal) ? GapLength() : GapLength(convertLength(builderState, value));

1594

}

1595

1596

}

1597

}

Older »